C#

                    if (RECONCILIATIONIND == "N")
                    {
                        objSheet.Cells[iR, iC + 18] = RECONCILIATIONIND;
                        objRange = objSheet.Cells.Rows.EntireRow;
                        objRange.Font.ColorIndex = "3";
                    }
>/pre>
The next problem I have is that I need to do some calculation on an unknown number of cells and subtract it from a total in a different column.  Below is a sample screen.
<code>
Nominees & Own Name (Level 1)	Beneficiaries (Level 2)
19326421	
	                                175
	                                84
	                                76
	                                2238
	                                235
	                                14
	                                591
	                                345
	                                122
</code>
From the above, I need to calculate the totals in Beneficiary (level 2) and subtract that from Level 1 total and add the total into a new column.  Now, there is an undertermined number of values in Level 2 i.e. there could be 2 or 4 or 50 or 300 values to add.  How would I be able to do that?

Any help or advise would be appreciated. 

<div class="ForumSig">Excellence is doing ordinary things extraordinarily well.</div>

Fan-Out metric is the number of classes that a particular class relies 
on. Fan-In metric is the number of classes that make use of a given class. 
The ripple impact measure counts the total number of classes that might 
have an impact when any single class is changed. Based on the dependency 
graph above, if we were to modify "E", the ripple will impact B directly, 
since B has an impact this will impact A as well. In short any change made 
to ‘E’ can have a potential ripple impact on B and A.

The nodes in the dependency graph that have a Fan-Out of Zero are known as 
a Sink node. Nodes that have a Fan-In of zero are known as Source nodes.

In the dependency graph shown, we can extract the following information:
• A: Fan-out = 1 [B], Fan-In = 0, Impact-Ripple = 0
• B: Fan-Out = 3 [D, E, F], Fan-In = 1 [A], Impact-Ripple = 1 [A]
• C: Fan-Out = 1 [D], Fan-In = 1 [F], Impact-Ripple = 4 [F, D, B, A]
• D: Fan-Out = 1 [F], Fan-In = 2 [C, B], Impact-Ripple = 4 [B,A,C, F]
• E: Fan-Out = 0, Fan-In = 1, Impact-Ripple = 2 [B,A]
• F: Fan-Out = 1, Fan-In = 2, Impact-Ripple = 4 [B,D,A,C]
• Sink nodes: E, Source nodes: A

public class Node
{
   ...

   public List<Node> FanIn
   {
       get
       {
           return this.fanIn;
       }
   }

   public HashSet<Node> Ripple
   {
       get
       {
            HashSet<Node> rippleSet = new HashSet<Node>();
            
            // add this node for easy cycle checking so we don't
            // process ourself twice
            rippleSet.Add(this);
            
            // call our recursive function
            this.CalcRipple(rippleSet);

            // remember to remove us so we don't skew the result
            rippleSet.Remove(this);

            return rippleSet;
       }
   }

   private void CalcRipple(HashSet<Node> rippleSet)
   {
       // source nodes exit here...
       foreach (Node node in this.FanIn)
       {
            // try and add the node to the set - if it fails then we
            // have already visited it before as it already exists in
            // the set, other wise the node gets added and we need to 
            // process its fan-in nodes. 
            //
            // as far as i can tell this results in us performing a
            // depth first traversal of the graph
            if (rippleSet.Add(node))
            {
                node.CalcRipple(rippleSet);
            }
        }
   }

   ...
}