Comparing precision of original (left) with increment (right):
Global (alloc@sid:703) on :-1:-1 is more precise using right:
Reversed (top or Set (Normal Lvals)): {} not leq All mutexes. compound: (Array: ((Unknown int([-7,7])), (1), false), (1)) not same type as Uninitialized. 
Global (alloc@sid:802) on :-1:-1 is more precise using right:
Reversed (top or Set (Normal Lvals)): {} not leq All mutexes. compound: (Array: ((Unknown int([-7,7])), (1), false), (1)) not same type as Uninitialized. 
Global (alloc@sid:829) on :-1:-1 is more precise using right:
Reversed (top or Set (Normal Lvals)): {} not leq All mutexes. compound: (Array: ((Unknown int([-7,7])), (1), false), (1)) not same type as Uninitialized. 
globals:	equal = 42	left = 0	right = 3	incomparable = 0
Statement exit(0); @ aget_comb.c:1043:3 is more precise using right:
([Reversed (top or Set (Normal Lvals * booleans)):{}, top or Set (variables):{},
  booleans:False, MT mode:Multithreaded (other),
  Thread * created:(([signal_waiter@aget_comb.c:205:3, main], {}), {}),
  value domain * array partitioning deps * Vars with Weak Update * P:(mapping {
                                                                        Local {
                                                                          i ->
                                                                            (Unknown int([-31,31]))
                                                                        }
                                                                      }, mapping {
                                                                             }, {}, {}),
  lifted node:Unknown node, Unit:()], mapping {
                                        }):
not leq ([Reversed (top or Set (Normal Lvals * booleans)):{},
          top or Set (variables):{}, booleans:False,
          MT mode:Multithreaded (other),
          Thread * created:(([signal_waiter@aget_comb.c:205:3, main], {}), {}),
          value domain * array partitioning deps * Vars with Weak Update * P:(mapping {
                                                                                }, mapping {
                                                                                     }, {}, {}),
          lifted node:Unknown node, Unit:()], mapping {
                                                }) because Map: i =
compound: (Unknown int([-31,31])) not same type as Uninitialized. 

Statement return; @ aget_comb.c:1053:3 is more precise using left:
Set ([expRelation:(Unit), mallocWrapper:(lifted node), base:(value domain * array partitioning deps * Vars with Weak Update * P), threadid:(Thread * created), threadflag:(MT mode), threadreturn:(booleans), escape:(top or Set (variables)), mutex:(Reversed (top or Set (Normal Lvals * booleans)))] * std) (1 and 1 paths): These are fine!
Statement return ((void *)0); @ aget_comb.c:1178:3 is more precise using left:
No Changes
Statement close(sd); @ aget_comb.c:1176:3 is more precise using right:
{([Reversed (top or Set (Normal Lvals * booleans)):{},
   top or Set (variables):{}, booleans:True, MT mode:Multithreaded (other),
   Thread * created:(Top Threads, {}),
   value domain * array partitioning deps * Vars with Weak Update * P:(mapping {
                                                                         Local {
                                                                           td ->
                                                                             {?, &(alloc@sid:224)[def_exc:Unknown int([-31,31])], &(alloc@sid:118)[def_exc:Unknown int([-31,31])]}
                                                                           sd ->
                                                                             (Not {-1}([-31,31]))
                                                                           rbuf ->
                                                                             {&(alloc@sid:703)[def_exc:0]}
                                                                           s ->
                                                                             {&(alloc@sid:703)[def_exc:Unknown int([-63,63])]}
                                                                           dr ->
                                                                             (Unknown int([-31,31]))
                                                                           dw ->
                                                                             (Unknown int([-31,31]))
                                                                           i ->
                                                                             (Unknown int([-31,31]))
                                                                           foffset ->
                                                                             (Unknown int([-63,63]))
                                                                           tid ->
                                                                             (Unknown int([0,64]))
                                                                           tmp ->
                                                                             {&(alloc@sid:703)[def_exc:0]}
                                                                           tmp___0 ->
                                                                             {NULL, ?}
                                                                           tmp___1 ->
                                                                             {NULL, ?}
                                                                           tmp___2 ->
                                                                             {NULL, ?}
                                                                           tmp___3 ->
                                                                             {NULL, ?}
                                                                           tmp___4 ->
                                                                             (Not {-1}([-31,31]))
                                                                           tmp___5 ->
                                                                             {NULL, ?}
                                                                           tmp___6 ->
                                                                             {NULL, ?}
                                                                           tmp___7 ->
                                                                             (Unknown int([0,32]))
                                                                           tmp___8 ->
                                                                             (Not {-1}([-31,31]))
                                                                           tmp___9 ->
                                                                             {NULL, ?}
                                                                           tmp___10 ->
                                                                             {NULL, ?}
                                                                           tmp___11 ->
                                                                             {NULL, ?}
                                                                         }
                                                                         Parameter {
                                                                           arg ->
                                                                             {?, &(alloc@sid:224)[def_exc:Unknown int([-31,31])], &(alloc@sid:118)[def_exc:Unknown int([-31,31])]}
                                                                         }
                                                                       }, mapping {
                                                                              }, {}, {}),
   lifted node:Unknown node, Unit:()], mapping {
                                         })} instead of Dead code
locals: 	equal = 453	left = 2	right = 2	incomparable = 94
locals_ctx:	equal = 66	left = 0	right = 0	incomparable = 0	no_ctx_in_right = 1302