INFO: No output directory specified (--dir)
INFO: Using directory: "Single_crystal_validation_20250816_160706"
INFO: Regenerating c-file: Single_crystal_validation.c
DEBUG: CMD: /home/willend/micromamba/bin/mcstas -t -o ./Single_crystal_validation.c Single_crystal_validation.instr
Warning: DECLARE block contains 2 assignments (= sign).
         Move them into an INITIALIZE section. May fail at compile.
CFLAGS= -DFUNNEL 
          
WARNING:
 The parameter mosaic_AB of Single_crystal_test_process is initialized 
 using a static {,,,} vector.
  -> Such static vectors support literal numbers ONLY.
  -> Any vector use of variables or defines must happen via a 
     DECLARE/INITIALIZE pointer.


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


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

Generating single GPU kernel or single CPU section layout: 

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

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

-----------------------------------------------------------
DEBUG: CMD: /home/willend/micromamba/bin/mcstas finished
INFO: Linting generated code: ./Single_crystal_validation.c
DEBUG: CMD: cppcheck ./Single_crystal_validation.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 Single_crystal_validation.c ...
Checking Single_crystal_validation.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...
Single_crystal_validation.c:20706:16: error: Memory leak: OUTFILE [memleak]
    if (!file) return(NULL);
               ^
Single_crystal_validation.c:7848:5: error: Memory leak: temp_logger_with_data.logger_pointers [memleak]
    } else {
    ^
Single_crystal_validation.c:7878:5: error: Memory leak: temp_abs_logger_with_data.abs_logger_pointers [memleak]
    } else {
    ^
Single_crystal_validation.c:8509:5: error: Memory leak: temp_history.elements [memleak]
    } else {
    ^
Single_crystal_validation.c:14754:5: error: Memory leak: removed_under_2.elements [memleak]
    };
    ^
Single_crystal_validation.c:7739: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];
                                                                 ^
Single_crystal_validation.c:7738:22: note: Assuming allocation function fails
        temp = malloc(list->num_elements * sizeof(int));
                     ^
Single_crystal_validation.c:7738:22: note: Assignment 'temp=malloc(list->num_elements*sizeof(int))', assigned value is 0
        temp = malloc(list->num_elements * sizeof(int));
                     ^
Single_crystal_validation.c:7739:66: note: Null pointer dereference
        for (iterate = 0;iterate < list->num_elements;iterate++) temp[iterate] = list->elements[iterate];
                                                                 ^
Single_crystal_validation.c:7742: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];
                                                                                           ^
Single_crystal_validation.c:7738:22: note: Assuming allocation function fails
        temp = malloc(list->num_elements * sizeof(int));
                     ^
Single_crystal_validation.c:7738:22: note: Assignment 'temp=malloc(list->num_elements*sizeof(int))', assigned value is 0
        temp = malloc(list->num_elements * sizeof(int));
                     ^
Single_crystal_validation.c:7742:92: note: Null pointer dereference
        for (iterate = 0;iterate < list->num_elements;iterate++) list->elements[iterate] = temp[iterate];
                                                                                           ^
Single_crystal_validation.c:7776: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];
                                                           ^
Single_crystal_validation.c:7774:26: note: Assuming allocation function fails
      double *temp=malloc(list->num_elements*sizeof(double));
                         ^
Single_crystal_validation.c:7774:26: note: Assignment 'temp=malloc(list->num_elements*sizeof(double))', assigned value is 0
      double *temp=malloc(list->num_elements*sizeof(double));
                         ^
Single_crystal_validation.c:7776:60: note: Null pointer dereference
      for (iterate=0;iterate<list->num_elements;iterate++) temp[iterate] = list->elements[iterate];
                                                           ^
Single_crystal_validation.c:7780: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];
                                                                                       ^
Single_crystal_validation.c:7774:26: note: Assuming allocation function fails
      double *temp=malloc(list->num_elements*sizeof(double));
                         ^
Single_crystal_validation.c:7774:26: note: Assignment 'temp=malloc(list->num_elements*sizeof(double))', assigned value is 0
      double *temp=malloc(list->num_elements*sizeof(double));
                         ^
Single_crystal_validation.c:7780:88: note: Null pointer dereference
      for (iterate=0;iterate<list->num_elements-1;iterate++) list->elements[iterate] = temp[iterate];
                                                                                       ^
Single_crystal_validation.c:7794: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];
                                                           ^
Single_crystal_validation.c:7792:26: note: Assuming allocation function fails
      double *temp=malloc(list->num_elements*sizeof(double));
                         ^
Single_crystal_validation.c:7792:26: note: Assignment 'temp=malloc(list->num_elements*sizeof(double))', assigned value is 0
      double *temp=malloc(list->num_elements*sizeof(double));
                         ^
Single_crystal_validation.c:7794:60: note: Null pointer dereference
      for (iterate=0;iterate<list->num_elements;iterate++) temp[iterate] = list->elements[iterate];
                                                           ^
Single_crystal_validation.c:7798: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];
                                                                                       ^
Single_crystal_validation.c:7792:26: note: Assuming allocation function fails
      double *temp=malloc(list->num_elements*sizeof(double));
                         ^
Single_crystal_validation.c:7792:26: note: Assignment 'temp=malloc(list->num_elements*sizeof(double))', assigned value is 0
      double *temp=malloc(list->num_elements*sizeof(double));
                         ^
Single_crystal_validation.c:7798:88: note: Null pointer dereference
      for (iterate=0;iterate<list->num_elements-1;iterate++) list->elements[iterate] = temp[iterate];
                                                                                       ^
Single_crystal_validation.c:7813: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];
                                                                       ^
Single_crystal_validation.c:7811:44: note: Assuming allocation function fails
      struct focus_data_struct *temp=malloc(focus_data_array->num_elements*sizeof(struct focus_data_struct));
                                           ^
Single_crystal_validation.c:7811: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));
                                           ^
Single_crystal_validation.c:7813:72: note: Null pointer dereference
      for (iterate=0;iterate<focus_data_array->num_elements;iterate++) temp[iterate] = focus_data_array->elements[iterate];
                                                                       ^
Single_crystal_validation.c:7817: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];
                                                                                                               ^
Single_crystal_validation.c:7811:44: note: Assuming allocation function fails
      struct focus_data_struct *temp=malloc(focus_data_array->num_elements*sizeof(struct focus_data_struct));
                                           ^
Single_crystal_validation.c:7811: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));
                                           ^
Single_crystal_validation.c:7817:112: note: Null pointer dereference
      for (iterate=0;iterate<focus_data_array->num_elements-1;iterate++) focus_data_array->elements[iterate] = temp[iterate];
                                                                                                               ^
Single_crystal_validation.c:7900:7: warning: If memory allocation fails, then there is a possible null pointer dereference: temp_fp [nullPointerOutOfMemory]
      temp_fp[iterate] = list->conditional_functions[iterate];
      ^
Single_crystal_validation.c:7895:49: note: Assuming allocation function fails
    conditional_function_pointer *temp_fp=malloc(list->num_elements*sizeof(conditional_function_pointer));
                                                ^
Single_crystal_validation.c:7895: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));
                                                ^
Single_crystal_validation.c:7900:7: note: Null pointer dereference
      temp_fp[iterate] = list->conditional_functions[iterate];
      ^
Single_crystal_validation.c:7901: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];
      ^
Single_crystal_validation.c:7896:50: note: Assuming allocation function fails
    union conditional_data_union **temp_du=malloc(list->num_elements*sizeof(union conditional_data_union));
                                                 ^
Single_crystal_validation.c:7896: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));
                                                 ^
Single_crystal_validation.c:7901:7: note: Null pointer dereference
      temp_du[iterate] = list->p_data_unions[iterate];
      ^
Single_crystal_validation.c:7910:46: warning: If memory allocation fails, then there is a possible null pointer dereference: temp_fp [nullPointerOutOfMemory]
      list->conditional_functions[iterate] = temp_fp[iterate];
                                             ^
Single_crystal_validation.c:7895:49: note: Assuming allocation function fails
    conditional_function_pointer *temp_fp=malloc(list->num_elements*sizeof(conditional_function_pointer));
                                                ^
Single_crystal_validation.c:7895: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));
                                                ^
Single_crystal_validation.c:7910:46: note: Null pointer dereference
      list->conditional_functions[iterate] = temp_fp[iterate];
                                             ^
Single_crystal_validation.c:7911: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];
                                     ^
Single_crystal_validation.c:7896:50: note: Assuming allocation function fails
    union conditional_data_union **temp_du=malloc(list->num_elements*sizeof(union conditional_data_union));
                                                 ^
Single_crystal_validation.c:7896: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));
                                                 ^
Single_crystal_validation.c:7911:38: note: Null pointer dereference
      list->p_data_unions[iterate] = temp_du[iterate];
                                     ^
Single_crystal_validation.c:8004:9: warning: If memory allocation fails, then there is a possible null pointer dereference: temp [nullPointerOutOfMemory]
        temp[iterate] = list->positions[iterate];
        ^
Single_crystal_validation.c:7999:20: note: Assuming allocation function fails
      temp = malloc(list->num_elements*sizeof(Coords*));
                   ^
Single_crystal_validation.c:7999:20: note: Assignment 'temp=malloc(list->num_elements*sizeof(struct Coords*))', assigned value is 0
      temp = malloc(list->num_elements*sizeof(Coords*));
                   ^
Single_crystal_validation.c:8004:9: note: Null pointer dereference
        temp[iterate] = list->positions[iterate];
        ^
Single_crystal_validation.c:8011:36: warning: If memory allocation fails, then there is a possible null pointer dereference: temp [nullPointerOutOfMemory]
        list->positions[iterate] = temp[iterate];
                                   ^
Single_crystal_validation.c:7999:20: note: Assuming allocation function fails
      temp = malloc(list->num_elements*sizeof(Coords*));
                   ^
Single_crystal_validation.c:7999:20: note: Assignment 'temp=malloc(list->num_elements*sizeof(struct Coords*))', assigned value is 0
      temp = malloc(list->num_elements*sizeof(Coords*));
                   ^
Single_crystal_validation.c:8011:36: note: Null pointer dereference
        list->positions[iterate] = temp[iterate];
                                   ^
Single_crystal_validation.c:8027:9: warning: If memory allocation fails, then there is a possible null pointer dereference: temp [nullPointerOutOfMemory]
        temp[iterate] = list->rotations[iterate];
        ^
Single_crystal_validation.c:8024:20: note: Assuming allocation function fails
      temp = malloc(list->num_elements*sizeof(Rotation*));
                   ^
Single_crystal_validation.c:8024:20: note: Assignment 'temp=malloc(list->num_elements*sizeof(double(*)[3][3]))', assigned value is 0
      temp = malloc(list->num_elements*sizeof(Rotation*));
                   ^
Single_crystal_validation.c:8027:9: note: Null pointer dereference
        temp[iterate] = list->rotations[iterate];
        ^
Single_crystal_validation.c:8033:36: warning: If memory allocation fails, then there is a possible null pointer dereference: temp [nullPointerOutOfMemory]
        list->rotations[iterate] = temp[iterate];
                                   ^
Single_crystal_validation.c:8024:20: note: Assuming allocation function fails
      temp = malloc(list->num_elements*sizeof(Rotation*));
                   ^
Single_crystal_validation.c:8024:20: note: Assignment 'temp=malloc(list->num_elements*sizeof(double(*)[3][3]))', assigned value is 0
      temp = malloc(list->num_elements*sizeof(Rotation*));
                   ^
Single_crystal_validation.c:8033:36: note: Null pointer dereference
        list->rotations[iterate] = temp[iterate];
                                   ^
Single_crystal_validation.c:8048: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];
                                                         ^
Single_crystal_validation.c:8046:56: note: Assuming allocation function fails
      struct global_process_element_struct *temp=malloc(list->num_elements*sizeof(struct global_process_element_struct));
                                                       ^
Single_crystal_validation.c:8046: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));
                                                       ^
Single_crystal_validation.c:8048:58: note: Null pointer dereference
    for (iterate=0;iterate<list->num_elements;iterate++) temp[iterate] = list->elements[iterate];
                                                         ^
Single_crystal_validation.c:8052: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];
                                                                                     ^
Single_crystal_validation.c:8046:56: note: Assuming allocation function fails
      struct global_process_element_struct *temp=malloc(list->num_elements*sizeof(struct global_process_element_struct));
                                                       ^
Single_crystal_validation.c:8046: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));
                                                       ^
Single_crystal_validation.c:8052:86: note: Null pointer dereference
    for (iterate=0;iterate<list->num_elements-1;iterate++) list->elements[iterate] = temp[iterate];
                                                                                     ^
Single_crystal_validation.c:8067: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];
                                                         ^
Single_crystal_validation.c:8065:55: note: Assuming allocation function fails
    struct global_material_element_struct *temp=malloc(list->num_elements*sizeof(struct global_material_element_struct));
                                                      ^
Single_crystal_validation.c:8065: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));
                                                      ^
Single_crystal_validation.c:8067:58: note: Null pointer dereference
    for (iterate=0;iterate<list->num_elements;iterate++) temp[iterate] = list->elements[iterate];
                                                         ^
Single_crystal_validation.c:8071: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];
                                                                                     ^
Single_crystal_validation.c:8065:55: note: Assuming allocation function fails
    struct global_material_element_struct *temp=malloc(list->num_elements*sizeof(struct global_material_element_struct));
                                                      ^
Single_crystal_validation.c:8065: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));
                                                      ^
Single_crystal_validation.c:8071:86: note: Null pointer dereference
    for (iterate=0;iterate<list->num_elements-1;iterate++) list->elements[iterate] = temp[iterate];
                                                                                     ^
Single_crystal_validation.c:8086: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];
                                                         ^
Single_crystal_validation.c:8084:55: note: Assuming allocation function fails
    struct global_geometry_element_struct *temp=malloc(list->num_elements*sizeof(struct global_geometry_element_struct));
                                                      ^
Single_crystal_validation.c:8084: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));
                                                      ^
Single_crystal_validation.c:8086:58: note: Null pointer dereference
    for (iterate=0;iterate<list->num_elements;iterate++) temp[iterate] = list->elements[iterate];
                                                         ^
Single_crystal_validation.c:8090: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];
                                                                                     ^
Single_crystal_validation.c:8084:55: note: Assuming allocation function fails
    struct global_geometry_element_struct *temp=malloc(list->num_elements*sizeof(struct global_geometry_element_struct));
                                                      ^
Single_crystal_validation.c:8084: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));
                                                      ^
Single_crystal_validation.c:8090:86: note: Null pointer dereference
    for (iterate=0;iterate<list->num_elements-1;iterate++) list->elements[iterate] = temp[iterate];
                                                                                     ^
Single_crystal_validation.c:8105: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];
                                                         ^
Single_crystal_validation.c:8103:53: note: Assuming allocation function fails
    struct global_logger_element_struct *temp=malloc(list->num_elements*sizeof(struct global_logger_element_struct));
                                                    ^
Single_crystal_validation.c:8103: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));
                                                    ^
Single_crystal_validation.c:8105:58: note: Null pointer dereference
    for (iterate=0;iterate<list->num_elements;iterate++) temp[iterate] = list->elements[iterate];
                                                         ^
Single_crystal_validation.c:8109: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];
                                                                                     ^
Single_crystal_validation.c:8103:53: note: Assuming allocation function fails
    struct global_logger_element_struct *temp=malloc(list->num_elements*sizeof(struct global_logger_element_struct));
                                                    ^
Single_crystal_validation.c:8103: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));
                                                    ^
Single_crystal_validation.c:8109:86: note: Null pointer dereference
    for (iterate=0;iterate<list->num_elements-1;iterate++) list->elements[iterate] = temp[iterate];
                                                                                     ^
Single_crystal_validation.c:8124: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];
                                                           ^
Single_crystal_validation.c:8122:59: note: Assuming allocation function fails
      struct global_abs_logger_element_struct *temp=malloc(list->num_elements*sizeof(struct global_abs_logger_element_struct));
                                                          ^
Single_crystal_validation.c:8122: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));
                                                          ^
Single_crystal_validation.c:8124:60: note: Null pointer dereference
      for (iterate=0;iterate<list->num_elements;iterate++) temp[iterate] = list->elements[iterate];
                                                           ^
Single_crystal_validation.c:8128: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];
                                                                                       ^
Single_crystal_validation.c:8122:59: note: Assuming allocation function fails
      struct global_abs_logger_element_struct *temp=malloc(list->num_elements*sizeof(struct global_abs_logger_element_struct));
                                                          ^
Single_crystal_validation.c:8122: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));
                                                          ^
Single_crystal_validation.c:8128:88: note: Null pointer dereference
      for (iterate=0;iterate<list->num_elements-1;iterate++) list->elements[iterate] = temp[iterate];
                                                                                       ^
Single_crystal_validation.c:8143: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];
                                                         ^
Single_crystal_validation.c:8141:66: note: Assuming allocation function fails
    struct global_tagging_conditional_element_struct *temp=malloc(list->num_elements*sizeof(struct global_tagging_conditional_element_struct));
                                                                 ^
Single_crystal_validation.c:8141: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));
                                                                 ^
Single_crystal_validation.c:8143:58: note: Null pointer dereference
    for (iterate=0;iterate<list->num_elements;iterate++) temp[iterate] = list->elements[iterate];
                                                         ^
Single_crystal_validation.c:8147: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];
                                                                                     ^
Single_crystal_validation.c:8141:66: note: Assuming allocation function fails
    struct global_tagging_conditional_element_struct *temp=malloc(list->num_elements*sizeof(struct global_tagging_conditional_element_struct));
                                                                 ^
Single_crystal_validation.c:8141: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));
                                                                 ^
Single_crystal_validation.c:8147:86: note: Null pointer dereference
    for (iterate=0;iterate<list->num_elements-1;iterate++) list->elements[iterate] = temp[iterate];
                                                                                     ^
Single_crystal_validation.c:8162: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];
                                                         ^
Single_crystal_validation.c:8160:53: note: Assuming allocation function fails
    struct global_master_element_struct *temp=malloc(list->num_elements*sizeof(struct global_master_element_struct));
                                                    ^
Single_crystal_validation.c:8160: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));
                                                    ^
Single_crystal_validation.c:8162:58: note: Null pointer dereference
    for (iterate=0;iterate<list->num_elements;iterate++) temp[iterate] = list->elements[iterate];
                                                         ^
Single_crystal_validation.c:8166: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];
                                                                                     ^
Single_crystal_validation.c:8160:53: note: Assuming allocation function fails
    struct global_master_element_struct *temp=malloc(list->num_elements*sizeof(struct global_master_element_struct));
                                                    ^
Single_crystal_validation.c:8160: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));
                                                    ^
