anchor.diff:                  { Value = output.Value
                     Address = address
                     Index = i }
  -            saveNeoOutput transactionHash output
  +            saveInputOutputRecord "Output" transactionHash output
               output
  -
  -        let lookupTransaction transHash i =
  -            client.Cypher
  -                .Match("(t:Transaction)-[:output]->(o:Output)")
  -                .Where(fun t -> t.TransactionHash = transHash)
  -                .AndWhere(fun o -> o.Index = i)
  -                .Return<NeoOutput>("o")
  -                .Results
  -                .SingleOrDefault()
  -
  -        let saveNeoInput transactionHash neoInput =
  -            client.Cypher
  -                .Create("(i:Input {param})")
  -                .WithParam("param", neoInput)
  -                .With("i")
  -                .Match("(t:Transaction)")
  -                .Where(fun t -> t.TransactionHash = transactionHash)
  -                .CreateUnique("t-[:input]->i")
  -                .ExecuteWithoutResults()
   
           let neoInputOfInput transactionHash transTime (input: Input) =
               let inputHash = Conversion.littleEndianBytesToHexString input.InputHash
  
positive.code:                   Index = input.InputTransactionIndex
                    Address = outputAddress
                    Value = outputValue }
              saveNeoInput transactionHash input
              input
  
          let saveNeoTrans neoTrans =
              client.Cypher
                  .Create("(t:Transaction {param})")
                  .WithParam("param", neoTrans)
                  .ExecuteWithoutResults()
  
          let tansactionRelations trans blockHash =
              client.Cypher
                  .Match("(t:Transaction)", "(b:Block)")
                  .Where(fun t -> t.TransactionHash = trans.TransactionHash)
                  .AndWhere(fun b -> b.Hash = blockHash)
                  .CreateUnique("t-[:belongsTo]->b")
                  .CreateUnique("t<-[:owns]-b")
                  .ExecuteWithoutResults()
  
          let updateTransaction (trans: NeoTransaction) =
              client.Cypher
                  .Match("(t:Transaction)")
                  .Where(fun t -> t.TransactionHash = trans.TransactionHash)
                  .Set("t.TotalInputs = {inputparam}")
                  .WithParam("inputparam", trans.TotalInputs)
                  .Set("t.TotalOutputs = {outputparam}")
                  .WithParam("outputparam", trans.TotalOutputs)
                  .ExecuteWithoutResults()
  
          let neoTransOfTrans (trans: Transaction) (hash: string) timestamp =
              let transactionHash = Conversion.littleEndianBytesToHexString trans.TransactionHash
  
negative.code:                 { Hash = hash
                    Timestamp = timestamp
                    Height = height }
              saveRecord "Block" neoBlock
              for trans in block.Transactions do
                  neoTransOfTrans trans hash timestamp
              neoBlock
  