The rule for while loops fails to capture flows from the a loop's body to its condition.  For example, consider

  read(X, high);
  Y := 1;
  Z := 0;
  while(Y > 0 && Z < 2){
     Y := X;
     Z := Z + 1
  };
  write(Z, low)

The while loop will be executed once if X is 0 and twice otherwise.  Thus, the low output will be 1 if X is 0 and 2 otherwise, showing a flow from low to high.  

However, the rule for loops will fail to show this flow.  While it finds the flow from the condition to Z and from X to Y, it does so in that order and does not update the first flow to reflect the second.  Thus, since the condition does not depend upon X (high) until after an execution of a body, it does not find X flowing to Z.

While the rule should be reformulated, a quick fix is to just wrap all while loops inside of another trivial one.  For example, rewrite the above program as

  read(X, high);
  Y := 1;
  Z := 0;
  while(true){
    while(Y > 0 && Z < 2){
       Y := X;
       Z := Z + 1
    }
  };
  write(Z, low)

The outer loop will force recomputing the condition's level after finding the flow from X to Y.  (The fact that this changes the program's semantics shouldn't effect the analysis since it's termination insensitive.)