Single_crystal_validation.c:8166:86: note: Null pointer dereference
    for (iterate=0;iterate<list->num_elements-1;iterate++) list->elements[iterate] = temp[iterate];
                                                                                     ^
Single_crystal_validation.c:8185: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];
                                                            ^
Single_crystal_validation.c:8183:53: note: Assuming allocation function fails
    struct logger_for_each_process_list *temp=malloc(loggers->num_elements*sizeof(struct logger_for_each_process_list));
                                                    ^
Single_crystal_validation.c:8183: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));
                                                    ^
Single_crystal_validation.c:8185:61: note: Null pointer dereference
    for (iterate=0;iterate<loggers->num_elements;iterate++) temp[iterate] = loggers->p_logger_volume[iterate];
                                                            ^
Single_crystal_validation.c:8189: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];
                                                                                                  ^
Single_crystal_validation.c:8183:53: note: Assuming allocation function fails
    struct logger_for_each_process_list *temp=malloc(loggers->num_elements*sizeof(struct logger_for_each_process_list));
                                                    ^
Single_crystal_validation.c:8183: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));
                                                    ^
Single_crystal_validation.c:8189:99: note: Null pointer dereference
    for (iterate=0;iterate<loggers->num_elements-1;iterate++) loggers->p_logger_volume[iterate] = temp[iterate];
                                                                                                  ^
Single_crystal_validation.c:8236: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];
                                                                ^
Single_crystal_validation.c:8234:43: note: Assuming allocation function fails
    struct abs_logger_struct **temp=malloc(abs_loggers->num_elements*sizeof(struct abs_logger_struct *));
                                          ^
Single_crystal_validation.c:8234: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 *));
                                          ^
Single_crystal_validation.c:8236:65: note: Null pointer dereference
    for (iterate=0;iterate<abs_loggers->num_elements;iterate++) temp[iterate] = abs_loggers->p_abs_logger[iterate];
                                                                ^
Single_crystal_validation.c:8241: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];
                                                                                                       ^
Single_crystal_validation.c:8234:43: note: Assuming allocation function fails
    struct abs_logger_struct **temp=malloc(abs_loggers->num_elements*sizeof(struct abs_logger_struct *));
                                          ^
Single_crystal_validation.c:8234: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 *));
                                          ^
Single_crystal_validation.c:8241:104: note: Null pointer dereference
    for (iterate=0;iterate<abs_loggers->num_elements-1;iterate++) abs_loggers->p_abs_logger[iterate] = temp[iterate];
                                                                                                       ^
Single_crystal_validation.c:8535: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);
            ^
Single_crystal_validation.c:8699:3: note: Assuming allocation function fails
  MPI_MASTER(
  ^
Single_crystal_validation.c:8699:3: note: Assignment 'fp=fopen("union_history.dat","w")', assigned value is 0
  MPI_MASTER(
  ^
Single_crystal_validation.c:8699:3: note: Calling function 'fprintf_total_history', 2nd argument 'fp' value is 0
  MPI_MASTER(
  ^
Single_crystal_validation.c:8535:13: note: Null pointer dereference
    fprintf(fp,"%d\t N I=%E \t", history->number_of_rays, history->intensity);
            ^
Single_crystal_validation.c:8699:3: warning: If resource allocation fails, then there is a possible null pointer dereference: fp [nullPointerOutOfResources]
  MPI_MASTER(
  ^
Single_crystal_validation.c:8699:3: note: Assuming allocation function fails
  MPI_MASTER(
  ^
Single_crystal_validation.c:8699:3: note: Assignment 'fp=fopen("union_history.dat","w")', assigned value is 0
  MPI_MASTER(
  ^
Single_crystal_validation.c:8699:3: note: Null pointer dereference
  MPI_MASTER(
  ^
Single_crystal_validation.c:8821: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];
                                                                        ^
Single_crystal_validation.c:8820:24: note: Assuming allocation function fails
    temp_lines = malloc(lines_master->number_of_lines*sizeof(struct line_segment));
                       ^
Single_crystal_validation.c:8820: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));
                       ^
Single_crystal_validation.c:8821:73: note: Null pointer dereference
    for (iterate = 0;iterate < lines_master->number_of_lines;iterate++) temp_lines[iterate] = lines_master->lines[iterate];
                                                                        ^
Single_crystal_validation.c:8824: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];
                                                                                                       ^
Single_crystal_validation.c:8820:24: note: Assuming allocation function fails
    temp_lines = malloc(lines_master->number_of_lines*sizeof(struct line_segment));
                       ^
Single_crystal_validation.c:8820: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));
                       ^
Single_crystal_validation.c:8824:104: note: Null pointer dereference
    for (iterate = 0;iterate < lines_master->number_of_lines;iterate++) lines_master->lines[iterate] = temp_lines[iterate];
                                                                                                       ^
Single_crystal_validation.c:8988: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]);
    ^
Single_crystal_validation.c:8987:26: note: Assuming allocation function fails
    Coords *points=malloc((intersection_list.num_elements+2)*sizeof(Coords));
                         ^
Single_crystal_validation.c:8987: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));
                         ^
Single_crystal_validation.c:8988:5: note: Null pointer dereference
    points[0] = coords_set(r1[0],r1[1],r1[2]);
    ^
Single_crystal_validation.c:8989: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]);
    ^
Single_crystal_validation.c:8987:26: note: Assuming allocation function fails
    Coords *points=malloc((intersection_list.num_elements+2)*sizeof(Coords));
                         ^
Single_crystal_validation.c:8987: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));
                         ^
Single_crystal_validation.c:8989:5: note: Null pointer dereference
    points[intersection_list.num_elements+1] = coords_set(r2[0],r2[1],r2[2]);
    ^
Single_crystal_validation.c:8991: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];
        ^
Single_crystal_validation.c:8987:26: note: Assuming allocation function fails
    Coords *points=malloc((intersection_list.num_elements+2)*sizeof(Coords));
                         ^
Single_crystal_validation.c:8987: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));
                         ^
Single_crystal_validation.c:8991:9: note: Null pointer dereference
        points[iterate].x = r1[0] + direction[0]*intersection_list.elements[iterate-1];
        ^
Single_crystal_validation.c:8992: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];
        ^
Single_crystal_validation.c:8987:26: note: Assuming allocation function fails
    Coords *points=malloc((intersection_list.num_elements+2)*sizeof(Coords));
                         ^
Single_crystal_validation.c:8987: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));
                         ^
Single_crystal_validation.c:8992:9: note: Null pointer dereference
        points[iterate].y = r1[1] + direction[1]*intersection_list.elements[iterate-1];
        ^
Single_crystal_validation.c:8993: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];
        ^
Single_crystal_validation.c:8987:26: note: Assuming allocation function fails
    Coords *points=malloc((intersection_list.num_elements+2)*sizeof(Coords));
                         ^
Single_crystal_validation.c:8987: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));
                         ^
Single_crystal_validation.c:8993:9: note: Null pointer dereference
        points[iterate].z = r1[2] + direction[2]*intersection_list.elements[iterate-1];
        ^
Single_crystal_validation.c:9013:9: warning: If memory allocation fails, then there is a possible null pointer dereference: lines [nullPointerOutOfMemory]
        lines[iterate].point1 = points[iterate];
        ^
Single_crystal_validation.c:9002:38: note: Assuming allocation function fails
    struct line_segment *lines=malloc((intersection_list.num_elements+1)*sizeof(struct line_segment));
                                     ^
Single_crystal_validation.c:9002: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));
                                     ^
Single_crystal_validation.c:9013:9: note: Null pointer dereference
        lines[iterate].point1 = points[iterate];
        ^
Single_crystal_validation.c:9013:33: warning: If memory allocation fails, then there is a possible null pointer dereference: points [nullPointerOutOfMemory]
        lines[iterate].point1 = points[iterate];
                                ^
Single_crystal_validation.c:8987:26: note: Assuming allocation function fails
    Coords *points=malloc((intersection_list.num_elements+2)*sizeof(Coords));
                         ^
Single_crystal_validation.c:8987: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));
                         ^
Single_crystal_validation.c:9013:33: note: Null pointer dereference
        lines[iterate].point1 = points[iterate];
                                ^
Single_crystal_validation.c:9014:9: warning: If memory allocation fails, then there is a possible null pointer dereference: lines [nullPointerOutOfMemory]
        lines[iterate].point2 = points[iterate+1];
        ^
Single_crystal_validation.c:9002:38: note: Assuming allocation function fails
    struct line_segment *lines=malloc((intersection_list.num_elements+1)*sizeof(struct line_segment));
                                     ^
Single_crystal_validation.c:9002: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));
                                     ^
Single_crystal_validation.c:9014:9: note: Null pointer dereference
        lines[iterate].point2 = points[iterate+1];
        ^
Single_crystal_validation.c:9014:33: warning: If memory allocation fails, then there is a possible null pointer dereference: points [nullPointerOutOfMemory]
        lines[iterate].point2 = points[iterate+1];
                                ^
Single_crystal_validation.c:8987:26: note: Assuming allocation function fails
    Coords *points=malloc((intersection_list.num_elements+2)*sizeof(Coords));
                         ^
Single_crystal_validation.c:8987: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));
                         ^
Single_crystal_validation.c:9014:33: note: Null pointer dereference
        lines[iterate].point2 = points[iterate+1];
                                ^
Single_crystal_validation.c:9015: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);
                          ^
Single_crystal_validation.c:9002:38: note: Assuming allocation function fails
    struct line_segment *lines=malloc((intersection_list.num_elements+1)*sizeof(struct line_segment));
                                     ^
Single_crystal_validation.c:9002: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));
                                     ^
Single_crystal_validation.c:9015:27: note: Null pointer dereference
        midpoint.x = 0.5*(lines[iterate].point1.x + lines[iterate].point2.x);
                          ^
Single_crystal_validation.c:9015: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);
                                                    ^
Single_crystal_validation.c:9002:38: note: Assuming allocation function fails
    struct line_segment *lines=malloc((intersection_list.num_elements+1)*sizeof(struct line_segment));
                                     ^
Single_crystal_validation.c:9002: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));
                                     ^
Single_crystal_validation.c:9015:53: note: Null pointer dereference
        midpoint.x = 0.5*(lines[iterate].point1.x + lines[iterate].point2.x);
                                                    ^
Single_crystal_validation.c:9016: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);
                          ^
Single_crystal_validation.c:9002:38: note: Assuming allocation function fails
    struct line_segment *lines=malloc((intersection_list.num_elements+1)*sizeof(struct line_segment));
                                     ^
Single_crystal_validation.c:9002: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));
                                     ^
Single_crystal_validation.c:9016:27: note: Null pointer dereference
        midpoint.y = 0.5*(lines[iterate].point1.y + lines[iterate].point2.y);
                          ^
Single_crystal_validation.c:9016: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);
                                                    ^
Single_crystal_validation.c:9002:38: note: Assuming allocation function fails
    struct line_segment *lines=malloc((intersection_list.num_elements+1)*sizeof(struct line_segment));
                                     ^
Single_crystal_validation.c:9002: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));
                                     ^
Single_crystal_validation.c:9016:53: note: Null pointer dereference
        midpoint.y = 0.5*(lines[iterate].point1.y + lines[iterate].point2.y);
                                                    ^
Single_crystal_validation.c:9017: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);
                          ^
Single_crystal_validation.c:9002:38: note: Assuming allocation function fails
    struct line_segment *lines=malloc((intersection_list.num_elements+1)*sizeof(struct line_segment));
                                     ^
Single_crystal_validation.c:9002: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));
                                     ^
Single_crystal_validation.c:9017:27: note: Null pointer dereference
        midpoint.z = 0.5*(lines[iterate].point1.z + lines[iterate].point2.z);
                          ^
Single_crystal_validation.c:9017: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);
                                                    ^
Single_crystal_validation.c:9002:38: note: Assuming allocation function fails
    struct line_segment *lines=malloc((intersection_list.num_elements+1)*sizeof(struct line_segment));
                                     ^
Single_crystal_validation.c:9002: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));
                                     ^
Single_crystal_validation.c:9017:53: note: Null pointer dereference
        midpoint.z = 0.5*(lines[iterate].point1.z + lines[iterate].point2.z);
                                                    ^
Single_crystal_validation.c:9229: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;
               ^
Single_crystal_validation.c:9227:38: note: Assuming allocation function fails
  union_output.p_box_storage = malloc(sizeof(struct box_storage));
                                     ^
Single_crystal_validation.c:9227: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));
                                     ^
Single_crystal_validation.c:9229:16: note: Null pointer dereference
  *union_output.p_box_storage = *union_input->p_box_storage;
               ^
Single_crystal_validation.c:9240: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;
               ^
Single_crystal_validation.c:9238:43: note: Assuming allocation function fails
  union_output.p_cylinder_storage = malloc(sizeof(struct cylinder_storage));
                                          ^
Single_crystal_validation.c:9238: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));
                                          ^
Single_crystal_validation.c:9240:16: note: Null pointer dereference
  *union_output.p_cylinder_storage = *union_input->p_cylinder_storage;
               ^
Single_crystal_validation.c:9250: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;
               ^
Single_crystal_validation.c:9248:41: note: Assuming allocation function fails
  union_output.p_sphere_storage = malloc(sizeof(struct sphere_storage));
                                        ^
Single_crystal_validation.c:9248: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));
                                        ^
Single_crystal_validation.c:9250:16: note: Null pointer dereference
  *union_output.p_sphere_storage = *union_input->p_sphere_storage;
               ^
Single_crystal_validation.c:9260: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;
               ^
Single_crystal_validation.c:9258:39: note: Assuming allocation function fails
  union_output.p_cone_storage = malloc(sizeof(struct cone_storage));
                                      ^
Single_crystal_validation.c:9258: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));
                                      ^
Single_crystal_validation.c:9260:16: note: Null pointer dereference
  *union_output.p_cone_storage = *union_input->p_cone_storage;
               ^
Single_crystal_validation.c:9270: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;
               ^
Single_crystal_validation.c:9268:39: note: Assuming allocation function fails
  union_output.p_mesh_storage = malloc(sizeof(struct mesh_storage));
                                      ^
Single_crystal_validation.c:9268: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));
                                      ^
Single_crystal_validation.c:9270:16: note: Null pointer dereference
  *union_output.p_mesh_storage = *union_input->p_mesh_storage;
               ^
Single_crystal_validation.c:9328: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);
        ^
Single_crystal_validation.c:12639:32: note: Assuming allocation function fails
    circle_point_array = malloc(number_of_points * sizeof(Coords));
                               ^
Single_crystal_validation.c:12639: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));
                               ^
Single_crystal_validation.c:12641: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);
                     ^
Single_crystal_validation.c:9328: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);
        ^
Single_crystal_validation.c:9329: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);
        ^
Single_crystal_validation.c:12639:32: note: Assuming allocation function fails
    circle_point_array = malloc(number_of_points * sizeof(Coords));
                               ^
Single_crystal_validation.c:12639: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));
                               ^
Single_crystal_validation.c:12641: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);
                     ^
Single_crystal_validation.c:9329:9: note: Null pointer dereference
        output[point_nr] = coords_add(output[point_nr],center);
        ^
Single_crystal_validation.c:9329: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);
                                      ^
Single_crystal_validation.c:12639:32: note: Assuming allocation function fails
    circle_point_array = malloc(number_of_points * sizeof(Coords));
                               ^
Single_crystal_validation.c:12639: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));
                               ^
Single_crystal_validation.c:12641: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);
                     ^
Single_crystal_validation.c:9329:39: note: Null pointer dereference
        output[point_nr] = coords_add(output[point_nr],center);
                                      ^
Single_crystal_validation.c:11839: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) {
                                          ^
Single_crystal_validation.c:11833:32: note: Assuming allocation function fails
    circle_point_array = malloc(number_of_points * sizeof(Coords));
                               ^
Single_crystal_validation.c:11833: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));
                               ^
Single_crystal_validation.c:11839:43: note: Null pointer dereference
        if (geometry_box->within_function(circle_point_array[iterate],geometry_box) == 1) {
                                          ^
Single_crystal_validation.c:11847: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) {
                                          ^
Single_crystal_validation.c:11833:32: note: Assuming allocation function fails
    circle_point_array = malloc(number_of_points * sizeof(Coords));
                               ^
Single_crystal_validation.c:11833: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));
                               ^
Single_crystal_validation.c:11839:85: note: Assuming condition is false
        if (geometry_box->within_function(circle_point_array[iterate],geometry_box) == 1) {
                                                                                    ^
Single_crystal_validation.c:11847:43: note: Null pointer dereference
        if (geometry_box->within_function(circle_point_array[iterate],geometry_box) == 1) {
                                          ^
Single_crystal_validation.c:12646: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) {
                                             ^
Single_crystal_validation.c:12639:32: note: Assuming allocation function fails
    circle_point_array = malloc(number_of_points * sizeof(Coords));
                               ^
Single_crystal_validation.c:12639: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));
                               ^
Single_crystal_validation.c:12646:46: note: Null pointer dereference
        if (geometry_parent->within_function(circle_point_array[iterate],geometry_parent) == 0) {
                                             ^
Single_crystal_validation.c:12654: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) {
                                             ^
Single_crystal_validation.c:12639:32: note: Assuming allocation function fails
    circle_point_array = malloc(number_of_points * sizeof(Coords));
                               ^
Single_crystal_validation.c:12639: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));
                               ^
Single_crystal_validation.c:12646:91: note: Assuming condition is false
        if (geometry_parent->within_function(circle_point_array[iterate],geometry_parent) == 0) {
                                                                                          ^
Single_crystal_validation.c:12654:46: note: Null pointer dereference
        if (geometry_parent->within_function(circle_point_array[iterate],geometry_parent) == 0) {
                                             ^
Single_crystal_validation.c:13470: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;
  ^
Single_crystal_validation.c:13467:36: note: Assuming allocation function fails
  temporary_children_lists = malloc(number_of_volumes*sizeof(struct pointer_to_1d_int_list));
                                   ^
Single_crystal_validation.c:13467: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));
                                   ^
Single_crystal_validation.c:13470:3: note: Null pointer dereference
  temporary_children_lists[0].num_elements = number_of_volumes - 1;
  ^
Single_crystal_validation.c:13471: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));
  ^
Single_crystal_validation.c:13467:36: note: Assuming allocation function fails
  temporary_children_lists = malloc(number_of_volumes*sizeof(struct pointer_to_1d_int_list));
                                   ^
Single_crystal_validation.c:13467: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));
                                   ^
Single_crystal_validation.c:13471:3: note: Null pointer dereference
  temporary_children_lists[0].elements = malloc(temporary_children_lists[0].num_elements*sizeof(int));
  ^
