public static Price Decode(IByteReader stream)
 {
     Price decodedPrice = new Price();
     decodedPrice.N = Int32.Decode(stream);
     decodedPrice.D = Int32.Decode(stream);
     return decodedPrice;
 }

 public static TransactionResultPair Decode(IByteReader stream)
 {
     TransactionResultPair decodedTransactionResultPair = new TransactionResultPair();
     decodedTransactionResultPair.TransactionHash = Hash.Decode(stream);
     decodedTransactionResultPair.Result = TransactionResult.Decode(stream);
     return decodedTransactionResultPair;
 }

 public static Signature Decode(IByteReader stream)
 {
     Signature decodedSignature = new Signature();
       int Signaturesize = XdrEncoding.DecodeInt32(stream);
       decodedSignature.InnerValue = XdrEncoding.ReadFixOpaque(stream, (uint)Signaturesize);
     return decodedSignature;
 }

 public static Thresholds Decode(IByteReader stream)
 {
     Thresholds decodedThresholds = new Thresholds();
       int Thresholdssize = 4;
       decodedThresholds.InnerValue = XdrEncoding.ReadFixOpaque(stream, (uint)Thresholdssize);
     return decodedThresholds;
 }

 public static SCPStatement Decode(IByteReader stream) {
   SCPStatement decodedSCPStatement = new SCPStatement();
   decodedSCPStatement.NodeID = NodeID.Decode(stream);
   decodedSCPStatement.SlotIndex = Uint64.Decode(stream);
   decodedSCPStatement.Pledges = SCPStatementPledges.Decode(stream);
   return decodedSCPStatement;
 }

 public static Uint256 Decode(IByteReader stream)
 {
     Uint256 decodedUint256 = new Uint256();
       int uint256size = 32;
       decodedUint256.InnerValue = XdrEncoding.ReadFixOpaque(stream, (uint)uint256size);
     return decodedUint256;
 }

 public static AuthenticatedMessageV0 Decode(IByteReader stream) {
   AuthenticatedMessageV0 decodedAuthenticatedMessageV0 = new AuthenticatedMessageV0();
   decodedAuthenticatedMessageV0.Sequence = Uint64.Decode(stream);
   decodedAuthenticatedMessageV0.Message = StellarMessage.Decode(stream);
   decodedAuthenticatedMessageV0.Mac = HmacSha256Mac.Decode(stream);
   return decodedAuthenticatedMessageV0;
 }

 public static SignatureHint Decode(IByteReader stream)
 {
     SignatureHint decodedSignatureHint = new SignatureHint();
       int SignatureHintsize = 4;
       decodedSignatureHint.InnerValue = XdrEncoding.ReadFixOpaque(stream, (uint)SignatureHintsize);
     return decodedSignatureHint;
 }

		//public int getMaxOffset() { return MaxOffset; }



		/**
		 * checks whether the binary file specified by targetFile is compliant
		 * with this byte sequence
		 *
		 * @param targetFile   The binary file to be identified
		 */
		public bool isFileCompliant(IByteReader targetFile)
		{
			//System.out.println("Looking at new byte sequence with reference "+Reference);
			//initialise variables and start with the file marker at the beginning of the file
			bool isCompliant = true;
			bool reverseOrder = (string.Compare(getReference(), "EOFoffset", true) == 0) ? true : false; //(getReference().equalsIgnoreCase("EOFoffset")) ? true : false;
			int ssLoopStart = reverseOrder ? getNumSubSequences() - 1 : 0;
			int ssLoopEnd = reverseOrder ? -1 : getNumSubSequences();
			int searchDirection = reverseOrder ? -1 : 1;
			if (reverseOrder)
			{
				targetFile.SetFileMarker(targetFile.GetNumberOfBytes() - 1L);
			}
			else
			{
				targetFile.SetFileMarker(0L);
			}

			//check whether each subsequence in turn is compliant
			for (int iSS = ssLoopStart; (searchDirection * iSS < searchDirection * ssLoopEnd) & isCompliant; iSS += searchDirection)
			{
				bool isFixedStart = ((string.Compare(getReference(), "EOFoffset", true) == 0) || (string.Compare(getReference(), "BOFoffset", true) == 0)) ? true : false; //getReference().equalsIgnoreCase("EOFoffset") || getReference().equalsIgnoreCase("BOFoffset");
				if ((iSS == ssLoopStart) && (isFixedStart))
				{
					isCompliant = getSubSequence(iSS).isFoundAtStartOfFile(targetFile, reverseOrder, bigEndian); //, MaxOffset);
				}
				else
				{
					isCompliant = getSubSequence(iSS).isFoundAfterFileMarker(targetFile, reverseOrder, bigEndian);
				}
			}
			return isCompliant;
		}

 public static Curve25519Secret Decode(IByteReader stream)
 {
     Curve25519Secret decodedCurve25519Secret = new Curve25519Secret();
     int keysize = 32;
     decodedCurve25519Secret.Key = XdrEncoding.ReadFixOpaque(stream, (uint)keysize);
     return decodedCurve25519Secret;
 }

 public static Value Decode(IByteReader stream)
 {
     Value decodedValue = new Value();
       int Valuesize = XdrEncoding.DecodeInt32(stream);
       decodedValue.InnerValue = XdrEncoding.ReadFixOpaque(stream, (uint)Valuesize);
     return decodedValue;
 }

 public static DecoratedSignature Decode(IByteReader stream)
 {
     DecoratedSignature decodedDecoratedSignature = new DecoratedSignature();
     decodedDecoratedSignature.Hint = SignatureHint.Decode(stream);
     decodedDecoratedSignature.Signature = Signature.Decode(stream);
     return decodedDecoratedSignature;
 }

 public static Error Decode(IByteReader stream)
 {
     Error decodedError = new Error();
     decodedError.Code = ErrorCode.Decode(stream);
     decodedError.Msg = XdrEncoding.ReadString(stream);
     return decodedError;
 }

 public static PaymentOp Decode(IByteReader stream) {
   PaymentOp decodedPaymentOp = new PaymentOp();
   decodedPaymentOp.Destination = AccountID.Decode(stream);
   decodedPaymentOp.Asset = Asset.Decode(stream);
   decodedPaymentOp.Amount = Int64.Decode(stream);
   return decodedPaymentOp;
 }

 public static LedgerEntry Decode(IByteReader stream) {
   LedgerEntry decodedLedgerEntry = new LedgerEntry();
   decodedLedgerEntry.LastModifiedLedgerSeq = Uint32.Decode(stream);
   decodedLedgerEntry.Data = LedgerEntryData.Decode(stream);
   decodedLedgerEntry.Ext = LedgerEntryExt.Decode(stream);
   return decodedLedgerEntry;
 }

 public static PeerAddress Decode(IByteReader stream) {
   PeerAddress decodedPeerAddress = new PeerAddress();
   decodedPeerAddress.Ip = PeerAddressIp.Decode(stream);
   decodedPeerAddress.Port = Uint32.Decode(stream);
   decodedPeerAddress.NumFailures = Uint32.Decode(stream);
   return decodedPeerAddress;
 }

 public static Hash Decode(IByteReader stream)
 {
     Hash decodedHash = new Hash();
       int Hashsize = 32;
       decodedHash.InnerValue = XdrEncoding.ReadFixOpaque(stream, (uint)Hashsize);
     return decodedHash;
 }

 public static AssetAlphaNum4 Decode(IByteReader stream) {
   AssetAlphaNum4 decodedAssetAlphaNum4 = new AssetAlphaNum4();
   int assetCodesize = 4;
   decodedAssetAlphaNum4.AssetCode = XdrEncoding.ReadFixOpaque(stream, (uint)assetCodesize);
   decodedAssetAlphaNum4.Issuer = AccountID.Decode(stream);
   return decodedAssetAlphaNum4;
 }

 public static LedgerHeaderHistoryEntry Decode(IByteReader stream) {
   LedgerHeaderHistoryEntry decodedLedgerHeaderHistoryEntry = new LedgerHeaderHistoryEntry();
   decodedLedgerHeaderHistoryEntry.Hash = Hash.Decode(stream);
   decodedLedgerHeaderHistoryEntry.Header = LedgerHeader.Decode(stream);
   decodedLedgerHeaderHistoryEntry.Ext = LedgerHeaderHistoryEntryExt.Decode(stream);
   return decodedLedgerHeaderHistoryEntry;
 }

 public static TransactionHistoryResultEntry Decode(IByteReader stream) {
   TransactionHistoryResultEntry decodedTransactionHistoryResultEntry = new TransactionHistoryResultEntry();
   decodedTransactionHistoryResultEntry.LedgerSeq = Uint32.Decode(stream);
   decodedTransactionHistoryResultEntry.TxResultSet = TransactionResultSet.Decode(stream);
   decodedTransactionHistoryResultEntry.Ext = TransactionHistoryResultEntryExt.Decode(stream);
   return decodedTransactionHistoryResultEntry;
 }