anchor.diff:              .Match("(t:Transaction)")
               .Where(fun t -> t.TransactionHash = transactionHash)
               .CreateUnique("t-[:input]->i")
  -            .Return<NeoInput>("i")
  -            .Results
  -            .Single()
  +            .ExecuteWithoutResults()
   
       let neoInputOfInput transactionHash transTime (input: Input) =
           let inputHash = Conversion.littleEndianBytesToHexString input.InputHash
  
positive.code:                     null, 0L
          if outputAddress <> null then
              payAddress From transactionHash outputAddress outputValue transTime
          { Hash =  inputHash
            Index = input.InputTransactionIndex
            Address = outputAddress
            Value = outputValue }
          |> saveNeoInput transactionHash
  
      let saveNeoTrans neoTrans =
          client.Cypher
              .Create("(t:Transaction {param})")
              .WithParam("param", neoTrans)
              .Return<NeoTransaction>("t")
              .Results
              .Single()
  
      let tansactionRelations trans blockHash =
          client.Cypher
  
negative.code:                 payAddress To transactionHash address output.Value transTime
                  address 
              | _ -> null
          let output =
              { Value = output.Value
                Address = address
                Index = i }
          saveNeoOutput transactionHash output
          output
  
      let lookupTransaction transHash i =
          client.Cypher
  