Single_crystal_validation.c:13471: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));
                                                ^
Single_crystal_validation.c:13467:36: note: Assuming allocation function fails
  temporary_children_lists = malloc(number_of_volumes*sizeof(struct pointer_to_1d_int_list));
                                   ^
Single_crystal_validation.c:13467: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));
                                   ^
Single_crystal_validation.c:13471:49: note: Null pointer dereference
  temporary_children_lists[0].elements = malloc(temporary_children_lists[0].num_elements*sizeof(int));
                                                ^
Single_crystal_validation.c:13475: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;
      ^
Single_crystal_validation.c:13467:36: note: Assuming allocation function fails
  temporary_children_lists = malloc(number_of_volumes*sizeof(struct pointer_to_1d_int_list));
                                   ^
Single_crystal_validation.c:13467: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));
                                   ^
Single_crystal_validation.c:13475:7: note: Null pointer dereference
      temporary_children_lists[0].elements[parent-1] = parent;
      ^
Single_crystal_validation.c:13484: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));
  ^
Single_crystal_validation.c:15103:33: note: Assuming allocation function fails
    true_children_lists = malloc(number_of_volumes*sizeof(struct pointer_to_1d_int_list*));
                                ^
Single_crystal_validation.c:15103: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*));
                                ^
Single_crystal_validation.c:15105: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);
                                     ^
Single_crystal_validation.c:13484:3: note: Null pointer dereference
  true_children_lists[0] = malloc(sizeof(struct pointer_to_1d_int_list));
  ^
Single_crystal_validation.c:13485: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;
  ^
Single_crystal_validation.c:15103:33: note: Assuming allocation function fails
    true_children_lists = malloc(number_of_volumes*sizeof(struct pointer_to_1d_int_list*));
                                ^
Single_crystal_validation.c:15103: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*));
                                ^
Single_crystal_validation.c:15105: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);
                                     ^
Single_crystal_validation.c:13485:3: note: Null pointer dereference
  true_children_lists[0]->num_elements = number_of_volumes - 1;
  ^
Single_crystal_validation.c:13486: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));
  ^
Single_crystal_validation.c:15103:33: note: Assuming allocation function fails
    true_children_lists = malloc(number_of_volumes*sizeof(struct pointer_to_1d_int_list*));
                                ^
Single_crystal_validation.c:15103: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*));
                                ^
Single_crystal_validation.c:15105: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);
                                     ^
Single_crystal_validation.c:13486:3: note: Null pointer dereference
  true_children_lists[0]->elements = malloc((number_of_volumes-1)*sizeof(int));
  ^
Single_crystal_validation.c:13492: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;
      ^
Single_crystal_validation.c:15103:33: note: Assuming allocation function fails
    true_children_lists = malloc(number_of_volumes*sizeof(struct pointer_to_1d_int_list*));
                                ^
Single_crystal_validation.c:15103: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*));
                                ^
Single_crystal_validation.c:15105: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);
                                     ^
Single_crystal_validation.c:13492:7: note: Null pointer dereference
      true_children_lists[0]->elements[parent-1] = parent;
      ^
Single_crystal_validation.c:13527: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;
      ^
Single_crystal_validation.c:13467:36: note: Assuming allocation function fails
  temporary_children_lists = malloc(number_of_volumes*sizeof(struct pointer_to_1d_int_list));
                                   ^
Single_crystal_validation.c:13467: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));
                                   ^
Single_crystal_validation.c:13527:7: note: Null pointer dereference
      temporary_children_lists[parent].num_elements=0;
      ^
Single_crystal_validation.c:13531:7: warning: If memory allocation fails, then there is a possible null pointer dereference: temporary_children_lists [nullPointerOutOfMemory]
      MPI_MASTER(
      ^
Single_crystal_validation.c:13467:36: note: Assuming allocation function fails
  temporary_children_lists = malloc(number_of_volumes*sizeof(struct pointer_to_1d_int_list));
                                   ^
Single_crystal_validation.c:13467: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));
                                   ^
Single_crystal_validation.c:13531:7: note: Null pointer dereference
      MPI_MASTER(
      ^
Single_crystal_validation.c:13655: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));
    ^
Single_crystal_validation.c:15103:33: note: Assuming allocation function fails
    true_children_lists = malloc(number_of_volumes*sizeof(struct pointer_to_1d_int_list*));
                                ^
Single_crystal_validation.c:15103: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*));
                                ^
Single_crystal_validation.c:15105: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);
                                     ^
Single_crystal_validation.c:13655:5: note: Null pointer dereference
    true_children_lists[parent] = malloc(sizeof(struct pointer_to_1d_int_list));
    ^
Single_crystal_validation.c:13656: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;
    ^
Single_crystal_validation.c:15103:33: note: Assuming allocation function fails
    true_children_lists = malloc(number_of_volumes*sizeof(struct pointer_to_1d_int_list*));
                                ^
Single_crystal_validation.c:15103: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*));
                                ^
Single_crystal_validation.c:15105: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);
                                     ^
Single_crystal_validation.c:13656:5: note: Null pointer dereference
    true_children_lists[parent]->num_elements = 0;
    ^
Single_crystal_validation.c:13657: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]);
                                                               ^
Single_crystal_validation.c:15103:33: note: Assuming allocation function fails
    true_children_lists = malloc(number_of_volumes*sizeof(struct pointer_to_1d_int_list*));
                                ^
Single_crystal_validation.c:15103: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*));
                                ^
Single_crystal_validation.c:15105: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);
                                     ^
Single_crystal_validation.c:13657:64: note: Null pointer dereference
    allocate_list_from_temp(used_elements,true_temp_list_local,true_children_lists[parent]);
                                                               ^
Single_crystal_validation.c:13659:5: warning: If memory allocation fails, then there is a possible null pointer dereference: true_children_lists [nullPointerOutOfMemory]
    MPI_MASTER(
    ^
Single_crystal_validation.c:15103:33: note: Assuming allocation function fails
    true_children_lists = malloc(number_of_volumes*sizeof(struct pointer_to_1d_int_list*));
                                ^
Single_crystal_validation.c:15103: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*));
                                ^
Single_crystal_validation.c:15105: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);
                                     ^
Single_crystal_validation.c:13659:5: note: Null pointer dereference
    MPI_MASTER(
    ^
Single_crystal_validation.c:13668: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);
                                                    ^
Single_crystal_validation.c:13467:36: note: Assuming allocation function fails
  temporary_children_lists = malloc(number_of_volumes*sizeof(struct pointer_to_1d_int_list));
                                   ^
Single_crystal_validation.c:13467: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));
                                   ^
Single_crystal_validation.c:13668:53: note: Null pointer dereference
  for(child=0;child<number_of_volumes;child++) free(temporary_children_lists[child].elements);
                                                    ^
Single_crystal_validation.c:13690: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));
  ^
Single_crystal_validation.c:15109:32: note: Assuming allocation function fails
    true_overlap_lists = malloc(number_of_volumes*sizeof(struct pointer_to_1d_int_list*));
                               ^
Single_crystal_validation.c:15109: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*));
                               ^
Single_crystal_validation.c:15113: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);
                           ^
Single_crystal_validation.c:13690:3: note: Null pointer dereference
  true_overlap_lists[0] = malloc(sizeof(struct pointer_to_1d_int_list));
  ^
Single_crystal_validation.c:13691: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;
  ^
Single_crystal_validation.c:15109:32: note: Assuming allocation function fails
    true_overlap_lists = malloc(number_of_volumes*sizeof(struct pointer_to_1d_int_list*));
                               ^
Single_crystal_validation.c:15109: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*));
                               ^
Single_crystal_validation.c:15113: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);
                           ^
Single_crystal_validation.c:13691:3: note: Null pointer dereference
  true_overlap_lists[0]->num_elements = number_of_volumes-1;
  ^
Single_crystal_validation.c:13692: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));
  ^
Single_crystal_validation.c:15109:32: note: Assuming allocation function fails
    true_overlap_lists = malloc(number_of_volumes*sizeof(struct pointer_to_1d_int_list*));
                               ^
Single_crystal_validation.c:15109: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*));
                               ^
Single_crystal_validation.c:15113: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);
                           ^
Single_crystal_validation.c:13692:3: note: Null pointer dereference
  true_overlap_lists[0]->elements = malloc((number_of_volumes-1)*sizeof(int));
  ^
Single_crystal_validation.c:13694: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));
  ^
Single_crystal_validation.c:15111:31: note: Assuming allocation function fails
    raw_overlap_lists = malloc(number_of_volumes*sizeof(struct pointer_to_1d_int_list*));
                              ^
Single_crystal_validation.c:15111: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*));
                              ^
Single_crystal_validation.c:15113: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);
                                               ^
Single_crystal_validation.c:13694:3: note: Null pointer dereference
  raw_overlap_lists[0] =  malloc(sizeof(struct pointer_to_1d_int_list));
  ^
Single_crystal_validation.c:13695: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;
  ^
Single_crystal_validation.c:15111:31: note: Assuming allocation function fails
    raw_overlap_lists = malloc(number_of_volumes*sizeof(struct pointer_to_1d_int_list*));
                              ^
Single_crystal_validation.c:15111: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*));
                              ^
Single_crystal_validation.c:15113: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);
                                               ^
Single_crystal_validation.c:13695:3: note: Null pointer dereference
  raw_overlap_lists[0]->num_elements = number_of_volumes;
  ^
Single_crystal_validation.c:13696: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));
  ^
Single_crystal_validation.c:15111:31: note: Assuming allocation function fails
    raw_overlap_lists = malloc(number_of_volumes*sizeof(struct pointer_to_1d_int_list*));
                              ^
Single_crystal_validation.c:15111: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*));
                              ^
Single_crystal_validation.c:15113: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);
                                               ^
Single_crystal_validation.c:13696:3: note: Null pointer dereference
  raw_overlap_lists[0]->elements = malloc(number_of_volumes*sizeof(int));
  ^
Single_crystal_validation.c:13697: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
  ^
Single_crystal_validation.c:15111:31: note: Assuming allocation function fails
    raw_overlap_lists = malloc(number_of_volumes*sizeof(struct pointer_to_1d_int_list*));
                              ^
Single_crystal_validation.c:15111: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*));
                              ^
Single_crystal_validation.c:15113: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);
                                               ^
Single_crystal_validation.c:13697:3: note: Null pointer dereference
  raw_overlap_lists[0]->elements[0] = 0; // Volume 0 overlaps itself
  ^
Single_crystal_validation.c:13701: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;
      ^
Single_crystal_validation.c:15109:32: note: Assuming allocation function fails
    true_overlap_lists = malloc(number_of_volumes*sizeof(struct pointer_to_1d_int_list*));
                               ^
Single_crystal_validation.c:15109: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*));
                               ^
Single_crystal_validation.c:15113: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);
                           ^
Single_crystal_validation.c:13701:7: note: Null pointer dereference
      true_overlap_lists[0]->elements[parent-1] = parent;
      ^
Single_crystal_validation.c:13702: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;
      ^
Single_crystal_validation.c:15111:31: note: Assuming allocation function fails
    raw_overlap_lists = malloc(number_of_volumes*sizeof(struct pointer_to_1d_int_list*));
                              ^
Single_crystal_validation.c:15111: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*));
                              ^
Single_crystal_validation.c:15113: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);
                                               ^
Single_crystal_validation.c:13702:7: note: Null pointer dereference
      raw_overlap_lists[0]->elements[parent] = parent;
      ^
Single_crystal_validation.c:13706:3: warning: If memory allocation fails, then there is a possible null pointer dereference: true_overlap_lists [nullPointerOutOfMemory]
  MPI_MASTER(
  ^
Single_crystal_validation.c:15109:32: note: Assuming allocation function fails
    true_overlap_lists = malloc(number_of_volumes*sizeof(struct pointer_to_1d_int_list*));
                               ^
Single_crystal_validation.c:15109: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*));
                               ^
Single_crystal_validation.c:15113: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);
                           ^
Single_crystal_validation.c:13706:3: note: Null pointer dereference
  MPI_MASTER(
  ^
Single_crystal_validation.c:13719: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));
      ^
Single_crystal_validation.c:15109:32: note: Assuming allocation function fails
    true_overlap_lists = malloc(number_of_volumes*sizeof(struct pointer_to_1d_int_list*));
                               ^
Single_crystal_validation.c:15109: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*));
                               ^
Single_crystal_validation.c:15113: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);
                           ^
Single_crystal_validation.c:13719:7: note: Null pointer dereference
      true_overlap_lists[parent] = malloc(sizeof(struct pointer_to_1d_int_list));
      ^
Single_crystal_validation.c:13792: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));
      ^
Single_crystal_validation.c:15111:31: note: Assuming allocation function fails
    raw_overlap_lists = malloc(number_of_volumes*sizeof(struct pointer_to_1d_int_list*));
                              ^
Single_crystal_validation.c:15111: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*));
                              ^
Single_crystal_validation.c:15113: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);
                                               ^
Single_crystal_validation.c:13792:7: note: Null pointer dereference
      raw_overlap_lists[parent] = malloc(sizeof(struct pointer_to_1d_int_list));
      ^
Single_crystal_validation.c:13793: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;
      ^
Single_crystal_validation.c:15111:31: note: Assuming allocation function fails
    raw_overlap_lists = malloc(number_of_volumes*sizeof(struct pointer_to_1d_int_list*));
                              ^
Single_crystal_validation.c:15111: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*));
                              ^
Single_crystal_validation.c:15113: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);
                                               ^
Single_crystal_validation.c:13793:7: note: Null pointer dereference
      raw_overlap_lists[parent]->num_elements = 0;
      ^
Single_crystal_validation.c:13794: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]);
                                                            ^
Single_crystal_validation.c:15111:31: note: Assuming allocation function fails
    raw_overlap_lists = malloc(number_of_volumes*sizeof(struct pointer_to_1d_int_list*));
                              ^
Single_crystal_validation.c:15111: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*));
                              ^
Single_crystal_validation.c:15113: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);
                                               ^
Single_crystal_validation.c:13794:61: note: Null pointer dereference
      allocate_list_from_temp(used_elements,temp_list_local,raw_overlap_lists[parent]);
                                                            ^
Single_crystal_validation.c:13797:7: warning: If memory allocation fails, then there is a possible null pointer dereference: temporary_overlap_lists [nullPointerOutOfMemory]
      MPI_MASTER(
      ^
Single_crystal_validation.c:13687:35: note: Assuming allocation function fails
  temporary_overlap_lists = malloc(number_of_volumes*sizeof(struct pointer_to_1d_int_list));
                                  ^
Single_crystal_validation.c:13687: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));
                                  ^
Single_crystal_validation.c:13797:7: note: Null pointer dereference
      MPI_MASTER(
      ^
Single_crystal_validation.c:13910: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]);
                                                          ^
Single_crystal_validation.c:15109:32: note: Assuming allocation function fails
    true_overlap_lists = malloc(number_of_volumes*sizeof(struct pointer_to_1d_int_list*));
                               ^
Single_crystal_validation.c:15109: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*));
                               ^
Single_crystal_validation.c:15113: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);
                           ^
Single_crystal_validation.c:13910:59: note: Null pointer dereference
    allocate_list_from_temp(used_elements,temp_list_local,true_overlap_lists[parent]);
                                                          ^
Single_crystal_validation.c:13912:5: warning: If memory allocation fails, then there is a possible null pointer dereference: true_overlap_lists [nullPointerOutOfMemory]
    MPI_MASTER(
    ^
Single_crystal_validation.c:15109:32: note: Assuming allocation function fails
    true_overlap_lists = malloc(number_of_volumes*sizeof(struct pointer_to_1d_int_list*));
                               ^
Single_crystal_validation.c:15109: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*));
                               ^
Single_crystal_validation.c:15113: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);
                           ^
Single_crystal_validation.c:13912:5: note: Null pointer dereference
    MPI_MASTER(
    ^
Single_crystal_validation.c:13918: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);
                                                    ^
Single_crystal_validation.c:13687:35: note: Assuming allocation function fails
  temporary_overlap_lists = malloc(number_of_volumes*sizeof(struct pointer_to_1d_int_list));
                                  ^
Single_crystal_validation.c:13687: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));
                                  ^
Single_crystal_validation.c:13918:53: note: Null pointer dereference
  for(child=1;child<number_of_volumes;child++) free(temporary_overlap_lists[child].elements);
                                                    ^
Single_crystal_validation.c:14210: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));
    ^
Single_crystal_validation.c:15120:27: note: Assuming allocation function fails
    parents_lists = malloc(number_of_volumes*sizeof(struct pointer_to_1d_int_list*));
                          ^
Single_crystal_validation.c:15120: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*));
                          ^
Single_crystal_validation.c:15121: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
                           ^
Single_crystal_validation.c:14210:5: note: Null pointer dereference
    parents_lists[iterate] = malloc(sizeof(struct pointer_to_1d_int_list));
    ^
Single_crystal_validation.c:14216: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]);
                                                            ^
Single_crystal_validation.c:15120:27: note: Assuming allocation function fails
    parents_lists = malloc(number_of_volumes*sizeof(struct pointer_to_1d_int_list*));
                          ^
Single_crystal_validation.c:15120: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*));
                          ^
Single_crystal_validation.c:15121: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
                           ^
Single_crystal_validation.c:14216:61: note: Null pointer dereference
      allocate_list_from_temp(used_elements,temp_list_local,parents_lists[iterate]);
                                                            ^
Single_crystal_validation.c:14258: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
    ^
Single_crystal_validation.c:15130:32: note: Assuming allocation function fails
    true_parents_lists = malloc(number_of_volumes*sizeof(struct pointer_to_1d_int_list*));
                               ^
Single_crystal_validation.c:15130: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*));
                               ^
Single_crystal_validation.c:15131: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);
                                ^
Single_crystal_validation.c:14258:5: note: Null pointer dereference
    parents_lists[iterate] = malloc(sizeof(struct pointer_to_1d_int_list)); // allocate_list_from_temp allocates
    ^
Single_crystal_validation.c:14261: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))
                         ^
Single_crystal_validation.c:15103:33: note: Assuming allocation function fails
    true_children_lists = malloc(number_of_volumes*sizeof(struct pointer_to_1d_int_list*));
                                ^
Single_crystal_validation.c:15103: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*));
                                ^
Single_crystal_validation.c:15131: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);
                                                    ^
Single_crystal_validation.c:14261:26: note: Null pointer dereference
        if (on_int_list(*true_children_lists[parent],iterate))
                         ^
Single_crystal_validation.c:14265: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]);
                                                            ^
Single_crystal_validation.c:15130:32: note: Assuming allocation function fails
    true_parents_lists = malloc(number_of_volumes*sizeof(struct pointer_to_1d_int_list*));
                               ^
