anchor.diff:                      | prs -> reducePrices (reductionStep prs)
   
           let premium, previousPremium = reducePrices prices
  -        buildPricingResult previousPremium premium pricing
  +        buildPricingResult previousPremium premium ctx
   
       let buildPricingContext (stock:StockInfo) (option:OptionLeg) (steps:int) = 
           // we need to construct the binomial pricing model, using the CRR (Cox, Ross and Rubinstein)
  
positive.code:         let call = exp(-rate) * (q*cu + (1.0-q)*cd)
          call
  
      let buildPricingResult previousOptionPrice optionPrice pricing = 
          let optionPriceChange = previousOptionPrice - optionPrice
          let underlyingPriceChange = pricing.Ref*pricing.Up - pricing.Ref
          let delta = optionPriceChange / underlyingPriceChange
          {
              Premium = optionPrice
              Delta = delta
          }
  
      let binomialPricing (pricing:BinomialContext) =
          
          // this array holds the prices of the underlying in given period
          let prices = Array.zeroCreate pricing.Periods
          
          // retursn a function used to calculate the option prices in the period i.
          // it looks into the underlying prices array and compares with strike
          let optionValueInPeriod = 
              match pricing.Option.Kind with
                      | Call -> fun i -> max 0.0 (prices.[i] - pricing.Option.Strike)
                      | Put -> fun i -> max 0.0 (pricing.Option.Strike - prices.[i])
                                   
          // initialize the last price (the underlying wen down * period times)
          prices.[0] <- pricing.Ref*(pricing.Down**(float pricing.Periods))
          let optionValues = Array.zeroCreate pricing.Periods
  
          optionValues.[0]<- optionValueInPeriod 0
          for i in 1 ..pricing.Periods-1 do
              prices.[i] <- prices.[i-1]*pricing.Up*pricing.Up
              optionValues.[i]<- optionValueInPeriod i
  
          let counter = pricing.Periods-2
          for step = counter downto 0 do
              for j in 0 .. step do
                  optionValues.[j] <- (pricing.PUp*optionValues.[j+1]+pricing.PDown*optionValues.[j])*(1.0/pricing.Rate)
                  if pricing.Option.Style = American then
                      prices.[j] <- pricing.Down*prices.[j+1]
                      optionValues.[j] <- max optionValues.[j] (optionValueInPeriod j)
  
          buildPricingResult optionValues.[1] optionValues.[0] pricing
      
      // Creates an array of BinomialNodes - the leafs of the CRR tree
      let generateEndNodePrices (ref:float) (up:float) (periods:int) optionVal =
  
negative.code:             |> Array.pairwise 
              |> Array.map (fun (downNode,upNode) -> mergeNodes downNode upNode optionVal pricing)
              
      let binomialPricingFunc (ctx:BinomialContext) =
          let optionValue = BasicOptions.optionValue ctx.Option
  
          // that's the leafs of the derivative tree
          let prices = generateEndNodePrices ctx.Ref ctx.Up ctx.Periods optionValue
          
          // define a reduction step which will generate new layer
          let reductionStep = step ctx optionValue
          
          // apply the reduction till we have only one node in the list
          let rec reducePrices prices =
  