Single_crystal_validation.c:15130: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*));
                               ^
Single_crystal_validation.c:15131: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);
                                ^
Single_crystal_validation.c:14265:61: note: Null pointer dereference
      allocate_list_from_temp(used_elements,temp_list_local,parents_lists[iterate]);
                                                            ^
Single_crystal_validation.c:14465: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));
    ^
Single_crystal_validation.c:15142:32: note: Assuming allocation function fails
    grandparents_lists = malloc(number_of_volumes*sizeof(struct pointer_to_1d_int_list*));
                               ^
Single_crystal_validation.c:15142: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*));
                               ^
Single_crystal_validation.c:15143: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);
                                ^
Single_crystal_validation.c:14465:5: note: Null pointer dereference
    grandparents_lists[iterate] = malloc(sizeof(struct pointer_to_1d_int_list));
    ^
Single_crystal_validation.c:14467: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++) {
                            ^
Single_crystal_validation.c:15120:27: note: Assuming allocation function fails
    parents_lists = malloc(number_of_volumes*sizeof(struct pointer_to_1d_int_list*));
                          ^
Single_crystal_validation.c:15120: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*));
                          ^
Single_crystal_validation.c:15143: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);
                                                   ^
Single_crystal_validation.c:14467:29: note: Null pointer dereference
    for (parent = 0; parent<parents_lists[iterate]->num_elements; parent++) {
                            ^
Single_crystal_validation.c:14469: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);
                          ^
Single_crystal_validation.c:15120:27: note: Assuming allocation function fails
    parents_lists = malloc(number_of_volumes*sizeof(struct pointer_to_1d_int_list*));
                          ^
Single_crystal_validation.c:15120: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*));
                          ^
Single_crystal_validation.c:15143: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);
                                                   ^
Single_crystal_validation.c:14469:27: note: Null pointer dereference
        on_both_int_lists(parents_lists[parents_lists[iterate]->elements[parent]], parents_lists[iterate], &common);
                          ^
Single_crystal_validation.c:14469: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);
                                        ^
Single_crystal_validation.c:15120:27: note: Assuming allocation function fails
    parents_lists = malloc(number_of_volumes*sizeof(struct pointer_to_1d_int_list*));
                          ^
Single_crystal_validation.c:15120: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*));
                          ^
Single_crystal_validation.c:15143: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);
                                                   ^
Single_crystal_validation.c:14469:41: note: Null pointer dereference
        on_both_int_lists(parents_lists[parents_lists[iterate]->elements[parent]], parents_lists[iterate], &common);
                                        ^
Single_crystal_validation.c:14469: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);
                                                                                   ^
Single_crystal_validation.c:15120:27: note: Assuming allocation function fails
    parents_lists = malloc(number_of_volumes*sizeof(struct pointer_to_1d_int_list*));
                          ^
Single_crystal_validation.c:15120: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*));
                          ^
Single_crystal_validation.c:15143: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);
                                                   ^
Single_crystal_validation.c:14469:84: note: Null pointer dereference
        on_both_int_lists(parents_lists[parents_lists[iterate]->elements[parent]], parents_lists[iterate], &common);
                                                                                   ^
Single_crystal_validation.c:14478: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]);
                                                            ^
Single_crystal_validation.c:15142:32: note: Assuming allocation function fails
    grandparents_lists = malloc(number_of_volumes*sizeof(struct pointer_to_1d_int_list*));
                               ^
Single_crystal_validation.c:15142: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*));
                               ^
Single_crystal_validation.c:15143: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);
                                ^
Single_crystal_validation.c:14478:61: note: Null pointer dereference
    allocate_list_from_temp(used_elements, temp_list_local, grandparents_lists[iterate]);
                                                            ^
Single_crystal_validation.c:14481:5: warning: If memory allocation fails, then there is a possible null pointer dereference: grandparents_lists [nullPointerOutOfMemory]
    MPI_MASTER(
    ^
Single_crystal_validation.c:15142:32: note: Assuming allocation function fails
    grandparents_lists = malloc(number_of_volumes*sizeof(struct pointer_to_1d_int_list*));
                               ^
Single_crystal_validation.c:15142: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*));
                               ^
Single_crystal_validation.c:15143: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);
                                ^
Single_crystal_validation.c:14481:5: note: Null pointer dereference
    MPI_MASTER(
    ^
Single_crystal_validation.c:14508: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;
                             ^
Single_crystal_validation.c:15109:32: note: Assuming allocation function fails
    true_overlap_lists = malloc(number_of_volumes*sizeof(struct pointer_to_1d_int_list*));
                               ^
Single_crystal_validation.c:15109: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*));
                               ^
Single_crystal_validation.c:15161: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);
                                             ^
Single_crystal_validation.c:14508:30: note: Null pointer dereference
    work_list.num_elements = true_overlap_lists[volume_index]->num_elements;
                             ^
Single_crystal_validation.c:14510: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];
                                                                                           ^
Single_crystal_validation.c:15109:32: note: Assuming allocation function fails
    true_overlap_lists = malloc(number_of_volumes*sizeof(struct pointer_to_1d_int_list*));
                               ^
Single_crystal_validation.c:15109: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*));
                               ^
Single_crystal_validation.c:15161: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);
                                             ^
Single_crystal_validation.c:14510: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];
                                                                                           ^
Single_crystal_validation.c:14555: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++)
                           ^
Single_crystal_validation.c:15103:33: note: Assuming allocation function fails
    true_children_lists = malloc(number_of_volumes*sizeof(struct pointer_to_1d_int_list*));
                                ^
Single_crystal_validation.c:15103: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*));
                                ^
Single_crystal_validation.c:15161: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);
                                                                 ^
Single_crystal_validation.c:14555:28: note: Null pointer dereference
    for (iterate=0;iterate<true_children_lists[volume_index]->num_elements;iterate++)
                           ^
Single_crystal_validation.c:14556: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]);
                                                 ^
Single_crystal_validation.c:15103:33: note: Assuming allocation function fails
    true_children_lists = malloc(number_of_volumes*sizeof(struct pointer_to_1d_int_list*));
                                ^
Single_crystal_validation.c:15103: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*));
                                ^
Single_crystal_validation.c:15161: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);
                                                                 ^
Single_crystal_validation.c:14556:50: note: Null pointer dereference
      remove_element_in_list_by_value(&work_list,true_children_lists[volume_index]->elements[iterate]);
                                                 ^
Single_crystal_validation.c:14561: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++)
                           ^
Single_crystal_validation.c:15156:46: note: Assuming allocation function fails
    true_grandparents_lists_no_masks = malloc(number_of_volumes*sizeof(struct pointer_to_1d_int_list*));
                                             ^
Single_crystal_validation.c:15156: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*));
                                             ^
Single_crystal_validation.c:15161: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);
                                                                                                                   ^
Single_crystal_validation.c:14561:28: note: Null pointer dereference
    for (iterate=0;iterate<true_grandparents_lists[volume_index]->num_elements;iterate++)
                           ^
Single_crystal_validation.c:14562: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]);
                                                 ^
Single_crystal_validation.c:15156:46: note: Assuming allocation function fails
    true_grandparents_lists_no_masks = malloc(number_of_volumes*sizeof(struct pointer_to_1d_int_list*));
                                             ^
Single_crystal_validation.c:15156: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*));
                                             ^
Single_crystal_validation.c:15161: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);
                                                                                                                   ^
Single_crystal_validation.c:14562:50: note: Null pointer dereference
      remove_element_in_list_by_value(&work_list,true_grandparents_lists[volume_index]->elements[iterate]);
                                                 ^
Single_crystal_validation.c:14576: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])){
                       ^
Single_crystal_validation.c:15135:41: note: Assuming allocation function fails
    true_parents_lists_no_masks = malloc(number_of_volumes*sizeof(struct pointer_to_1d_int_list*));
                                        ^
Single_crystal_validation.c:15135: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*));
                                        ^
Single_crystal_validation.c:15161: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);
                                                                                      ^
Single_crystal_validation.c:14576:24: note: Null pointer dereference
      if (on_int_list(*true_parents_lists[volume_index],work_list.elements[iterate])){
                       ^
Single_crystal_validation.c:14876: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++) {
                                 ^
Single_crystal_validation.c:15120:27: note: Assuming allocation function fails
    parents_lists = malloc(number_of_volumes*sizeof(struct pointer_to_1d_int_list*));
                          ^
Single_crystal_validation.c:15120: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*));
                          ^
Single_crystal_validation.c:15168: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);
                                   ^
Single_crystal_validation.c:14876:34: note: Null pointer dereference
            for (parent=0;parent<parents_lists[Volumes[volume_index]->geometry.children.elements[child]]->num_elements;parent++) {
                                 ^
Single_crystal_validation.c:14877: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]))
                                                                         ^
Single_crystal_validation.c:15120:27: note: Assuming allocation function fails
    parents_lists = malloc(number_of_volumes*sizeof(struct pointer_to_1d_int_list*));
                          ^
Single_crystal_validation.c:15120: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*));
                          ^
Single_crystal_validation.c:15168: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);
                                   ^
Single_crystal_validation.c:14877: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]))
                                                                         ^
Single_crystal_validation.c:15183: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);
            ^
Single_crystal_validation.c:15109:32: note: Assuming allocation function fails
    true_overlap_lists = malloc(number_of_volumes*sizeof(struct pointer_to_1d_int_list*));
                               ^
Single_crystal_validation.c:15109: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*));
                               ^
Single_crystal_validation.c:15183:13: note: Null pointer dereference
        if (true_overlap_lists[iterate]->num_elements > 0) free(true_overlap_lists[iterate]->elements);
            ^
Single_crystal_validation.c:15184:14: warning: If memory allocation fails, then there is a possible null pointer dereference: true_overlap_lists [nullPointerOutOfMemory]
        free(true_overlap_lists[iterate]);
             ^
Single_crystal_validation.c:15109:32: note: Assuming allocation function fails
    true_overlap_lists = malloc(number_of_volumes*sizeof(struct pointer_to_1d_int_list*));
                               ^
Single_crystal_validation.c:15109: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*));
                               ^
Single_crystal_validation.c:15184:14: note: Null pointer dereference
        free(true_overlap_lists[iterate]);
             ^
Single_crystal_validation.c:15187: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);
            ^
Single_crystal_validation.c:15111:31: note: Assuming allocation function fails
    raw_overlap_lists = malloc(number_of_volumes*sizeof(struct pointer_to_1d_int_list*));
                              ^
Single_crystal_validation.c:15111: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*));
                              ^
Single_crystal_validation.c:15187:13: note: Null pointer dereference
        if (raw_overlap_lists[iterate]->num_elements > 0) free(raw_overlap_lists[iterate]->elements);
            ^
Single_crystal_validation.c:15188:14: warning: If memory allocation fails, then there is a possible null pointer dereference: raw_overlap_lists [nullPointerOutOfMemory]
        free(raw_overlap_lists[iterate]);
             ^
Single_crystal_validation.c:15111:31: note: Assuming allocation function fails
    raw_overlap_lists = malloc(number_of_volumes*sizeof(struct pointer_to_1d_int_list*));
                              ^
Single_crystal_validation.c:15111: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*));
                              ^
Single_crystal_validation.c:15188:14: note: Null pointer dereference
        free(raw_overlap_lists[iterate]);
             ^
Single_crystal_validation.c:15191: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);
            ^
Single_crystal_validation.c:15120:27: note: Assuming allocation function fails
    parents_lists = malloc(number_of_volumes*sizeof(struct pointer_to_1d_int_list*));
                          ^
Single_crystal_validation.c:15120: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*));
                          ^
Single_crystal_validation.c:15191:13: note: Null pointer dereference
        if (parents_lists[iterate]->num_elements > 0) free(parents_lists[iterate]->elements);
            ^
Single_crystal_validation.c:15192:14: warning: If memory allocation fails, then there is a possible null pointer dereference: parents_lists [nullPointerOutOfMemory]
        free(parents_lists[iterate]);
             ^
Single_crystal_validation.c:15120:27: note: Assuming allocation function fails
    parents_lists = malloc(number_of_volumes*sizeof(struct pointer_to_1d_int_list*));
                          ^
Single_crystal_validation.c:15120: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*));
                          ^
Single_crystal_validation.c:15192:14: note: Null pointer dereference
        free(parents_lists[iterate]);
             ^
Single_crystal_validation.c:15195: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);
            ^
Single_crystal_validation.c:15125:36: note: Assuming allocation function fails
    parents_lists_no_masks = malloc(number_of_volumes*sizeof(struct pointer_to_1d_int_list*));
                                   ^
Single_crystal_validation.c:15125: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*));
                                   ^
Single_crystal_validation.c:15195:13: note: Null pointer dereference
        if (parents_lists_no_masks[iterate]->num_elements > 0) free(parents_lists_no_masks[iterate]->elements);
            ^
Single_crystal_validation.c:15196: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]);
             ^
Single_crystal_validation.c:15125:36: note: Assuming allocation function fails
    parents_lists_no_masks = malloc(number_of_volumes*sizeof(struct pointer_to_1d_int_list*));
                                   ^
Single_crystal_validation.c:15125: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*));
                                   ^
Single_crystal_validation.c:15196:14: note: Null pointer dereference
        free(parents_lists_no_masks[iterate]);
             ^
Single_crystal_validation.c:15199: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);
            ^
Single_crystal_validation.c:15130:32: note: Assuming allocation function fails
    true_parents_lists = malloc(number_of_volumes*sizeof(struct pointer_to_1d_int_list*));
                               ^
Single_crystal_validation.c:15130: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*));
                               ^
Single_crystal_validation.c:15199:13: note: Null pointer dereference
        if (true_parents_lists[iterate]->num_elements > 0) free(true_parents_lists[iterate]->elements);
            ^
Single_crystal_validation.c:15200:14: warning: If memory allocation fails, then there is a possible null pointer dereference: true_parents_lists [nullPointerOutOfMemory]
        free(true_parents_lists[iterate]);
             ^
Single_crystal_validation.c:15130:32: note: Assuming allocation function fails
    true_parents_lists = malloc(number_of_volumes*sizeof(struct pointer_to_1d_int_list*));
                               ^
Single_crystal_validation.c:15130: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*));
                               ^
Single_crystal_validation.c:15200:14: note: Null pointer dereference
        free(true_parents_lists[iterate]);
             ^
Single_crystal_validation.c:15203: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);
            ^
Single_crystal_validation.c:15135:41: note: Assuming allocation function fails
    true_parents_lists_no_masks = malloc(number_of_volumes*sizeof(struct pointer_to_1d_int_list*));
                                        ^
Single_crystal_validation.c:15135: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*));
                                        ^
Single_crystal_validation.c:15203:13: note: Null pointer dereference
        if (true_parents_lists_no_masks[iterate]->num_elements > 0) free(true_parents_lists_no_masks[iterate]->elements);
            ^
Single_crystal_validation.c:15204: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]);
             ^
Single_crystal_validation.c:15135:41: note: Assuming allocation function fails
    true_parents_lists_no_masks = malloc(number_of_volumes*sizeof(struct pointer_to_1d_int_list*));
                                        ^
Single_crystal_validation.c:15135: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*));
                                        ^
Single_crystal_validation.c:15204:14: note: Null pointer dereference
        free(true_parents_lists_no_masks[iterate]);
             ^
Single_crystal_validation.c:15207: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);
            ^
Single_crystal_validation.c:15142:32: note: Assuming allocation function fails
    grandparents_lists = malloc(number_of_volumes*sizeof(struct pointer_to_1d_int_list*));
                               ^
Single_crystal_validation.c:15142: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*));
                               ^
Single_crystal_validation.c:15207:13: note: Null pointer dereference
        if (grandparents_lists[iterate]->num_elements > 0) free(grandparents_lists[iterate]->elements);
            ^
Single_crystal_validation.c:15208:14: warning: If memory allocation fails, then there is a possible null pointer dereference: grandparents_lists [nullPointerOutOfMemory]
        free(grandparents_lists[iterate]);
             ^
Single_crystal_validation.c:15142:32: note: Assuming allocation function fails
    grandparents_lists = malloc(number_of_volumes*sizeof(struct pointer_to_1d_int_list*));
                               ^
Single_crystal_validation.c:15142: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*));
                               ^
Single_crystal_validation.c:15208:14: note: Null pointer dereference
        free(grandparents_lists[iterate]);
             ^
Single_crystal_validation.c:15211: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);
            ^
Single_crystal_validation.c:15152:37: note: Assuming allocation function fails
    true_grandparents_lists = malloc(number_of_volumes*sizeof(struct pointer_to_1d_int_list*));
                                    ^
Single_crystal_validation.c:15152: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*));
                                    ^
Single_crystal_validation.c:15211:13: note: Null pointer dereference
        if (true_grandparents_lists[iterate]->num_elements > 0) free(true_grandparents_lists[iterate]->elements);
            ^
Single_crystal_validation.c:15212:14: warning: If memory allocation fails, then there is a possible null pointer dereference: true_grandparents_lists [nullPointerOutOfMemory]
        free(true_grandparents_lists[iterate]);
             ^
Single_crystal_validation.c:15152:37: note: Assuming allocation function fails
    true_grandparents_lists = malloc(number_of_volumes*sizeof(struct pointer_to_1d_int_list*));
                                    ^
Single_crystal_validation.c:15152: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*));
                                    ^
Single_crystal_validation.c:15212:14: note: Null pointer dereference
        free(true_grandparents_lists[iterate]);
             ^
Single_crystal_validation.c:15215: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);
            ^
Single_crystal_validation.c:15147:41: note: Assuming allocation function fails
    grandparents_lists_no_masks = malloc(number_of_volumes*sizeof(struct pointer_to_1d_int_list*));
                                        ^
Single_crystal_validation.c:15147: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*));
                                        ^
Single_crystal_validation.c:15215:13: note: Null pointer dereference
        if (grandparents_lists_no_masks[iterate]->num_elements > 0) free(grandparents_lists_no_masks[iterate]->elements);
            ^
Single_crystal_validation.c:15216: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]);
             ^
Single_crystal_validation.c:15147:41: note: Assuming allocation function fails
    grandparents_lists_no_masks = malloc(number_of_volumes*sizeof(struct pointer_to_1d_int_list*));
                                        ^
Single_crystal_validation.c:15147: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*));
                                        ^
Single_crystal_validation.c:15216:14: note: Null pointer dereference
        free(grandparents_lists_no_masks[iterate]);
             ^
Single_crystal_validation.c:15219: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);
            ^
Single_crystal_validation.c:15156:46: note: Assuming allocation function fails
    true_grandparents_lists_no_masks = malloc(number_of_volumes*sizeof(struct pointer_to_1d_int_list*));
                                             ^
Single_crystal_validation.c:15156: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*));
                                             ^
Single_crystal_validation.c:15219:13: note: Null pointer dereference
        if (true_grandparents_lists_no_masks[iterate]->num_elements > 0) free(true_grandparents_lists_no_masks[iterate]->elements);
            ^
Single_crystal_validation.c:15220: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]);
             ^
Single_crystal_validation.c:15156:46: note: Assuming allocation function fails
    true_grandparents_lists_no_masks = malloc(number_of_volumes*sizeof(struct pointer_to_1d_int_list*));
                                             ^
Single_crystal_validation.c:15156: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*));
                                             ^
Single_crystal_validation.c:15220:14: note: Null pointer dereference
        free(true_grandparents_lists_no_masks[iterate]);
             ^
Single_crystal_validation.c:15223: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);
            ^
Single_crystal_validation.c:15103:33: note: Assuming allocation function fails
    true_children_lists = malloc(number_of_volumes*sizeof(struct pointer_to_1d_int_list*));
                                ^
Single_crystal_validation.c:15103: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*));
                                ^
Single_crystal_validation.c:15223:13: note: Null pointer dereference
        if (true_children_lists[iterate]->num_elements > 0) free(true_children_lists[iterate]->elements);
            ^
Single_crystal_validation.c:15224:14: warning: If memory allocation fails, then there is a possible null pointer dereference: true_children_lists [nullPointerOutOfMemory]
        free(true_children_lists[iterate]);
             ^
Single_crystal_validation.c:15103:33: note: Assuming allocation function fails
    true_children_lists = malloc(number_of_volumes*sizeof(struct pointer_to_1d_int_list*));
                                ^
Single_crystal_validation.c:15103: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*));
                                ^
Single_crystal_validation.c:15224:14: note: Null pointer dereference
        free(true_children_lists[iterate]);
             ^
Single_crystal_validation.c:15412: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");
          ^
Single_crystal_validation.c:15411:13: note: Assuming allocation function fails
  fp = fopen("Union_absorption.dat","w");
            ^
Single_crystal_validation.c:15411:13: note: Assignment 'fp=fopen("Union_absorption.dat","w")', assigned value is 0
  fp = fopen("Union_absorption.dat","w");
            ^
Single_crystal_validation.c:15412: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");
          ^
Single_crystal_validation.c:15414:10: warning: If resource allocation fails, then there is a possible null pointer dereference: fp [nullPointerOutOfResources]
  fclose(fp);
         ^
Single_crystal_validation.c:15411:13: note: Assuming allocation function fails
  fp = fopen("Union_absorption.dat","w");
            ^
Single_crystal_validation.c:15411:13: note: Assignment 'fp=fopen("Union_absorption.dat","w")', assigned value is 0
  fp = fopen("Union_absorption.dat","w");
            ^
Single_crystal_validation.c:15414:10: note: Null pointer dereference
  fclose(fp);
         ^
Single_crystal_validation.c:15427: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",
            ^
Single_crystal_validation.c:15420:13: note: Assuming allocation function fails
  fp = fopen("Union_absorption.dat","a");
            ^
Single_crystal_validation.c:15420:13: note: Assignment 'fp=fopen("Union_absorption.dat","a")', assigned value is 0
  fp = fopen("Union_absorption.dat","a");
            ^
Single_crystal_validation.c:15427:13: note: Null pointer dereference
    fprintf(fp,"%g, %g, %g, %g, %g, %g, %g, %g, %e, %i, %i \n",
            ^
Single_crystal_validation.c:15435:10: warning: If resource allocation fails, then there is a possible null pointer dereference: fp [nullPointerOutOfResources]
  fclose(fp);
         ^
Single_crystal_validation.c:15420:13: note: Assuming allocation function fails
  fp = fopen("Union_absorption.dat","a");
            ^
Single_crystal_validation.c:15420:13: note: Assignment 'fp=fopen("Union_absorption.dat","a")', assigned value is 0
  fp = fopen("Union_absorption.dat","a");
            ^
Single_crystal_validation.c:15435:10: note: Null pointer dereference
  fclose(fp);
         ^
Single_crystal_validation.c:18887:7: warning: If memory allocation fails, then there is a possible null pointer dereference: list [nullPointerOutOfMemory]
      list[i].h = h;
      ^
Single_crystal_validation.c:18870:42: note: Assuming allocation function fails
    list = (struct hkl_data_union*)malloc(size*sizeof(struct hkl_data_union));
                                         ^
Single_crystal_validation.c:18870:12: note: Assignment 'list=(struct hkl_data_union*)malloc(size*sizeof(struct hkl_data_union))', assigned value is 0
    list = (struct hkl_data_union*)malloc(size*sizeof(struct hkl_data_union));
           ^
Single_crystal_validation.c:18887:7: note: Null pointer dereference
      list[i].h = h;
      ^
Single_crystal_validation.c:18888:7: warning: If memory allocation fails, then there is a possible null pointer dereference: list [nullPointerOutOfMemory]
      list[i].k = k;
      ^
Single_crystal_validation.c:18870:42: note: Assuming allocation function fails
    list = (struct hkl_data_union*)malloc(size*sizeof(struct hkl_data_union));
                                         ^
Single_crystal_validation.c:18870:12: note: Assignment 'list=(struct hkl_data_union*)malloc(size*sizeof(struct hkl_data_union))', assigned value is 0
    list = (struct hkl_data_union*)malloc(size*sizeof(struct hkl_data_union));
           ^
Single_crystal_validation.c:18888:7: note: Null pointer dereference
      list[i].k = k;
      ^
Single_crystal_validation.c:18889:7: warning: If memory allocation fails, then there is a possible null pointer dereference: list [nullPointerOutOfMemory]
      list[i].l = l;
      ^
Single_crystal_validation.c:18870:42: note: Assuming allocation function fails
    list = (struct hkl_data_union*)malloc(size*sizeof(struct hkl_data_union));
                                         ^
Single_crystal_validation.c:18870:12: note: Assignment 'list=(struct hkl_data_union*)malloc(size*sizeof(struct hkl_data_union))', assigned value is 0
    list = (struct hkl_data_union*)malloc(size*sizeof(struct hkl_data_union));
           ^
Single_crystal_validation.c:18889:7: note: Null pointer dereference
      list[i].l = l;
      ^
Single_crystal_validation.c:18890:7: warning: If memory allocation fails, then there is a possible null pointer dereference: list [nullPointerOutOfMemory]
      list[i].F2 = F2;
      ^
Single_crystal_validation.c:18870:42: note: Assuming allocation function fails
    list = (struct hkl_data_union*)malloc(size*sizeof(struct hkl_data_union));
                                         ^
Single_crystal_validation.c:18870:12: note: Assignment 'list=(struct hkl_data_union*)malloc(size*sizeof(struct hkl_data_union))', assigned value is 0
    list = (struct hkl_data_union*)malloc(size*sizeof(struct hkl_data_union));
           ^
Single_crystal_validation.c:18890:7: note: Null pointer dereference
      list[i].F2 = F2;
      ^
Single_crystal_validation.c:18893:7: warning: If memory allocation fails, then there is a possible null pointer dereference: list [nullPointerOutOfMemory]
      list[i].tau_x = h*info->asx + k*info->bsx + l*info->csx;
      ^
Single_crystal_validation.c:18870:42: note: Assuming allocation function fails
    list = (struct hkl_data_union*)malloc(size*sizeof(struct hkl_data_union));
                                         ^
Single_crystal_validation.c:18870:12: note: Assignment 'list=(struct hkl_data_union*)malloc(size*sizeof(struct hkl_data_union))', assigned value is 0
    list = (struct hkl_data_union*)malloc(size*sizeof(struct hkl_data_union));
           ^
Single_crystal_validation.c:18893:7: note: Null pointer dereference
      list[i].tau_x = h*info->asx + k*info->bsx + l*info->csx;
      ^
Single_crystal_validation.c:18894:7: warning: If memory allocation fails, then there is a possible null pointer dereference: list [nullPointerOutOfMemory]
      list[i].tau_y = h*info->asy + k*info->bsy + l*info->csy;
      ^
Single_crystal_validation.c:18870:42: note: Assuming allocation function fails
    list = (struct hkl_data_union*)malloc(size*sizeof(struct hkl_data_union));
                                         ^
Single_crystal_validation.c:18870:12: note: Assignment 'list=(struct hkl_data_union*)malloc(size*sizeof(struct hkl_data_union))', assigned value is 0
    list = (struct hkl_data_union*)malloc(size*sizeof(struct hkl_data_union));
           ^
Single_crystal_validation.c:18894:7: note: Null pointer dereference
      list[i].tau_y = h*info->asy + k*info->bsy + l*info->csy;
      ^
Single_crystal_validation.c:18895:7: warning: If memory allocation fails, then there is a possible null pointer dereference: list [nullPointerOutOfMemory]
      list[i].tau_z = h*info->asz + k*info->bsz + l*info->csz;
      ^
Single_crystal_validation.c:18870:42: note: Assuming allocation function fails
    list = (struct hkl_data_union*)malloc(size*sizeof(struct hkl_data_union));
                                         ^
Single_crystal_validation.c:18870:12: note: Assignment 'list=(struct hkl_data_union*)malloc(size*sizeof(struct hkl_data_union))', assigned value is 0
    list = (struct hkl_data_union*)malloc(size*sizeof(struct hkl_data_union));
           ^
Single_crystal_validation.c:18895:7: note: Null pointer dereference
      list[i].tau_z = h*info->asz + k*info->bsz + l*info->csz;
      ^
Single_crystal_validation.c:18896:7: warning: If memory allocation fails, then there is a possible null pointer dereference: list [nullPointerOutOfMemory]
      list[i].tau = sqrt(list[i].tau_x*list[i].tau_x +
      ^
Single_crystal_validation.c:18870:42: note: Assuming allocation function fails
    list = (struct hkl_data_union*)malloc(size*sizeof(struct hkl_data_union));
                                         ^
Single_crystal_validation.c:18870:12: note: Assignment 'list=(struct hkl_data_union*)malloc(size*sizeof(struct hkl_data_union))', assigned value is 0
    list = (struct hkl_data_union*)malloc(size*sizeof(struct hkl_data_union));
           ^
Single_crystal_validation.c:18896:7: note: Null pointer dereference
      list[i].tau = sqrt(list[i].tau_x*list[i].tau_x +
      ^
Single_crystal_validation.c:18896:26: warning: If memory allocation fails, then there is a possible null pointer dereference: list [nullPointerOutOfMemory]
      list[i].tau = sqrt(list[i].tau_x*list[i].tau_x +
                         ^
Single_crystal_validation.c:18870:42: note: Assuming allocation function fails
    list = (struct hkl_data_union*)malloc(size*sizeof(struct hkl_data_union));
                                         ^
Single_crystal_validation.c:18870:12: note: Assignment 'list=(struct hkl_data_union*)malloc(size*sizeof(struct hkl_data_union))', assigned value is 0
    list = (struct hkl_data_union*)malloc(size*sizeof(struct hkl_data_union));
           ^
Single_crystal_validation.c:18896:26: note: Null pointer dereference
      list[i].tau = sqrt(list[i].tau_x*list[i].tau_x +
                         ^
Single_crystal_validation.c:18896:40: warning: If memory allocation fails, then there is a possible null pointer dereference: list [nullPointerOutOfMemory]
      list[i].tau = sqrt(list[i].tau_x*list[i].tau_x +
                                       ^
Single_crystal_validation.c:18870:42: note: Assuming allocation function fails
    list = (struct hkl_data_union*)malloc(size*sizeof(struct hkl_data_union));
                                         ^
Single_crystal_validation.c:18870:12: note: Assignment 'list=(struct hkl_data_union*)malloc(size*sizeof(struct hkl_data_union))', assigned value is 0
    list = (struct hkl_data_union*)malloc(size*sizeof(struct hkl_data_union));
           ^
Single_crystal_validation.c:18896:40: note: Null pointer dereference
      list[i].tau = sqrt(list[i].tau_x*list[i].tau_x +
                                       ^
Single_crystal_validation.c:18897:26: warning: If memory allocation fails, then there is a possible null pointer dereference: list [nullPointerOutOfMemory]
                         list[i].tau_y*list[i].tau_y +
                         ^
Single_crystal_validation.c:18870:42: note: Assuming allocation function fails
    list = (struct hkl_data_union*)malloc(size*sizeof(struct hkl_data_union));
                                         ^
Single_crystal_validation.c:18870:12: note: Assignment 'list=(struct hkl_data_union*)malloc(size*sizeof(struct hkl_data_union))', assigned value is 0
    list = (struct hkl_data_union*)malloc(size*sizeof(struct hkl_data_union));
           ^
Single_crystal_validation.c:18897:26: note: Null pointer dereference
                         list[i].tau_y*list[i].tau_y +
                         ^
Single_crystal_validation.c:18897:40: warning: If memory allocation fails, then there is a possible null pointer dereference: list [nullPointerOutOfMemory]
                         list[i].tau_y*list[i].tau_y +
                                       ^
Single_crystal_validation.c:18870:42: note: Assuming allocation function fails
    list = (struct hkl_data_union*)malloc(size*sizeof(struct hkl_data_union));
                                         ^
Single_crystal_validation.c:18870:12: note: Assignment 'list=(struct hkl_data_union*)malloc(size*sizeof(struct hkl_data_union))', assigned value is 0
    list = (struct hkl_data_union*)malloc(size*sizeof(struct hkl_data_union));
           ^
Single_crystal_validation.c:18897:40: note: Null pointer dereference
                         list[i].tau_y*list[i].tau_y +
                                       ^
Single_crystal_validation.c:18898:26: warning: If memory allocation fails, then there is a possible null pointer dereference: list [nullPointerOutOfMemory]
                         list[i].tau_z*list[i].tau_z);
                         ^
Single_crystal_validation.c:18870:42: note: Assuming allocation function fails
    list = (struct hkl_data_union*)malloc(size*sizeof(struct hkl_data_union));
                                         ^
Single_crystal_validation.c:18870:12: note: Assignment 'list=(struct hkl_data_union*)malloc(size*sizeof(struct hkl_data_union))', assigned value is 0
    list = (struct hkl_data_union*)malloc(size*sizeof(struct hkl_data_union));
           ^
Single_crystal_validation.c:18898:26: note: Null pointer dereference
                         list[i].tau_z*list[i].tau_z);
                         ^
Single_crystal_validation.c:18898:40: warning: If memory allocation fails, then there is a possible null pointer dereference: list [nullPointerOutOfMemory]
                         list[i].tau_z*list[i].tau_z);
                                       ^
Single_crystal_validation.c:18870:42: note: Assuming allocation function fails
    list = (struct hkl_data_union*)malloc(size*sizeof(struct hkl_data_union));
                                         ^
Single_crystal_validation.c:18870:12: note: Assignment 'list=(struct hkl_data_union*)malloc(size*sizeof(struct hkl_data_union))', assigned value is 0
    list = (struct hkl_data_union*)malloc(size*sizeof(struct hkl_data_union));
           ^
Single_crystal_validation.c:18898:40: note: Null pointer dereference
                         list[i].tau_z*list[i].tau_z);
                                       ^
Single_crystal_validation.c:18899:7: warning: If memory allocation fails, then there is a possible null pointer dereference: list [nullPointerOutOfMemory]
      list[i].u1x = list[i].tau_x/list[i].tau;
      ^
Single_crystal_validation.c:18870:42: note: Assuming allocation function fails
    list = (struct hkl_data_union*)malloc(size*sizeof(struct hkl_data_union));
                                         ^
Single_crystal_validation.c:18870:12: note: Assignment 'list=(struct hkl_data_union*)malloc(size*sizeof(struct hkl_data_union))', assigned value is 0
    list = (struct hkl_data_union*)malloc(size*sizeof(struct hkl_data_union));
           ^
Single_crystal_validation.c:18899:7: note: Null pointer dereference
      list[i].u1x = list[i].tau_x/list[i].tau;
      ^
Single_crystal_validation.c:18899:21: warning: If memory allocation fails, then there is a possible null pointer dereference: list [nullPointerOutOfMemory]
      list[i].u1x = list[i].tau_x/list[i].tau;
                    ^
Single_crystal_validation.c:18870:42: note: Assuming allocation function fails
    list = (struct hkl_data_union*)malloc(size*sizeof(struct hkl_data_union));
                                         ^
Single_crystal_validation.c:18870:12: note: Assignment 'list=(struct hkl_data_union*)malloc(size*sizeof(struct hkl_data_union))', assigned value is 0
    list = (struct hkl_data_union*)malloc(size*sizeof(struct hkl_data_union));
           ^
Single_crystal_validation.c:18899:21: note: Null pointer dereference
      list[i].u1x = list[i].tau_x/list[i].tau;
                    ^
Single_crystal_validation.c:18899:35: warning: If memory allocation fails, then there is a possible null pointer dereference: list [nullPointerOutOfMemory]
      list[i].u1x = list[i].tau_x/list[i].tau;
                                  ^
Single_crystal_validation.c:18870:42: note: Assuming allocation function fails
    list = (struct hkl_data_union*)malloc(size*sizeof(struct hkl_data_union));
                                         ^
Single_crystal_validation.c:18870:12: note: Assignment 'list=(struct hkl_data_union*)malloc(size*sizeof(struct hkl_data_union))', assigned value is 0
    list = (struct hkl_data_union*)malloc(size*sizeof(struct hkl_data_union));
           ^
Single_crystal_validation.c:18899:35: note: Null pointer dereference
      list[i].u1x = list[i].tau_x/list[i].tau;
                                  ^
Single_crystal_validation.c:18900:7: warning: If memory allocation fails, then there is a possible null pointer dereference: list [nullPointerOutOfMemory]
      list[i].u1y = list[i].tau_y/list[i].tau;
      ^
Single_crystal_validation.c:18870:42: note: Assuming allocation function fails
    list = (struct hkl_data_union*)malloc(size*sizeof(struct hkl_data_union));
                                         ^
Single_crystal_validation.c:18870:12: note: Assignment 'list=(struct hkl_data_union*)malloc(size*sizeof(struct hkl_data_union))', assigned value is 0
    list = (struct hkl_data_union*)malloc(size*sizeof(struct hkl_data_union));
           ^
Single_crystal_validation.c:18900:7: note: Null pointer dereference
      list[i].u1y = list[i].tau_y/list[i].tau;
      ^
Single_crystal_validation.c:18900:21: warning: If memory allocation fails, then there is a possible null pointer dereference: list [nullPointerOutOfMemory]
      list[i].u1y = list[i].tau_y/list[i].tau;
                    ^
Single_crystal_validation.c:18870:42: note: Assuming allocation function fails
    list = (struct hkl_data_union*)malloc(size*sizeof(struct hkl_data_union));
                                         ^
Single_crystal_validation.c:18870:12: note: Assignment 'list=(struct hkl_data_union*)malloc(size*sizeof(struct hkl_data_union))', assigned value is 0
    list = (struct hkl_data_union*)malloc(size*sizeof(struct hkl_data_union));
           ^
Single_crystal_validation.c:18900:21: note: Null pointer dereference
      list[i].u1y = list[i].tau_y/list[i].tau;
                    ^
Single_crystal_validation.c:18900:35: warning: If memory allocation fails, then there is a possible null pointer dereference: list [nullPointerOutOfMemory]
      list[i].u1y = list[i].tau_y/list[i].tau;
                                  ^
Single_crystal_validation.c:18870:42: note: Assuming allocation function fails
    list = (struct hkl_data_union*)malloc(size*sizeof(struct hkl_data_union));
                                         ^
Single_crystal_validation.c:18870:12: note: Assignment 'list=(struct hkl_data_union*)malloc(size*sizeof(struct hkl_data_union))', assigned value is 0
    list = (struct hkl_data_union*)malloc(size*sizeof(struct hkl_data_union));
           ^
Single_crystal_validation.c:18900:35: note: Null pointer dereference
      list[i].u1y = list[i].tau_y/list[i].tau;
                                  ^
Single_crystal_validation.c:18901:7: warning: If memory allocation fails, then there is a possible null pointer dereference: list [nullPointerOutOfMemory]
      list[i].u1z = list[i].tau_z/list[i].tau;
      ^
Single_crystal_validation.c:18870:42: note: Assuming allocation function fails
    list = (struct hkl_data_union*)malloc(size*sizeof(struct hkl_data_union));
                                         ^
Single_crystal_validation.c:18870:12: note: Assignment 'list=(struct hkl_data_union*)malloc(size*sizeof(struct hkl_data_union))', assigned value is 0
    list = (struct hkl_data_union*)malloc(size*sizeof(struct hkl_data_union));
           ^
Single_crystal_validation.c:18901:7: note: Null pointer dereference
      list[i].u1z = list[i].tau_z/list[i].tau;
      ^
Single_crystal_validation.c:18901:21: warning: If memory allocation fails, then there is a possible null pointer dereference: list [nullPointerOutOfMemory]
      list[i].u1z = list[i].tau_z/list[i].tau;
                    ^
Single_crystal_validation.c:18870:42: note: Assuming allocation function fails
    list = (struct hkl_data_union*)malloc(size*sizeof(struct hkl_data_union));
                                         ^
Single_crystal_validation.c:18870:12: note: Assignment 'list=(struct hkl_data_union*)malloc(size*sizeof(struct hkl_data_union))', assigned value is 0
    list = (struct hkl_data_union*)malloc(size*sizeof(struct hkl_data_union));
           ^
Single_crystal_validation.c:18901:21: note: Null pointer dereference
      list[i].u1z = list[i].tau_z/list[i].tau;
                    ^
Single_crystal_validation.c:18901:35: warning: If memory allocation fails, then there is a possible null pointer dereference: list [nullPointerOutOfMemory]
      list[i].u1z = list[i].tau_z/list[i].tau;
                                  ^
Single_crystal_validation.c:18870:42: note: Assuming allocation function fails
    list = (struct hkl_data_union*)malloc(size*sizeof(struct hkl_data_union));
                                         ^
Single_crystal_validation.c:18870:12: note: Assignment 'list=(struct hkl_data_union*)malloc(size*sizeof(struct hkl_data_union))', assigned value is 0
    list = (struct hkl_data_union*)malloc(size*sizeof(struct hkl_data_union));
           ^
Single_crystal_validation.c:18901:35: note: Null pointer dereference
      list[i].u1z = list[i].tau_z/list[i].tau;
                                  ^
Single_crystal_validation.c:18902:41: warning: If memory allocation fails, then there is a possible null pointer dereference: list [nullPointerOutOfMemory]
      sig1 = FWHM2RMS*info->m_delta_d_d*list[i].tau;
                                        ^
Single_crystal_validation.c:18870:42: note: Assuming allocation function fails
    list = (struct hkl_data_union*)malloc(size*sizeof(struct hkl_data_union));
                                         ^
Single_crystal_validation.c:18870:12: note: Assignment 'list=(struct hkl_data_union*)malloc(size*sizeof(struct hkl_data_union))', assigned value is 0
    list = (struct hkl_data_union*)malloc(size*sizeof(struct hkl_data_union));
           ^
Single_crystal_validation.c:18902:41: note: Null pointer dereference
      sig1 = FWHM2RMS*info->m_delta_d_d*list[i].tau;
                                        ^
Single_crystal_validation.c:18906:18: warning: If memory allocation fails, then there is a possible null pointer dereference: list [nullPointerOutOfMemory]
                 list[i].u1x, list[i].u1y, list[i].u1z);
                 ^
Single_crystal_validation.c:18870:42: note: Assuming allocation function fails
    list = (struct hkl_data_union*)malloc(size*sizeof(struct hkl_data_union));
                                         ^
Single_crystal_validation.c:18870:12: note: Assignment 'list=(struct hkl_data_union*)malloc(size*sizeof(struct hkl_data_union))', assigned value is 0
    list = (struct hkl_data_union*)malloc(size*sizeof(struct hkl_data_union));
           ^
Single_crystal_validation.c:18906:18: note: Null pointer dereference
                 list[i].u1x, list[i].u1y, list[i].u1z);
                 ^
Single_crystal_validation.c:18906:31: warning: If memory allocation fails, then there is a possible null pointer dereference: list [nullPointerOutOfMemory]
                 list[i].u1x, list[i].u1y, list[i].u1z);
                              ^
Single_crystal_validation.c:18870:42: note: Assuming allocation function fails
    list = (struct hkl_data_union*)malloc(size*sizeof(struct hkl_data_union));
                                         ^
Single_crystal_validation.c:18870:12: note: Assignment 'list=(struct hkl_data_union*)malloc(size*sizeof(struct hkl_data_union))', assigned value is 0
    list = (struct hkl_data_union*)malloc(size*sizeof(struct hkl_data_union));
           ^
Single_crystal_validation.c:18906:31: note: Null pointer dereference
                 list[i].u1x, list[i].u1y, list[i].u1z);
                              ^
Single_crystal_validation.c:18906:44: warning: If memory allocation fails, then there is a possible null pointer dereference: list [nullPointerOutOfMemory]
                 list[i].u1x, list[i].u1y, list[i].u1z);
                                           ^
Single_crystal_validation.c:18870:42: note: Assuming allocation function fails
    list = (struct hkl_data_union*)malloc(size*sizeof(struct hkl_data_union));
                                         ^
Single_crystal_validation.c:18870:12: note: Assignment 'list=(struct hkl_data_union*)malloc(size*sizeof(struct hkl_data_union))', assigned value is 0
    list = (struct hkl_data_union*)malloc(size*sizeof(struct hkl_data_union));
           ^
Single_crystal_validation.c:18906:44: note: Null pointer dereference
                 list[i].u1x, list[i].u1y, list[i].u1z);
                                           ^
Single_crystal_validation.c:18907:7: warning: If memory allocation fails, then there is a possible null pointer dereference: list [nullPointerOutOfMemory]
      vec_prod(b2[0], b2[1], b2[2],
      ^
Single_crystal_validation.c:18870:42: note: Assuming allocation function fails
    list = (struct hkl_data_union*)malloc(size*sizeof(struct hkl_data_union));
                                         ^
Single_crystal_validation.c:18870:12: note: Assignment 'list=(struct hkl_data_union*)malloc(size*sizeof(struct hkl_data_union))', assigned value is 0
    list = (struct hkl_data_union*)malloc(size*sizeof(struct hkl_data_union));
           ^
Single_crystal_validation.c:18907:7: note: Null pointer dereference
      vec_prod(b2[0], b2[1], b2[2],
      ^
Single_crystal_validation.c:18914:9: warning: If memory allocation fails, then there is a possible null pointer dereference: list [nullPointerOutOfMemory]
        list[i].u2x = b1[0];
        ^
Single_crystal_validation.c:18870:42: note: Assuming allocation function fails
    list = (struct hkl_data_union*)malloc(size*sizeof(struct hkl_data_union));
                                         ^
Single_crystal_validation.c:18870:12: note: Assignment 'list=(struct hkl_data_union*)malloc(size*sizeof(struct hkl_data_union))', assigned value is 0
    list = (struct hkl_data_union*)malloc(size*sizeof(struct hkl_data_union));
           ^
Single_crystal_validation.c:18914:9: note: Null pointer dereference
        list[i].u2x = b1[0];
        ^
Single_crystal_validation.c:18915:9: warning: If memory allocation fails, then there is a possible null pointer dereference: list [nullPointerOutOfMemory]
        list[i].u2y = b1[1];
        ^
Single_crystal_validation.c:18870:42: note: Assuming allocation function fails
    list = (struct hkl_data_union*)malloc(size*sizeof(struct hkl_data_union));
                                         ^
Single_crystal_validation.c:18870:12: note: Assignment 'list=(struct hkl_data_union*)malloc(size*sizeof(struct hkl_data_union))', assigned value is 0
    list = (struct hkl_data_union*)malloc(size*sizeof(struct hkl_data_union));
           ^
Single_crystal_validation.c:18915:9: note: Null pointer dereference
        list[i].u2y = b1[1];
        ^
Single_crystal_validation.c:18916:9: warning: If memory allocation fails, then there is a possible null pointer dereference: list [nullPointerOutOfMemory]
        list[i].u2z = b1[2];
        ^
Single_crystal_validation.c:18870:42: note: Assuming allocation function fails
    list = (struct hkl_data_union*)malloc(size*sizeof(struct hkl_data_union));
                                         ^
Single_crystal_validation.c:18870:12: note: Assignment 'list=(struct hkl_data_union*)malloc(size*sizeof(struct hkl_data_union))', assigned value is 0
    list = (struct hkl_data_union*)malloc(size*sizeof(struct hkl_data_union));
           ^
Single_crystal_validation.c:18916:9: note: Null pointer dereference
        list[i].u2z = b1[2];
        ^
Single_crystal_validation.c:18917:25: warning: If memory allocation fails, then there is a possible null pointer dereference: list [nullPointerOutOfMemory]
        sig2 = FWHM2RMS*list[i].tau*MIN2RAD*SC_mosaic;
                        ^
Single_crystal_validation.c:18870:42: note: Assuming allocation function fails
    list = (struct hkl_data_union*)malloc(size*sizeof(struct hkl_data_union));
                                         ^
Single_crystal_validation.c:18870:12: note: Assignment 'list=(struct hkl_data_union*)malloc(size*sizeof(struct hkl_data_union))', assigned value is 0
    list = (struct hkl_data_union*)malloc(size*sizeof(struct hkl_data_union));
           ^
Single_crystal_validation.c:18917:25: note: Null pointer dereference
        sig2 = FWHM2RMS*list[i].tau*MIN2RAD*SC_mosaic;
                        ^
Single_crystal_validation.c:18918:9: warning: If memory allocation fails, then there is a possible null pointer dereference: list [nullPointerOutOfMemory]
        list[i].u3x = b2[0];
        ^
Single_crystal_validation.c:18870:42: note: Assuming allocation function fails
    list = (struct hkl_data_union*)malloc(size*sizeof(struct hkl_data_union));
                                         ^
Single_crystal_validation.c:18870:12: note: Assignment 'list=(struct hkl_data_union*)malloc(size*sizeof(struct hkl_data_union))', assigned value is 0
    list = (struct hkl_data_union*)malloc(size*sizeof(struct hkl_data_union));
           ^
Single_crystal_validation.c:18918:9: note: Null pointer dereference
        list[i].u3x = b2[0];
        ^
Single_crystal_validation.c:18919:9: warning: If memory allocation fails, then there is a possible null pointer dereference: list [nullPointerOutOfMemory]
        list[i].u3y = b2[1];
        ^
Single_crystal_validation.c:18870:42: note: Assuming allocation function fails
    list = (struct hkl_data_union*)malloc(size*sizeof(struct hkl_data_union));
                                         ^
Single_crystal_validation.c:18870:12: note: Assignment 'list=(struct hkl_data_union*)malloc(size*sizeof(struct hkl_data_union))', assigned value is 0
    list = (struct hkl_data_union*)malloc(size*sizeof(struct hkl_data_union));
           ^
Single_crystal_validation.c:18919:9: note: Null pointer dereference
        list[i].u3y = b2[1];
        ^
Single_crystal_validation.c:18920:9: warning: If memory allocation fails, then there is a possible null pointer dereference: list [nullPointerOutOfMemory]
        list[i].u3z = b2[2];
        ^
Single_crystal_validation.c:18870:42: note: Assuming allocation function fails
    list = (struct hkl_data_union*)malloc(size*sizeof(struct hkl_data_union));
                                         ^
Single_crystal_validation.c:18870:12: note: Assignment 'list=(struct hkl_data_union*)malloc(size*sizeof(struct hkl_data_union))', assigned value is 0
    list = (struct hkl_data_union*)malloc(size*sizeof(struct hkl_data_union));
           ^
Single_crystal_validation.c:18920:9: note: Null pointer dereference
        list[i].u3z = b2[2];
        ^
Single_crystal_validation.c:18921:25: warning: If memory allocation fails, then there is a possible null pointer dereference: list [nullPointerOutOfMemory]
        sig3 = FWHM2RMS*list[i].tau*MIN2RAD*SC_mosaic;
                        ^
Single_crystal_validation.c:18870:42: note: Assuming allocation function fails
    list = (struct hkl_data_union*)malloc(size*sizeof(struct hkl_data_union));
                                         ^
Single_crystal_validation.c:18870:12: note: Assignment 'list=(struct hkl_data_union*)malloc(size*sizeof(struct hkl_data_union))', assigned value is 0
    list = (struct hkl_data_union*)malloc(size*sizeof(struct hkl_data_union));
           ^
Single_crystal_validation.c:18921:25: note: Null pointer dereference
        sig3 = FWHM2RMS*list[i].tau*MIN2RAD*SC_mosaic;
                        ^
Single_crystal_validation.c:19039:7: warning: If memory allocation fails, then there is a possible null pointer dereference: list [nullPointerOutOfMemory]
      list[i].sig123 = sig1*sig2*sig3;
      ^
Single_crystal_validation.c:18870:42: note: Assuming allocation function fails
    list = (struct hkl_data_union*)malloc(size*sizeof(struct hkl_data_union));
                                         ^
Single_crystal_validation.c:18870:12: note: Assignment 'list=(struct hkl_data_union*)malloc(size*sizeof(struct hkl_data_union))', assigned value is 0
    list = (struct hkl_data_union*)malloc(size*sizeof(struct hkl_data_union));
           ^
Single_crystal_validation.c:19039:7: note: Null pointer dereference
      list[i].sig123 = sig1*sig2*sig3;
      ^
Single_crystal_validation.c:19040:7: warning: If memory allocation fails, then there is a possible null pointer dereference: list [nullPointerOutOfMemory]
      list[i].m1 = 1/(2*sig1*sig1);
      ^
Single_crystal_validation.c:18870:42: note: Assuming allocation function fails
    list = (struct hkl_data_union*)malloc(size*sizeof(struct hkl_data_union));
                                         ^
Single_crystal_validation.c:18870:12: note: Assignment 'list=(struct hkl_data_union*)malloc(size*sizeof(struct hkl_data_union))', assigned value is 0
    list = (struct hkl_data_union*)malloc(size*sizeof(struct hkl_data_union));
           ^
Single_crystal_validation.c:19040:7: note: Null pointer dereference
      list[i].m1 = 1/(2*sig1*sig1);
      ^
Single_crystal_validation.c:19041:7: warning: If memory allocation fails, then there is a possible null pointer dereference: list [nullPointerOutOfMemory]
      list[i].m2 = 1/(2*sig2*sig2);
      ^
Single_crystal_validation.c:18870:42: note: Assuming allocation function fails
    list = (struct hkl_data_union*)malloc(size*sizeof(struct hkl_data_union));
                                         ^
Single_crystal_validation.c:18870:12: note: Assignment 'list=(struct hkl_data_union*)malloc(size*sizeof(struct hkl_data_union))', assigned value is 0
    list = (struct hkl_data_union*)malloc(size*sizeof(struct hkl_data_union));
           ^
Single_crystal_validation.c:19041:7: note: Null pointer dereference
      list[i].m2 = 1/(2*sig2*sig2);
      ^
Single_crystal_validation.c:19042:7: warning: If memory allocation fails, then there is a possible null pointer dereference: list [nullPointerOutOfMemory]
      list[i].m3 = 1/(2*sig3*sig3);
      ^
Single_crystal_validation.c:18870:42: note: Assuming allocation function fails
    list = (struct hkl_data_union*)malloc(size*sizeof(struct hkl_data_union));
                                         ^
Single_crystal_validation.c:18870:12: note: Assignment 'list=(struct hkl_data_union*)malloc(size*sizeof(struct hkl_data_union))', assigned value is 0
    list = (struct hkl_data_union*)malloc(size*sizeof(struct hkl_data_union));
           ^
Single_crystal_validation.c:19042:7: note: Null pointer dereference
      list[i].m3 = 1/(2*sig3*sig3);
      ^
Single_crystal_validation.c:19058:11: warning: If memory allocation fails, then there is a possible null pointer dereference: list [nullPointerOutOfMemory]
    qsort(list, i, sizeof(struct hkl_data_union),  SX_list_compare_union);
          ^
Single_crystal_validation.c:18870:42: note: Assuming allocation function fails
    list = (struct hkl_data_union*)malloc(size*sizeof(struct hkl_data_union));
                                         ^
Single_crystal_validation.c:18870:12: note: Assignment 'list=(struct hkl_data_union*)malloc(size*sizeof(struct hkl_data_union))', assigned value is 0
    list = (struct hkl_data_union*)malloc(size*sizeof(struct hkl_data_union));
           ^
Single_crystal_validation.c:19058:11: note: Null pointer dereference
    qsort(list, i, sizeof(struct hkl_data_union),  SX_list_compare_union);
          ^
Single_crystal_validation.c:20003:9: warning: If memory allocation fails, then there is a possible null pointer dereference: ptr_array [nullPointerOutOfMemory]
        ptr_array[i] = data + (i*count_y);
        ^
Single_crystal_validation.c:20001:32: note: Assuming allocation function fails
    double **ptr_array = malloc(sizeof(double*) * count_x);
                               ^
Single_crystal_validation.c:20001:32: note: Assignment 'ptr_array=malloc(sizeof(double*)*count_x)', assigned value is 0
    double **ptr_array = malloc(sizeof(double*) * count_x);
                               ^
Single_crystal_validation.c:20003:9: note: Null pointer dereference
        ptr_array[i] = data + (i*count_y);
        ^
Single_crystal_validation.c:20955:7: warning: If memory allocation fails, then there is a possible null pointer dereference: list [nullPointerOutOfMemory]
      list[i].h = h;
      ^
Single_crystal_validation.c:20938:37: note: Assuming allocation function fails
    list = (struct hkl_data*) malloc(size*sizeof(struct hkl_data));
                                    ^
Single_crystal_validation.c:20938:12: note: Assignment 'list=(struct hkl_data*)malloc(size*sizeof(struct hkl_data))', assigned value is 0
    list = (struct hkl_data*) malloc(size*sizeof(struct hkl_data));
           ^
Single_crystal_validation.c:20955:7: note: Null pointer dereference
      list[i].h = h;
      ^
Single_crystal_validation.c:20956:7: warning: If memory allocation fails, then there is a possible null pointer dereference: list [nullPointerOutOfMemory]
      list[i].k = k;
      ^
Single_crystal_validation.c:20938:37: note: Assuming allocation function fails
    list = (struct hkl_data*) malloc(size*sizeof(struct hkl_data));
                                    ^
Single_crystal_validation.c:20938:12: note: Assignment 'list=(struct hkl_data*)malloc(size*sizeof(struct hkl_data))', assigned value is 0
    list = (struct hkl_data*) malloc(size*sizeof(struct hkl_data));
           ^
Single_crystal_validation.c:20956:7: note: Null pointer dereference
      list[i].k = k;
      ^
Single_crystal_validation.c:20957:7: warning: If memory allocation fails, then there is a possible null pointer dereference: list [nullPointerOutOfMemory]
      list[i].l = l;
      ^
Single_crystal_validation.c:20938:37: note: Assuming allocation function fails
    list = (struct hkl_data*) malloc(size*sizeof(struct hkl_data));
                                    ^
Single_crystal_validation.c:20938:12: note: Assignment 'list=(struct hkl_data*)malloc(size*sizeof(struct hkl_data))', assigned value is 0
    list = (struct hkl_data*) malloc(size*sizeof(struct hkl_data));
           ^
Single_crystal_validation.c:20957:7: note: Null pointer dereference
      list[i].l = l;
      ^
Single_crystal_validation.c:20958:7: warning: If memory allocation fails, then there is a possible null pointer dereference: list [nullPointerOutOfMemory]
      list[i].F2 = F2;
      ^
Single_crystal_validation.c:20938:37: note: Assuming allocation function fails
    list = (struct hkl_data*) malloc(size*sizeof(struct hkl_data));
                                    ^
Single_crystal_validation.c:20938:12: note: Assignment 'list=(struct hkl_data*)malloc(size*sizeof(struct hkl_data))', assigned value is 0
    list = (struct hkl_data*) malloc(size*sizeof(struct hkl_data));
           ^
Single_crystal_validation.c:20958:7: note: Null pointer dereference
      list[i].F2 = F2;
      ^
Single_crystal_validation.c:20961:7: warning: If memory allocation fails, then there is a possible null pointer dereference: list [nullPointerOutOfMemory]
      list[i].tau_x = h*info->asx + k*info->bsx + l*info->csx;
      ^
Single_crystal_validation.c:20938:37: note: Assuming allocation function fails
    list = (struct hkl_data*) malloc(size*sizeof(struct hkl_data));
                                    ^
Single_crystal_validation.c:20938:12: note: Assignment 'list=(struct hkl_data*)malloc(size*sizeof(struct hkl_data))', assigned value is 0
    list = (struct hkl_data*) malloc(size*sizeof(struct hkl_data));
           ^
Single_crystal_validation.c:20961:7: note: Null pointer dereference
      list[i].tau_x = h*info->asx + k*info->bsx + l*info->csx;
      ^
Single_crystal_validation.c:20962:7: warning: If memory allocation fails, then there is a possible null pointer dereference: list [nullPointerOutOfMemory]
      list[i].tau_y = h*info->asy + k*info->bsy + l*info->csy;
      ^
Single_crystal_validation.c:20938:37: note: Assuming allocation function fails
    list = (struct hkl_data*) malloc(size*sizeof(struct hkl_data));
                                    ^
Single_crystal_validation.c:20938:12: note: Assignment 'list=(struct hkl_data*)malloc(size*sizeof(struct hkl_data))', assigned value is 0
    list = (struct hkl_data*) malloc(size*sizeof(struct hkl_data));
           ^
Single_crystal_validation.c:20962:7: note: Null pointer dereference
      list[i].tau_y = h*info->asy + k*info->bsy + l*info->csy;
      ^
Single_crystal_validation.c:20963:7: warning: If memory allocation fails, then there is a possible null pointer dereference: list [nullPointerOutOfMemory]
      list[i].tau_z = h*info->asz + k*info->bsz + l*info->csz;
      ^
Single_crystal_validation.c:20938:37: note: Assuming allocation function fails
    list = (struct hkl_data*) malloc(size*sizeof(struct hkl_data));
                                    ^
Single_crystal_validation.c:20938:12: note: Assignment 'list=(struct hkl_data*)malloc(size*sizeof(struct hkl_data))', assigned value is 0
    list = (struct hkl_data*) malloc(size*sizeof(struct hkl_data));
           ^
Single_crystal_validation.c:20963:7: note: Null pointer dereference
      list[i].tau_z = h*info->asz + k*info->bsz + l*info->csz;
      ^
Single_crystal_validation.c:20964:7: warning: If memory allocation fails, then there is a possible null pointer dereference: list [nullPointerOutOfMemory]
      list[i].tau = sqrt(list[i].tau_x*list[i].tau_x +
      ^
Single_crystal_validation.c:20938:37: note: Assuming allocation function fails
    list = (struct hkl_data*) malloc(size*sizeof(struct hkl_data));
                                    ^
Single_crystal_validation.c:20938:12: note: Assignment 'list=(struct hkl_data*)malloc(size*sizeof(struct hkl_data))', assigned value is 0
    list = (struct hkl_data*) malloc(size*sizeof(struct hkl_data));
           ^
Single_crystal_validation.c:20964:7: note: Null pointer dereference
      list[i].tau = sqrt(list[i].tau_x*list[i].tau_x +
      ^
Single_crystal_validation.c:20964:26: warning: If memory allocation fails, then there is a possible null pointer dereference: list [nullPointerOutOfMemory]
      list[i].tau = sqrt(list[i].tau_x*list[i].tau_x +
                         ^
Single_crystal_validation.c:20938:37: note: Assuming allocation function fails
    list = (struct hkl_data*) malloc(size*sizeof(struct hkl_data));
                                    ^
Single_crystal_validation.c:20938:12: note: Assignment 'list=(struct hkl_data*)malloc(size*sizeof(struct hkl_data))', assigned value is 0
    list = (struct hkl_data*) malloc(size*sizeof(struct hkl_data));
           ^
Single_crystal_validation.c:20964:26: note: Null pointer dereference
      list[i].tau = sqrt(list[i].tau_x*list[i].tau_x +
                         ^
Single_crystal_validation.c:20964:40: warning: If memory allocation fails, then there is a possible null pointer dereference: list [nullPointerOutOfMemory]
      list[i].tau = sqrt(list[i].tau_x*list[i].tau_x +
                                       ^
Single_crystal_validation.c:20938:37: note: Assuming allocation function fails
    list = (struct hkl_data*) malloc(size*sizeof(struct hkl_data));
                                    ^
Single_crystal_validation.c:20938:12: note: Assignment 'list=(struct hkl_data*)malloc(size*sizeof(struct hkl_data))', assigned value is 0
    list = (struct hkl_data*) malloc(size*sizeof(struct hkl_data));
           ^
Single_crystal_validation.c:20964:40: note: Null pointer dereference
      list[i].tau = sqrt(list[i].tau_x*list[i].tau_x +
                                       ^
Single_crystal_validation.c:20965:26: warning: If memory allocation fails, then there is a possible null pointer dereference: list [nullPointerOutOfMemory]
                         list[i].tau_y*list[i].tau_y +
                         ^
Single_crystal_validation.c:20938:37: note: Assuming allocation function fails
    list = (struct hkl_data*) malloc(size*sizeof(struct hkl_data));
                                    ^
Single_crystal_validation.c:20938:12: note: Assignment 'list=(struct hkl_data*)malloc(size*sizeof(struct hkl_data))', assigned value is 0
    list = (struct hkl_data*) malloc(size*sizeof(struct hkl_data));
           ^
Single_crystal_validation.c:20965:26: note: Null pointer dereference
                         list[i].tau_y*list[i].tau_y +
                         ^
Single_crystal_validation.c:20965:40: warning: If memory allocation fails, then there is a possible null pointer dereference: list [nullPointerOutOfMemory]
                         list[i].tau_y*list[i].tau_y +
                                       ^
Single_crystal_validation.c:20938:37: note: Assuming allocation function fails
    list = (struct hkl_data*) malloc(size*sizeof(struct hkl_data));
                                    ^
Single_crystal_validation.c:20938:12: note: Assignment 'list=(struct hkl_data*)malloc(size*sizeof(struct hkl_data))', assigned value is 0
    list = (struct hkl_data*) malloc(size*sizeof(struct hkl_data));
           ^
Single_crystal_validation.c:20965:40: note: Null pointer dereference
                         list[i].tau_y*list[i].tau_y +
                                       ^
Single_crystal_validation.c:20966:26: warning: If memory allocation fails, then there is a possible null pointer dereference: list [nullPointerOutOfMemory]
                         list[i].tau_z*list[i].tau_z);
                         ^
Single_crystal_validation.c:20938:37: note: Assuming allocation function fails
    list = (struct hkl_data*) malloc(size*sizeof(struct hkl_data));
                                    ^
Single_crystal_validation.c:20938:12: note: Assignment 'list=(struct hkl_data*)malloc(size*sizeof(struct hkl_data))', assigned value is 0
    list = (struct hkl_data*) malloc(size*sizeof(struct hkl_data));
           ^
Single_crystal_validation.c:20966:26: note: Null pointer dereference
                         list[i].tau_z*list[i].tau_z);
                         ^
Single_crystal_validation.c:20966:40: warning: If memory allocation fails, then there is a possible null pointer dereference: list [nullPointerOutOfMemory]
                         list[i].tau_z*list[i].tau_z);
                                       ^
Single_crystal_validation.c:20938:37: note: Assuming allocation function fails
    list = (struct hkl_data*) malloc(size*sizeof(struct hkl_data));
                                    ^
Single_crystal_validation.c:20938:12: note: Assignment 'list=(struct hkl_data*)malloc(size*sizeof(struct hkl_data))', assigned value is 0
    list = (struct hkl_data*) malloc(size*sizeof(struct hkl_data));
           ^
Single_crystal_validation.c:20966:40: note: Null pointer dereference
                         list[i].tau_z*list[i].tau_z);
                                       ^
Single_crystal_validation.c:20967:7: warning: If memory allocation fails, then there is a possible null pointer dereference: list [nullPointerOutOfMemory]
      list[i].u1x = list[i].tau_x/list[i].tau;
      ^
Single_crystal_validation.c:20938:37: note: Assuming allocation function fails
    list = (struct hkl_data*) malloc(size*sizeof(struct hkl_data));
                                    ^
Single_crystal_validation.c:20938:12: note: Assignment 'list=(struct hkl_data*)malloc(size*sizeof(struct hkl_data))', assigned value is 0
    list = (struct hkl_data*) malloc(size*sizeof(struct hkl_data));
           ^
Single_crystal_validation.c:20967:7: note: Null pointer dereference
      list[i].u1x = list[i].tau_x/list[i].tau;
      ^
Single_crystal_validation.c:20967:21: warning: If memory allocation fails, then there is a possible null pointer dereference: list [nullPointerOutOfMemory]
      list[i].u1x = list[i].tau_x/list[i].tau;
                    ^
Single_crystal_validation.c:20938:37: note: Assuming allocation function fails
    list = (struct hkl_data*) malloc(size*sizeof(struct hkl_data));
                                    ^
Single_crystal_validation.c:20938:12: note: Assignment 'list=(struct hkl_data*)malloc(size*sizeof(struct hkl_data))', assigned value is 0
    list = (struct hkl_data*) malloc(size*sizeof(struct hkl_data));
           ^
Single_crystal_validation.c:20967:21: note: Null pointer dereference
      list[i].u1x = list[i].tau_x/list[i].tau;
                    ^
Single_crystal_validation.c:20967:35: warning: If memory allocation fails, then there is a possible null pointer dereference: list [nullPointerOutOfMemory]
      list[i].u1x = list[i].tau_x/list[i].tau;
                                  ^
Single_crystal_validation.c:20938:37: note: Assuming allocation function fails
    list = (struct hkl_data*) malloc(size*sizeof(struct hkl_data));
                                    ^
Single_crystal_validation.c:20938:12: note: Assignment 'list=(struct hkl_data*)malloc(size*sizeof(struct hkl_data))', assigned value is 0
    list = (struct hkl_data*) malloc(size*sizeof(struct hkl_data));
           ^
Single_crystal_validation.c:20967:35: note: Null pointer dereference
      list[i].u1x = list[i].tau_x/list[i].tau;
                                  ^
Single_crystal_validation.c:20968:7: warning: If memory allocation fails, then there is a possible null pointer dereference: list [nullPointerOutOfMemory]
      list[i].u1y = list[i].tau_y/list[i].tau;
      ^
Single_crystal_validation.c:20938:37: note: Assuming allocation function fails
    list = (struct hkl_data*) malloc(size*sizeof(struct hkl_data));
                                    ^
Single_crystal_validation.c:20938:12: note: Assignment 'list=(struct hkl_data*)malloc(size*sizeof(struct hkl_data))', assigned value is 0
    list = (struct hkl_data*) malloc(size*sizeof(struct hkl_data));
           ^
Single_crystal_validation.c:20968:7: note: Null pointer dereference
      list[i].u1y = list[i].tau_y/list[i].tau;
      ^
Single_crystal_validation.c:20968:21: warning: If memory allocation fails, then there is a possible null pointer dereference: list [nullPointerOutOfMemory]
      list[i].u1y = list[i].tau_y/list[i].tau;
                    ^
Single_crystal_validation.c:20938:37: note: Assuming allocation function fails
    list = (struct hkl_data*) malloc(size*sizeof(struct hkl_data));
                                    ^
Single_crystal_validation.c:20938:12: note: Assignment 'list=(struct hkl_data*)malloc(size*sizeof(struct hkl_data))', assigned value is 0
    list = (struct hkl_data*) malloc(size*sizeof(struct hkl_data));
           ^
Single_crystal_validation.c:20968:21: note: Null pointer dereference
      list[i].u1y = list[i].tau_y/list[i].tau;
                    ^
Single_crystal_validation.c:20968:35: warning: If memory allocation fails, then there is a possible null pointer dereference: list [nullPointerOutOfMemory]
      list[i].u1y = list[i].tau_y/list[i].tau;
                                  ^
Single_crystal_validation.c:20938:37: note: Assuming allocation function fails
    list = (struct hkl_data*) malloc(size*sizeof(struct hkl_data));
                                    ^
Single_crystal_validation.c:20938:12: note: Assignment 'list=(struct hkl_data*)malloc(size*sizeof(struct hkl_data))', assigned value is 0
    list = (struct hkl_data*) malloc(size*sizeof(struct hkl_data));
           ^
Single_crystal_validation.c:20968:35: note: Null pointer dereference
      list[i].u1y = list[i].tau_y/list[i].tau;
                                  ^
Single_crystal_validation.c:20969:7: warning: If memory allocation fails, then there is a possible null pointer dereference: list [nullPointerOutOfMemory]
      list[i].u1z = list[i].tau_z/list[i].tau;
      ^
Single_crystal_validation.c:20938:37: note: Assuming allocation function fails
    list = (struct hkl_data*) malloc(size*sizeof(struct hkl_data));
                                    ^
Single_crystal_validation.c:20938:12: note: Assignment 'list=(struct hkl_data*)malloc(size*sizeof(struct hkl_data))', assigned value is 0
    list = (struct hkl_data*) malloc(size*sizeof(struct hkl_data));
           ^
Single_crystal_validation.c:20969:7: note: Null pointer dereference
      list[i].u1z = list[i].tau_z/list[i].tau;
      ^
Single_crystal_validation.c:20969:21: warning: If memory allocation fails, then there is a possible null pointer dereference: list [nullPointerOutOfMemory]
      list[i].u1z = list[i].tau_z/list[i].tau;
                    ^
Single_crystal_validation.c:20938:37: note: Assuming allocation function fails
    list = (struct hkl_data*) malloc(size*sizeof(struct hkl_data));
                                    ^
Single_crystal_validation.c:20938:12: note: Assignment 'list=(struct hkl_data*)malloc(size*sizeof(struct hkl_data))', assigned value is 0
    list = (struct hkl_data*) malloc(size*sizeof(struct hkl_data));
           ^
Single_crystal_validation.c:20969:21: note: Null pointer dereference
      list[i].u1z = list[i].tau_z/list[i].tau;
                    ^
Single_crystal_validation.c:20969:35: warning: If memory allocation fails, then there is a possible null pointer dereference: list [nullPointerOutOfMemory]
      list[i].u1z = list[i].tau_z/list[i].tau;
                                  ^
Single_crystal_validation.c:20938:37: note: Assuming allocation function fails
    list = (struct hkl_data*) malloc(size*sizeof(struct hkl_data));
                                    ^
Single_crystal_validation.c:20938:12: note: Assignment 'list=(struct hkl_data*)malloc(size*sizeof(struct hkl_data))', assigned value is 0
    list = (struct hkl_data*) malloc(size*sizeof(struct hkl_data));
           ^
Single_crystal_validation.c:20969:35: note: Null pointer dereference
      list[i].u1z = list[i].tau_z/list[i].tau;
                                  ^
Single_crystal_validation.c:20970:41: warning: If memory allocation fails, then there is a possible null pointer dereference: list [nullPointerOutOfMemory]
      sig1 = FWHM2RMS*info->m_delta_d_d*list[i].tau;
                                        ^
Single_crystal_validation.c:20938:37: note: Assuming allocation function fails
    list = (struct hkl_data*) malloc(size*sizeof(struct hkl_data));
                                    ^
Single_crystal_validation.c:20938:12: note: Assignment 'list=(struct hkl_data*)malloc(size*sizeof(struct hkl_data))', assigned value is 0
    list = (struct hkl_data*) malloc(size*sizeof(struct hkl_data));
           ^
Single_crystal_validation.c:20970:41: note: Null pointer dereference
      sig1 = FWHM2RMS*info->m_delta_d_d*list[i].tau;
                                        ^
Single_crystal_validation.c:20974:18: warning: If memory allocation fails, then there is a possible null pointer dereference: list [nullPointerOutOfMemory]
                 list[i].u1x, list[i].u1y, list[i].u1z);
                 ^
Single_crystal_validation.c:20938:37: note: Assuming allocation function fails
    list = (struct hkl_data*) malloc(size*sizeof(struct hkl_data));
                                    ^
Single_crystal_validation.c:20938:12: note: Assignment 'list=(struct hkl_data*)malloc(size*sizeof(struct hkl_data))', assigned value is 0
    list = (struct hkl_data*) malloc(size*sizeof(struct hkl_data));
           ^
Single_crystal_validation.c:20974:18: note: Null pointer dereference
                 list[i].u1x, list[i].u1y, list[i].u1z);
                 ^
Single_crystal_validation.c:20974:31: warning: If memory allocation fails, then there is a possible null pointer dereference: list [nullPointerOutOfMemory]
                 list[i].u1x, list[i].u1y, list[i].u1z);
                              ^
Single_crystal_validation.c:20938:37: note: Assuming allocation function fails
    list = (struct hkl_data*) malloc(size*sizeof(struct hkl_data));
                                    ^
Single_crystal_validation.c:20938:12: note: Assignment 'list=(struct hkl_data*)malloc(size*sizeof(struct hkl_data))', assigned value is 0
    list = (struct hkl_data*) malloc(size*sizeof(struct hkl_data));
           ^
Single_crystal_validation.c:20974:31: note: Null pointer dereference
                 list[i].u1x, list[i].u1y, list[i].u1z);
                              ^
Single_crystal_validation.c:20974:44: warning: If memory allocation fails, then there is a possible null pointer dereference: list [nullPointerOutOfMemory]
                 list[i].u1x, list[i].u1y, list[i].u1z);
                                           ^
Single_crystal_validation.c:20938:37: note: Assuming allocation function fails
    list = (struct hkl_data*) malloc(size*sizeof(struct hkl_data));
                                    ^
Single_crystal_validation.c:20938:12: note: Assignment 'list=(struct hkl_data*)malloc(size*sizeof(struct hkl_data))', assigned value is 0
    list = (struct hkl_data*) malloc(size*sizeof(struct hkl_data));
           ^
Single_crystal_validation.c:20974:44: note: Null pointer dereference
                 list[i].u1x, list[i].u1y, list[i].u1z);
                                           ^
Single_crystal_validation.c:20975:7: warning: If memory allocation fails, then there is a possible null pointer dereference: list [nullPointerOutOfMemory]
      vec_prod(b2[0], b2[1], b2[2],
      ^
Single_crystal_validation.c:20938:37: note: Assuming allocation function fails
    list = (struct hkl_data*) malloc(size*sizeof(struct hkl_data));
                                    ^
Single_crystal_validation.c:20938:12: note: Assignment 'list=(struct hkl_data*)malloc(size*sizeof(struct hkl_data))', assigned value is 0
    list = (struct hkl_data*) malloc(size*sizeof(struct hkl_data));
           ^
Single_crystal_validation.c:20975:7: note: Null pointer dereference
      vec_prod(b2[0], b2[1], b2[2],
      ^
Single_crystal_validation.c:20982:9: warning: If memory allocation fails, then there is a possible null pointer dereference: list [nullPointerOutOfMemory]
        list[i].u2x = b1[0];
        ^
Single_crystal_validation.c:20938:37: note: Assuming allocation function fails
    list = (struct hkl_data*) malloc(size*sizeof(struct hkl_data));
                                    ^
Single_crystal_validation.c:20938:12: note: Assignment 'list=(struct hkl_data*)malloc(size*sizeof(struct hkl_data))', assigned value is 0
    list = (struct hkl_data*) malloc(size*sizeof(struct hkl_data));
           ^
Single_crystal_validation.c:20982:9: note: Null pointer dereference
        list[i].u2x = b1[0];
        ^
Single_crystal_validation.c:20983:9: warning: If memory allocation fails, then there is a possible null pointer dereference: list [nullPointerOutOfMemory]
        list[i].u2y = b1[1];
        ^
Single_crystal_validation.c:20938:37: note: Assuming allocation function fails
    list = (struct hkl_data*) malloc(size*sizeof(struct hkl_data));
                                    ^
Single_crystal_validation.c:20938:12: note: Assignment 'list=(struct hkl_data*)malloc(size*sizeof(struct hkl_data))', assigned value is 0
    list = (struct hkl_data*) malloc(size*sizeof(struct hkl_data));
           ^
Single_crystal_validation.c:20983:9: note: Null pointer dereference
        list[i].u2y = b1[1];
        ^
Single_crystal_validation.c:20984:9: warning: If memory allocation fails, then there is a possible null pointer dereference: list [nullPointerOutOfMemory]
        list[i].u2z = b1[2];
        ^
Single_crystal_validation.c:20938:37: note: Assuming allocation function fails
    list = (struct hkl_data*) malloc(size*sizeof(struct hkl_data));
                                    ^
Single_crystal_validation.c:20938:12: note: Assignment 'list=(struct hkl_data*)malloc(size*sizeof(struct hkl_data))', assigned value is 0
    list = (struct hkl_data*) malloc(size*sizeof(struct hkl_data));
           ^
Single_crystal_validation.c:20984:9: note: Null pointer dereference
        list[i].u2z = b1[2];
        ^
Single_crystal_validation.c:20985:25: warning: If memory allocation fails, then there is a possible null pointer dereference: list [nullPointerOutOfMemory]
        sig2 = FWHM2RMS*list[i].tau*MIN2RAD*SC_mosaic;
                        ^
Single_crystal_validation.c:20938:37: note: Assuming allocation function fails
    list = (struct hkl_data*) malloc(size*sizeof(struct hkl_data));
                                    ^
Single_crystal_validation.c:20938:12: note: Assignment 'list=(struct hkl_data*)malloc(size*sizeof(struct hkl_data))', assigned value is 0
    list = (struct hkl_data*) malloc(size*sizeof(struct hkl_data));
           ^
Single_crystal_validation.c:20985:25: note: Null pointer dereference
        sig2 = FWHM2RMS*list[i].tau*MIN2RAD*SC_mosaic;
                        ^
Single_crystal_validation.c:20986:9: warning: If memory allocation fails, then there is a possible null pointer dereference: list [nullPointerOutOfMemory]
        list[i].u3x = b2[0];
        ^
Single_crystal_validation.c:20938:37: note: Assuming allocation function fails
    list = (struct hkl_data*) malloc(size*sizeof(struct hkl_data));
                                    ^
Single_crystal_validation.c:20938:12: note: Assignment 'list=(struct hkl_data*)malloc(size*sizeof(struct hkl_data))', assigned value is 0
    list = (struct hkl_data*) malloc(size*sizeof(struct hkl_data));
           ^
Single_crystal_validation.c:20986:9: note: Null pointer dereference
        list[i].u3x = b2[0];
        ^
Single_crystal_validation.c:20987:9: warning: If memory allocation fails, then there is a possible null pointer dereference: list [nullPointerOutOfMemory]
        list[i].u3y = b2[1];
        ^
Single_crystal_validation.c:20938:37: note: Assuming allocation function fails
    list = (struct hkl_data*) malloc(size*sizeof(struct hkl_data));
                                    ^
Single_crystal_validation.c:20938:12: note: Assignment 'list=(struct hkl_data*)malloc(size*sizeof(struct hkl_data))', assigned value is 0
    list = (struct hkl_data*) malloc(size*sizeof(struct hkl_data));
           ^
Single_crystal_validation.c:20987:9: note: Null pointer dereference
        list[i].u3y = b2[1];
        ^
Single_crystal_validation.c:20988:9: warning: If memory allocation fails, then there is a possible null pointer dereference: list [nullPointerOutOfMemory]
        list[i].u3z = b2[2];
        ^
Single_crystal_validation.c:20938:37: note: Assuming allocation function fails
    list = (struct hkl_data*) malloc(size*sizeof(struct hkl_data));
                                    ^
Single_crystal_validation.c:20938:12: note: Assignment 'list=(struct hkl_data*)malloc(size*sizeof(struct hkl_data))', assigned value is 0
    list = (struct hkl_data*) malloc(size*sizeof(struct hkl_data));
           ^
Single_crystal_validation.c:20988:9: note: Null pointer dereference
        list[i].u3z = b2[2];
        ^
Single_crystal_validation.c:20989:25: warning: If memory allocation fails, then there is a possible null pointer dereference: list [nullPointerOutOfMemory]
        sig3 = FWHM2RMS*list[i].tau*MIN2RAD*SC_mosaic;
                        ^
Single_crystal_validation.c:20938:37: note: Assuming allocation function fails
    list = (struct hkl_data*) malloc(size*sizeof(struct hkl_data));
                                    ^
Single_crystal_validation.c:20938:12: note: Assignment 'list=(struct hkl_data*)malloc(size*sizeof(struct hkl_data))', assigned value is 0
    list = (struct hkl_data*) malloc(size*sizeof(struct hkl_data));
           ^
Single_crystal_validation.c:20989:25: note: Null pointer dereference
        sig3 = FWHM2RMS*list[i].tau*MIN2RAD*SC_mosaic;
                        ^
Single_crystal_validation.c:21107:7: warning: If memory allocation fails, then there is a possible null pointer dereference: list [nullPointerOutOfMemory]
      list[i].sig123 = sig1*sig2*sig3;
      ^
Single_crystal_validation.c:20938:37: note: Assuming allocation function fails
    list = (struct hkl_data*) malloc(size*sizeof(struct hkl_data));
                                    ^
Single_crystal_validation.c:20938:12: note: Assignment 'list=(struct hkl_data*)malloc(size*sizeof(struct hkl_data))', assigned value is 0
    list = (struct hkl_data*) malloc(size*sizeof(struct hkl_data));
           ^
Single_crystal_validation.c:21107:7: note: Null pointer dereference
      list[i].sig123 = sig1*sig2*sig3;
      ^
Single_crystal_validation.c:21108:7: warning: If memory allocation fails, then there is a possible null pointer dereference: list [nullPointerOutOfMemory]
      list[i].m1 = 1/(2*sig1*sig1);
      ^
Single_crystal_validation.c:20938:37: note: Assuming allocation function fails
    list = (struct hkl_data*) malloc(size*sizeof(struct hkl_data));
                                    ^
Single_crystal_validation.c:20938:12: note: Assignment 'list=(struct hkl_data*)malloc(size*sizeof(struct hkl_data))', assigned value is 0
    list = (struct hkl_data*) malloc(size*sizeof(struct hkl_data));
           ^
Single_crystal_validation.c:21108:7: note: Null pointer dereference
      list[i].m1 = 1/(2*sig1*sig1);
      ^
Single_crystal_validation.c:21109:7: warning: If memory allocation fails, then there is a possible null pointer dereference: list [nullPointerOutOfMemory]
      list[i].m2 = 1/(2*sig2*sig2);
      ^
Single_crystal_validation.c:20938:37: note: Assuming allocation function fails
    list = (struct hkl_data*) malloc(size*sizeof(struct hkl_data));
                                    ^
Single_crystal_validation.c:20938:12: note: Assignment 'list=(struct hkl_data*)malloc(size*sizeof(struct hkl_data))', assigned value is 0
    list = (struct hkl_data*) malloc(size*sizeof(struct hkl_data));
           ^
Single_crystal_validation.c:21109:7: note: Null pointer dereference
      list[i].m2 = 1/(2*sig2*sig2);
      ^
Single_crystal_validation.c:21110:7: warning: If memory allocation fails, then there is a possible null pointer dereference: list [nullPointerOutOfMemory]
      list[i].m3 = 1/(2*sig3*sig3);
      ^
Single_crystal_validation.c:20938:37: note: Assuming allocation function fails
    list = (struct hkl_data*) malloc(size*sizeof(struct hkl_data));
                                    ^
Single_crystal_validation.c:20938:12: note: Assignment 'list=(struct hkl_data*)malloc(size*sizeof(struct hkl_data))', assigned value is 0
    list = (struct hkl_data*) malloc(size*sizeof(struct hkl_data));
           ^
Single_crystal_validation.c:21110:7: note: Null pointer dereference
      list[i].m3 = 1/(2*sig3*sig3);
      ^
Single_crystal_validation.c:21126:11: warning: If memory allocation fails, then there is a possible null pointer dereference: list [nullPointerOutOfMemory]
    qsort(list, i, sizeof(struct hkl_data),  SX_list_compare);
          ^
Single_crystal_validation.c:20938:37: note: Assuming allocation function fails
    list = (struct hkl_data*) malloc(size*sizeof(struct hkl_data));
                                    ^
Single_crystal_validation.c:20938:12: note: Assignment 'list=(struct hkl_data*)malloc(size*sizeof(struct hkl_data))', assigned value is 0
    list = (struct hkl_data*) malloc(size*sizeof(struct hkl_data));
           ^
Single_crystal_validation.c:21126:11: note: Null pointer dereference
    qsort(list, i, sizeof(struct hkl_data),  SX_list_compare);
          ^
Single_crystal_validation.c:20003:29: error: If memory allocation fails: pointer addition with NULL pointer. [nullPointerArithmeticOutOfMemory]
        ptr_array[i] = data + (i*count_y);
                            ^
Single_crystal_validation.c:19998:26: note: Assuming allocation function fails
    double *data = malloc(sizeof(double) * count_x * count_y);
                         ^
Single_crystal_validation.c:19998:26: note: Assignment 'data=malloc(sizeof(double)*count_x*count_y)', assigned value is 0
    double *data = malloc(sizeof(double) * count_x * count_y);
                         ^
Single_crystal_validation.c:20003:29: note: Null pointer addition
        ptr_array[i] = data + (i*count_y);
                            ^
Single_crystal_validation.c:9043:12: warning: Uninitialized variable: draw_order.lines [uninitvar]
    return draw_order;
           ^
Single_crystal_validation.c:9027:36: note: Assuming condition is false
    if (draw_order.number_of_lines > 0) {
                                   ^
Single_crystal_validation.c:9043:12: note: Uninitialized variable: draw_order.lines
    return draw_order;
           ^
Single_crystal_validation.c:12502:66: error: Uninitialized variable: square_center [uninitvar]
    Coords box_end_point = coords_sub(coords_set(0,0,-z_depth/2),square_center);
                                                                 ^
Single_crystal_validation.c:13375:25: error: Uninitialized variable: temp_pointer [uninitvar]
                ListA = temp_pointer;
                        ^
Single_crystal_validation.c:14726:79: warning: Uninitialized variable: logic_list.elements [uninitvar]
    Volumes[N_volume]->geometry.destinations_list.num_elements = sum_int_list(logic_list);
                                                                              ^
Single_crystal_validation.c:14709:32: note: Assuming condition is false
    if (logic_list.num_elements>0) logic_list.elements = malloc(logic_list.num_elements*sizeof(int));
                               ^
Single_crystal_validation.c:14726:79: note: Uninitialized variable: logic_list.elements
    Volumes[N_volume]->geometry.destinations_list.num_elements = sum_int_list(logic_list);
                                                                              ^
Single_crystal_validation.c:19372:52: error: Uninitialized variable: r [uninitvar]
          "(r=%g, sum=%g, j=%i, tau_count=%i).\n", r, sum, j , hkl_info->tau_count);
                                                   ^
Single_crystal_validation.c:12502:66: error: Uninitialized struct member: square_center.x [uninitStructMember]
    Coords box_end_point = coords_sub(coords_set(0,0,-z_depth/2),square_center);
                                                                 ^
Single_crystal_validation.c:12502:66: error: Uninitialized struct member: square_center.y [uninitStructMember]
    Coords box_end_point = coords_sub(coords_set(0,0,-z_depth/2),square_center);
                                                                 ^
Single_crystal_validation.c:12502:66: error: Uninitialized struct member: square_center.z [uninitStructMember]
    Coords box_end_point = coords_sub(coords_set(0,0,-z_depth/2),square_center);
                                                                 ^
Single_crystal_validation.c:19012:14: error: Uninitialized variable: c1 [legacyUninitvar]
        if ((c1==0) && (c2==0)){
             ^
Single_crystal_validation.c:19018:74: error: Uninitialized variable: c2 [legacyUninitvar]
        sig_tau_c = MIN2RAD*sqrt(c1*SC_mosaic_AB[0]*c1*SC_mosaic_AB[0] + c2*SC_mosaic_AB[1]*c2*SC_mosaic_AB[1]);
                                                                         ^
Single_crystal_validation.c:21080:14: error: Uninitialized variable: c1 [legacyUninitvar]
        if ((c1==0) && (c2==0)){
             ^
Single_crystal_validation.c:21086:74: error: Uninitialized variable: c2 [legacyUninitvar]
        sig_tau_c = MIN2RAD*sqrt(c1*SC_mosaic_AB[0]*c1*SC_mosaic_AB[0] + c2*SC_mosaic_AB[1]*c2*SC_mosaic_AB[1]);
                                                                         ^
Checking Single_crystal_validation.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 Single_crystal_validation.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 Single_crystal_validation.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 Single_crystal_validation.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 Single_crystal_validation.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 Single_crystal_validation.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 Single_crystal_validation.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 Single_crystal_validation.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 Single_crystal_validation.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_TEXTURE_DETECTOR...
Checking Single_crystal_validation.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 Single_crystal_validation.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...
Single_crystal_validation.c:27011:48: error: Uninitialized variable: temp_string [legacyUninitvar]
  strcat(this_storage.Detector_2D.title_string,temp_string); // Connects the title string started in Q_direction_1 part with the ending in Q_direction_2 part
                                               ^
Checking Single_crystal_validation.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 Single_crystal_validation.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 Single_crystal_validation.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...
Single_crystal_validation.c:29576: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 Single_crystal_validation.c: MCDEFAULT_NCOUNT=1000000;ND_BUFFER=10000000;SIGABRT=1;SIGBREAK=1;SIGBUS=1;SIGPE=1;SIGHUP=1;SIGILL=1;SIGINT=1;SIGKILL=1;SIGUSR1=1;SIGUSR2=1;SIGPIPE=1;SIGQUIT=1;SIGSEGV=1;SIGTRAP=1;SIGURG=1;SIGFPE=1;SIGKILL=1;SIGTERM=1;__unix__=1;_WIN64...
Checking Single_crystal_validation.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 Single_crystal_validation.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 Single_crystal_validation.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 Single_crystal_validation.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 Single_crystal_validation.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 Single_crystal_validation.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 ./Single_crystal_validation.c