using System;
using System.Text;
using QCRPG.Framework;

namespace QCRPG.TSL.BT.Packets;

public class DbfwLmpDebugInfo : PacketBase
{
	public class UserFieldsWrapper
	{
		public class VariousInfo0EnumCollection
		{
			private AssertBitEnum _InitiatedBySlave;

			private AssertBitEnum _InternallyUsed;

			private AssertBitEnum _Reserved;

			public AssertBitEnum InitiatedBySlave
			{
				get
				{
					return _InitiatedBySlave;
				}
				set
				{
					_InitiatedBySlave = value;
				}
			}

			public AssertBitEnum InternallyUsed
			{
				get
				{
					return _InternallyUsed;
				}
				set
				{
					_InternallyUsed = value;
				}
			}

			public AssertBitEnum Reserved
			{
				get
				{
					return _Reserved;
				}
				set
				{
					_Reserved = value;
				}
			}
		}

		public static class VariousInfo0Info
		{
			public static VariousInfo0EnumCollection ValueToVariousInfo0(uint value)
			{
				VariousInfo0EnumCollection variousInfo0EnumCollection = new VariousInfo0EnumCollection();
				variousInfo0EnumCollection.InitiatedBySlave = AssertBitInfo.ValueToAssertBit(value & 1u);
				variousInfo0EnumCollection.InternallyUsed = AssertBitInfo.ValueToAssertBit((value & 2) >> 1);
				variousInfo0EnumCollection.Reserved = AssertBitInfo.ValueToAssertBit((value & 0xFC) >> 2);
				return variousInfo0EnumCollection;
			}

			public static uint VariousInfo0ToValue(VariousInfo0EnumCollection enumCollection)
			{
				uint num = 0u;
				num |= AssertBitInfo.AssertBitToValue(enumCollection.InitiatedBySlave);
				num |= AssertBitInfo.AssertBitToValue(enumCollection.InternallyUsed) << 1;
				return num | (AssertBitInfo.AssertBitToValue(enumCollection.Reserved) << 2);
			}

			public static string VariousInfo0ToString(VariousInfo0EnumCollection enumCollection)
			{
				string text = "";
				text = text + "Initiated by Slave: " + AssertBitInfo.AssertBitToString(enumCollection.InitiatedBySlave) + "\r\n";
				text = text + "Internally Used: " + AssertBitInfo.AssertBitToString(enumCollection.InternallyUsed) + "\r\n";
				text = text + "Reserved: " + AssertBitInfo.AssertBitToString(enumCollection.Reserved) + "\r\n";
				return text.TrimEnd('\r', '\n');
			}

			public static string VariousInfo0ToDescription()
			{
				StringBuilder stringBuilder = new StringBuilder();
				stringBuilder.AppendLine("Bit 0: Initiated by Slave");
				stringBuilder.AppendLine(AssertBitInfo.AssertBitToDescription());
				stringBuilder.AppendLine("Bit 1: Internally Used");
				stringBuilder.AppendLine(AssertBitInfo.AssertBitToDescription());
				stringBuilder.AppendLine("Bits 7-2: Reserved");
				stringBuilder.AppendLine(AssertBitInfo.AssertBitToDescription());
				return stringBuilder.ToString();
			}
		}

		public class AckInfomation0EnumCollection
		{
			private DbfwPacketTypeEnum _PacketType;

			private AssertBitEnum _Arqn;

			private AssertBitEnum _FowGo;

			private AssertBitEnum _Valid;

			public DbfwPacketTypeEnum PacketType
			{
				get
				{
					return _PacketType;
				}
				set
				{
					_PacketType = value;
				}
			}

			public AssertBitEnum Arqn
			{
				get
				{
					return _Arqn;
				}
				set
				{
					_Arqn = value;
				}
			}

			public AssertBitEnum FowGo
			{
				get
				{
					return _FowGo;
				}
				set
				{
					_FowGo = value;
				}
			}

			public AssertBitEnum Valid
			{
				get
				{
					return _Valid;
				}
				set
				{
					_Valid = value;
				}
			}
		}

		public static class AckInfomation0Info
		{
			public static AckInfomation0EnumCollection ValueToAckInfomation0(uint value)
			{
				AckInfomation0EnumCollection ackInfomation0EnumCollection = new AckInfomation0EnumCollection();
				ackInfomation0EnumCollection.PacketType = DbfwPacketTypeInfo.ValueToDbfwPacketType(value & 0xFu);
				ackInfomation0EnumCollection.Arqn = AssertBitInfo.ValueToAssertBit((value & 0x10) >> 4);
				ackInfomation0EnumCollection.FowGo = AssertBitInfo.ValueToAssertBit((value & 0x20) >> 5);
				ackInfomation0EnumCollection.Valid = AssertBitInfo.ValueToAssertBit((value & 0x40) >> 6);
				return ackInfomation0EnumCollection;
			}

			public static uint AckInfomation0ToValue(AckInfomation0EnumCollection enumCollection)
			{
				uint num = 0u;
				num |= DbfwPacketTypeInfo.DbfwPacketTypeToValue(enumCollection.PacketType);
				num |= AssertBitInfo.AssertBitToValue(enumCollection.Arqn) << 4;
				num |= AssertBitInfo.AssertBitToValue(enumCollection.FowGo) << 5;
				return num | (AssertBitInfo.AssertBitToValue(enumCollection.Valid) << 6);
			}

			public static string AckInfomation0ToString(AckInfomation0EnumCollection enumCollection)
			{
				string text = "";
				text = text + "Packet Type: " + DbfwPacketTypeInfo.DbfwPacketTypeToString(enumCollection.PacketType) + "\r\n";
				text = text + "ARQN: " + AssertBitInfo.AssertBitToString(enumCollection.Arqn) + "\r\n";
				text = text + "Fow Go: " + AssertBitInfo.AssertBitToString(enumCollection.FowGo) + "\r\n";
				text = text + "Valid: " + AssertBitInfo.AssertBitToString(enumCollection.Valid) + "\r\n";
				return text.TrimEnd('\r', '\n');
			}

			public static string AckInfomation0ToDescription()
			{
				StringBuilder stringBuilder = new StringBuilder();
				stringBuilder.AppendLine("Bits 3-0: Packet Type");
				stringBuilder.AppendLine(DbfwPacketTypeInfo.DbfwPacketTypeToDescription());
				stringBuilder.AppendLine("Bit 4: ARQN");
				stringBuilder.AppendLine(AssertBitInfo.AssertBitToDescription());
				stringBuilder.AppendLine("Bit 5: Fow Go");
				stringBuilder.AppendLine(AssertBitInfo.AssertBitToDescription());
				stringBuilder.AppendLine("Bit 6: Valid");
				stringBuilder.AppendLine(AssertBitInfo.AssertBitToDescription());
				stringBuilder.AppendLine("Bit 7: Reserved");
				return stringBuilder.ToString();
			}
		}

		public class VariousInfo1EnumCollection
		{
			private AssertBitEnum _InitiatedBySlave;

			private AssertBitEnum _InternallyUsed;

			private AssertBitEnum _Reserved;

			public AssertBitEnum InitiatedBySlave
			{
				get
				{
					return _InitiatedBySlave;
				}
				set
				{
					_InitiatedBySlave = value;
				}
			}

			public AssertBitEnum InternallyUsed
			{
				get
				{
					return _InternallyUsed;
				}
				set
				{
					_InternallyUsed = value;
				}
			}

			public AssertBitEnum Reserved
			{
				get
				{
					return _Reserved;
				}
				set
				{
					_Reserved = value;
				}
			}
		}

		public static class VariousInfo1Info
		{
			public static VariousInfo1EnumCollection ValueToVariousInfo1(uint value)
			{
				VariousInfo1EnumCollection variousInfo1EnumCollection = new VariousInfo1EnumCollection();
				variousInfo1EnumCollection.InitiatedBySlave = AssertBitInfo.ValueToAssertBit(value & 1u);
				variousInfo1EnumCollection.InternallyUsed = AssertBitInfo.ValueToAssertBit((value & 2) >> 1);
				variousInfo1EnumCollection.Reserved = AssertBitInfo.ValueToAssertBit((value & 0xFC) >> 2);
				return variousInfo1EnumCollection;
			}

			public static uint VariousInfo1ToValue(VariousInfo1EnumCollection enumCollection)
			{
				uint num = 0u;
				num |= AssertBitInfo.AssertBitToValue(enumCollection.InitiatedBySlave);
				num |= AssertBitInfo.AssertBitToValue(enumCollection.InternallyUsed) << 1;
				return num | (AssertBitInfo.AssertBitToValue(enumCollection.Reserved) << 2);
			}

			public static string VariousInfo1ToString(VariousInfo1EnumCollection enumCollection)
			{
				string text = "";
				text = text + "Initiated by Slave: " + AssertBitInfo.AssertBitToString(enumCollection.InitiatedBySlave) + "\r\n";
				text = text + "Internally Used: " + AssertBitInfo.AssertBitToString(enumCollection.InternallyUsed) + "\r\n";
				text = text + "Reserved: " + AssertBitInfo.AssertBitToString(enumCollection.Reserved) + "\r\n";
				return text.TrimEnd('\r', '\n');
			}

			public static string VariousInfo1ToDescription()
			{
				StringBuilder stringBuilder = new StringBuilder();
				stringBuilder.AppendLine("Bit 0: Initiated by Slave");
				stringBuilder.AppendLine(AssertBitInfo.AssertBitToDescription());
				stringBuilder.AppendLine("Bit 1: Internally Used");
				stringBuilder.AppendLine(AssertBitInfo.AssertBitToDescription());
				stringBuilder.AppendLine("Bits 7-2: Reserved");
				stringBuilder.AppendLine(AssertBitInfo.AssertBitToDescription());
				return stringBuilder.ToString();
			}
		}

		public class AckInfomation1EnumCollection
		{
			private DbfwPacketTypeEnum _PacketType;

			private AssertBitEnum _Arqn;

			private AssertBitEnum _FowGo;

			private AssertBitEnum _Valid;

			public DbfwPacketTypeEnum PacketType
			{
				get
				{
					return _PacketType;
				}
				set
				{
					_PacketType = value;
				}
			}

			public AssertBitEnum Arqn
			{
				get
				{
					return _Arqn;
				}
				set
				{
					_Arqn = value;
				}
			}

			public AssertBitEnum FowGo
			{
				get
				{
					return _FowGo;
				}
				set
				{
					_FowGo = value;
				}
			}

			public AssertBitEnum Valid
			{
				get
				{
					return _Valid;
				}
				set
				{
					_Valid = value;
				}
			}
		}

		public static class AckInfomation1Info
		{
			public static AckInfomation1EnumCollection ValueToAckInfomation1(uint value)
			{
				AckInfomation1EnumCollection ackInfomation1EnumCollection = new AckInfomation1EnumCollection();
				ackInfomation1EnumCollection.PacketType = DbfwPacketTypeInfo.ValueToDbfwPacketType(value & 0xFu);
				ackInfomation1EnumCollection.Arqn = AssertBitInfo.ValueToAssertBit((value & 0x10) >> 4);
				ackInfomation1EnumCollection.FowGo = AssertBitInfo.ValueToAssertBit((value & 0x20) >> 5);
				ackInfomation1EnumCollection.Valid = AssertBitInfo.ValueToAssertBit((value & 0x40) >> 6);
				return ackInfomation1EnumCollection;
			}

			public static uint AckInfomation1ToValue(AckInfomation1EnumCollection enumCollection)
			{
				uint num = 0u;
				num |= DbfwPacketTypeInfo.DbfwPacketTypeToValue(enumCollection.PacketType);
				num |= AssertBitInfo.AssertBitToValue(enumCollection.Arqn) << 4;
				num |= AssertBitInfo.AssertBitToValue(enumCollection.FowGo) << 5;
				return num | (AssertBitInfo.AssertBitToValue(enumCollection.Valid) << 6);
			}

			public static string AckInfomation1ToString(AckInfomation1EnumCollection enumCollection)
			{
				string text = "";
				text = text + "Packet Type: " + DbfwPacketTypeInfo.DbfwPacketTypeToString(enumCollection.PacketType) + "\r\n";
				text = text + "ARQN: " + AssertBitInfo.AssertBitToString(enumCollection.Arqn) + "\r\n";
				text = text + "Fow Go: " + AssertBitInfo.AssertBitToString(enumCollection.FowGo) + "\r\n";
				text = text + "Valid: " + AssertBitInfo.AssertBitToString(enumCollection.Valid) + "\r\n";
				return text.TrimEnd('\r', '\n');
			}

			public static string AckInfomation1ToDescription()
			{
				StringBuilder stringBuilder = new StringBuilder();
				stringBuilder.AppendLine("Bits 3-0: Packet Type");
				stringBuilder.AppendLine(DbfwPacketTypeInfo.DbfwPacketTypeToDescription());
				stringBuilder.AppendLine("Bit 4: ARQN");
				stringBuilder.AppendLine(AssertBitInfo.AssertBitToDescription());
				stringBuilder.AppendLine("Bit 5: Fow Go");
				stringBuilder.AppendLine(AssertBitInfo.AssertBitToDescription());
				stringBuilder.AppendLine("Bit 6: Valid");
				stringBuilder.AppendLine(AssertBitInfo.AssertBitToDescription());
				stringBuilder.AppendLine("Bit 7: Reserved");
				return stringBuilder.ToString();
			}
		}

		public class VariousInfo2EnumCollection
		{
			private AssertBitEnum _InitiatedBySlave;

			private AssertBitEnum _InternallyUsed;

			private AssertBitEnum _Reserved;

			public AssertBitEnum InitiatedBySlave
			{
				get
				{
					return _InitiatedBySlave;
				}
				set
				{
					_InitiatedBySlave = value;
				}
			}

			public AssertBitEnum InternallyUsed
			{
				get
				{
					return _InternallyUsed;
				}
				set
				{
					_InternallyUsed = value;
				}
			}

			public AssertBitEnum Reserved
			{
				get
				{
					return _Reserved;
				}
				set
				{
					_Reserved = value;
				}
			}
		}

		public static class VariousInfo2Info
		{
			public static VariousInfo2EnumCollection ValueToVariousInfo2(uint value)
			{
				VariousInfo2EnumCollection variousInfo2EnumCollection = new VariousInfo2EnumCollection();
				variousInfo2EnumCollection.InitiatedBySlave = AssertBitInfo.ValueToAssertBit(value & 1u);
				variousInfo2EnumCollection.InternallyUsed = AssertBitInfo.ValueToAssertBit((value & 2) >> 1);
				variousInfo2EnumCollection.Reserved = AssertBitInfo.ValueToAssertBit((value & 0xFC) >> 2);
				return variousInfo2EnumCollection;
			}

			public static uint VariousInfo2ToValue(VariousInfo2EnumCollection enumCollection)
			{
				uint num = 0u;
				num |= AssertBitInfo.AssertBitToValue(enumCollection.InitiatedBySlave);
				num |= AssertBitInfo.AssertBitToValue(enumCollection.InternallyUsed) << 1;
				return num | (AssertBitInfo.AssertBitToValue(enumCollection.Reserved) << 2);
			}

			public static string VariousInfo2ToString(VariousInfo2EnumCollection enumCollection)
			{
				string text = "";
				text = text + "Initiated by Slave: " + AssertBitInfo.AssertBitToString(enumCollection.InitiatedBySlave) + "\r\n";
				text = text + "Internally Used: " + AssertBitInfo.AssertBitToString(enumCollection.InternallyUsed) + "\r\n";
				text = text + "Reserved: " + AssertBitInfo.AssertBitToString(enumCollection.Reserved) + "\r\n";
				return text.TrimEnd('\r', '\n');
			}

			public static string VariousInfo2ToDescription()
			{
				StringBuilder stringBuilder = new StringBuilder();
				stringBuilder.AppendLine("Bit 0: Initiated by Slave");
				stringBuilder.AppendLine(AssertBitInfo.AssertBitToDescription());
				stringBuilder.AppendLine("Bit 1: Internally Used");
				stringBuilder.AppendLine(AssertBitInfo.AssertBitToDescription());
				stringBuilder.AppendLine("Bits 7-2: Reserved");
				stringBuilder.AppendLine(AssertBitInfo.AssertBitToDescription());
				return stringBuilder.ToString();
			}
		}

		public class AckInfomation2EnumCollection
		{
			private DbfwPacketTypeEnum _PacketType;

			private AssertBitEnum _Arqn;

			private AssertBitEnum _FowGo;

			private AssertBitEnum _Valid;

			public DbfwPacketTypeEnum PacketType
			{
				get
				{
					return _PacketType;
				}
				set
				{
					_PacketType = value;
				}
			}

			public AssertBitEnum Arqn
			{
				get
				{
					return _Arqn;
				}
				set
				{
					_Arqn = value;
				}
			}

			public AssertBitEnum FowGo
			{
				get
				{
					return _FowGo;
				}
				set
				{
					_FowGo = value;
				}
			}

			public AssertBitEnum Valid
			{
				get
				{
					return _Valid;
				}
				set
				{
					_Valid = value;
				}
			}
		}

		public static class AckInfomation2Info
		{
			public static AckInfomation2EnumCollection ValueToAckInfomation2(uint value)
			{
				AckInfomation2EnumCollection ackInfomation2EnumCollection = new AckInfomation2EnumCollection();
				ackInfomation2EnumCollection.PacketType = DbfwPacketTypeInfo.ValueToDbfwPacketType(value & 0xFu);
				ackInfomation2EnumCollection.Arqn = AssertBitInfo.ValueToAssertBit((value & 0x10) >> 4);
				ackInfomation2EnumCollection.FowGo = AssertBitInfo.ValueToAssertBit((value & 0x20) >> 5);
				ackInfomation2EnumCollection.Valid = AssertBitInfo.ValueToAssertBit((value & 0x40) >> 6);
				return ackInfomation2EnumCollection;
			}

			public static uint AckInfomation2ToValue(AckInfomation2EnumCollection enumCollection)
			{
				uint num = 0u;
				num |= DbfwPacketTypeInfo.DbfwPacketTypeToValue(enumCollection.PacketType);
				num |= AssertBitInfo.AssertBitToValue(enumCollection.Arqn) << 4;
				num |= AssertBitInfo.AssertBitToValue(enumCollection.FowGo) << 5;
				return num | (AssertBitInfo.AssertBitToValue(enumCollection.Valid) << 6);
			}

			public static string AckInfomation2ToString(AckInfomation2EnumCollection enumCollection)
			{
				string text = "";
				text = text + "Packet Type: " + DbfwPacketTypeInfo.DbfwPacketTypeToString(enumCollection.PacketType) + "\r\n";
				text = text + "ARQN: " + AssertBitInfo.AssertBitToString(enumCollection.Arqn) + "\r\n";
				text = text + "Fow Go: " + AssertBitInfo.AssertBitToString(enumCollection.FowGo) + "\r\n";
				text = text + "Valid: " + AssertBitInfo.AssertBitToString(enumCollection.Valid) + "\r\n";
				return text.TrimEnd('\r', '\n');
			}

			public static string AckInfomation2ToDescription()
			{
				StringBuilder stringBuilder = new StringBuilder();
				stringBuilder.AppendLine("Bits 3-0: Packet Type");
				stringBuilder.AppendLine(DbfwPacketTypeInfo.DbfwPacketTypeToDescription());
				stringBuilder.AppendLine("Bit 4: ARQN");
				stringBuilder.AppendLine(AssertBitInfo.AssertBitToDescription());
				stringBuilder.AppendLine("Bit 5: Fow Go");
				stringBuilder.AppendLine(AssertBitInfo.AssertBitToDescription());
				stringBuilder.AppendLine("Bit 6: Valid");
				stringBuilder.AppendLine(AssertBitInfo.AssertBitToDescription());
				stringBuilder.AppendLine("Bit 7: Reserved");
				return stringBuilder.ToString();
			}
		}

		public class VariousInfo3EnumCollection
		{
			private AssertBitEnum _InitiatedBySlave;

			private AssertBitEnum _InternallyUsed;

			private AssertBitEnum _Reserved;

			public AssertBitEnum InitiatedBySlave
			{
				get
				{
					return _InitiatedBySlave;
				}
				set
				{
					_InitiatedBySlave = value;
				}
			}

			public AssertBitEnum InternallyUsed
			{
				get
				{
					return _InternallyUsed;
				}
				set
				{
					_InternallyUsed = value;
				}
			}

			public AssertBitEnum Reserved
			{
				get
				{
					return _Reserved;
				}
				set
				{
					_Reserved = value;
				}
			}
		}

		public static class VariousInfo3Info
		{
			public static VariousInfo3EnumCollection ValueToVariousInfo3(uint value)
			{
				VariousInfo3EnumCollection variousInfo3EnumCollection = new VariousInfo3EnumCollection();
				variousInfo3EnumCollection.InitiatedBySlave = AssertBitInfo.ValueToAssertBit(value & 1u);
				variousInfo3EnumCollection.InternallyUsed = AssertBitInfo.ValueToAssertBit((value & 2) >> 1);
				variousInfo3EnumCollection.Reserved = AssertBitInfo.ValueToAssertBit((value & 0xFC) >> 2);
				return variousInfo3EnumCollection;
			}

			public static uint VariousInfo3ToValue(VariousInfo3EnumCollection enumCollection)
			{
				uint num = 0u;
				num |= AssertBitInfo.AssertBitToValue(enumCollection.InitiatedBySlave);
				num |= AssertBitInfo.AssertBitToValue(enumCollection.InternallyUsed) << 1;
				return num | (AssertBitInfo.AssertBitToValue(enumCollection.Reserved) << 2);
			}

			public static string VariousInfo3ToString(VariousInfo3EnumCollection enumCollection)
			{
				string text = "";
				text = text + "Initiated by Slave: " + AssertBitInfo.AssertBitToString(enumCollection.InitiatedBySlave) + "\r\n";
				text = text + "Internally Used: " + AssertBitInfo.AssertBitToString(enumCollection.InternallyUsed) + "\r\n";
				text = text + "Reserved: " + AssertBitInfo.AssertBitToString(enumCollection.Reserved) + "\r\n";
				return text.TrimEnd('\r', '\n');
			}

			public static string VariousInfo3ToDescription()
			{
				StringBuilder stringBuilder = new StringBuilder();
				stringBuilder.AppendLine("Bit 0: Initiated by Slave");
				stringBuilder.AppendLine(AssertBitInfo.AssertBitToDescription());
				stringBuilder.AppendLine("Bit 1: Internally Used");
				stringBuilder.AppendLine(AssertBitInfo.AssertBitToDescription());
				stringBuilder.AppendLine("Bits 7-2: Reserved");
				stringBuilder.AppendLine(AssertBitInfo.AssertBitToDescription());
				return stringBuilder.ToString();
			}
		}

		public class AckInfomation3EnumCollection
		{
			private DbfwPacketTypeEnum _PacketType;

			private AssertBitEnum _Arqn;

			private AssertBitEnum _FowGo;

			private AssertBitEnum _Valid;

			public DbfwPacketTypeEnum PacketType
			{
				get
				{
					return _PacketType;
				}
				set
				{
					_PacketType = value;
				}
			}

			public AssertBitEnum Arqn
			{
				get
				{
					return _Arqn;
				}
				set
				{
					_Arqn = value;
				}
			}

			public AssertBitEnum FowGo
			{
				get
				{
					return _FowGo;
				}
				set
				{
					_FowGo = value;
				}
			}

			public AssertBitEnum Valid
			{
				get
				{
					return _Valid;
				}
				set
				{
					_Valid = value;
				}
			}
		}

		public static class AckInfomation3Info
		{
			public static AckInfomation3EnumCollection ValueToAckInfomation3(uint value)
			{
				AckInfomation3EnumCollection ackInfomation3EnumCollection = new AckInfomation3EnumCollection();
				ackInfomation3EnumCollection.PacketType = DbfwPacketTypeInfo.ValueToDbfwPacketType(value & 0xFu);
				ackInfomation3EnumCollection.Arqn = AssertBitInfo.ValueToAssertBit((value & 0x10) >> 4);
				ackInfomation3EnumCollection.FowGo = AssertBitInfo.ValueToAssertBit((value & 0x20) >> 5);
				ackInfomation3EnumCollection.Valid = AssertBitInfo.ValueToAssertBit((value & 0x40) >> 6);
				return ackInfomation3EnumCollection;
			}

			public static uint AckInfomation3ToValue(AckInfomation3EnumCollection enumCollection)
			{
				uint num = 0u;
				num |= DbfwPacketTypeInfo.DbfwPacketTypeToValue(enumCollection.PacketType);
				num |= AssertBitInfo.AssertBitToValue(enumCollection.Arqn) << 4;
				num |= AssertBitInfo.AssertBitToValue(enumCollection.FowGo) << 5;
				return num | (AssertBitInfo.AssertBitToValue(enumCollection.Valid) << 6);
			}

			public static string AckInfomation3ToString(AckInfomation3EnumCollection enumCollection)
			{
				string text = "";
				text = text + "Packet Type: " + DbfwPacketTypeInfo.DbfwPacketTypeToString(enumCollection.PacketType) + "\r\n";
				text = text + "ARQN: " + AssertBitInfo.AssertBitToString(enumCollection.Arqn) + "\r\n";
				text = text + "Fow Go: " + AssertBitInfo.AssertBitToString(enumCollection.FowGo) + "\r\n";
				text = text + "Valid: " + AssertBitInfo.AssertBitToString(enumCollection.Valid) + "\r\n";
				return text.TrimEnd('\r', '\n');
			}

			public static string AckInfomation3ToDescription()
			{
				StringBuilder stringBuilder = new StringBuilder();
				stringBuilder.AppendLine("Bits 3-0: Packet Type");
				stringBuilder.AppendLine(DbfwPacketTypeInfo.DbfwPacketTypeToDescription());
				stringBuilder.AppendLine("Bit 4: ARQN");
				stringBuilder.AppendLine(AssertBitInfo.AssertBitToDescription());
				stringBuilder.AppendLine("Bit 5: Fow Go");
				stringBuilder.AppendLine(AssertBitInfo.AssertBitToDescription());
				stringBuilder.AppendLine("Bit 6: Valid");
				stringBuilder.AppendLine(AssertBitInfo.AssertBitToDescription());
				stringBuilder.AppendLine("Bit 7: Reserved");
				return stringBuilder.ToString();
			}
		}

		private const uint _DbfwEventCode = 144u;

		private const uint _SubEventCode = 19u;

		private uint _Payload0;

		private uint _FirstClock0;

		private uint _LastClock0;

		private uint _RetransmissionCount0;

		private uint _VariousInfo0;

		private uint _AckInfomation0;

		private uint _Payload1;

		private uint _FirstClock1;

		private uint _LastClock1;

		private uint _RetransmissionCount1;

		private uint _VariousInfo1;

		private uint _AckInfomation1;

		private uint _Payload2;

		private uint _FirstClock2;

		private uint _LastClock2;

		private uint _RetransmissionCount2;

		private uint _VariousInfo2;

		private uint _AckInfomation2;

		private uint _Payload3;

		private uint _FirstClock3;

		private uint _LastClock3;

		private uint _RetransmissionCount3;

		private uint _VariousInfo3;

		private uint _AckInfomation3;

		public uint DbfwEventCode => 144u;

		public uint SubEventCode => 19u;

		public uint Payload0
		{
			get
			{
				return _Payload0;
			}
			set
			{
				_Payload0 = value;
			}
		}

		public uint FirstClock0
		{
			get
			{
				return _FirstClock0;
			}
			set
			{
				_FirstClock0 = value;
			}
		}

		public uint LastClock0
		{
			get
			{
				return _LastClock0;
			}
			set
			{
				_LastClock0 = value;
			}
		}

		public uint RetransmissionCount0
		{
			get
			{
				return _RetransmissionCount0;
			}
			set
			{
				if (value > 255)
				{
					throw new Exception("Maximum possible value for RetransmissionCount0 is 0xFF");
				}
				_RetransmissionCount0 = value;
			}
		}

		public uint VariousInfo0
		{
			get
			{
				return _VariousInfo0;
			}
			set
			{
				if (value > 255)
				{
					throw new Exception("Maximum possible value for VariousInfo0 is 0xFF");
				}
				_VariousInfo0 = value;
			}
		}

		public uint AckInfomation0
		{
			get
			{
				return _AckInfomation0;
			}
			set
			{
				if (value > 255)
				{
					throw new Exception("Maximum possible value for AckInfomation0 is 0xFF");
				}
				_AckInfomation0 = value;
			}
		}

		public uint Payload1
		{
			get
			{
				return _Payload1;
			}
			set
			{
				_Payload1 = value;
			}
		}

		public uint FirstClock1
		{
			get
			{
				return _FirstClock1;
			}
			set
			{
				_FirstClock1 = value;
			}
		}

		public uint LastClock1
		{
			get
			{
				return _LastClock1;
			}
			set
			{
				_LastClock1 = value;
			}
		}

		public uint RetransmissionCount1
		{
			get
			{
				return _RetransmissionCount1;
			}
			set
			{
				if (value > 255)
				{
					throw new Exception("Maximum possible value for RetransmissionCount1 is 0xFF");
				}
				_RetransmissionCount1 = value;
			}
		}

		public uint VariousInfo1
		{
			get
			{
				return _VariousInfo1;
			}
			set
			{
				if (value > 255)
				{
					throw new Exception("Maximum possible value for VariousInfo1 is 0xFF");
				}
				_VariousInfo1 = value;
			}
		}

		public uint AckInfomation1
		{
			get
			{
				return _AckInfomation1;
			}
			set
			{
				if (value > 255)
				{
					throw new Exception("Maximum possible value for AckInfomation1 is 0xFF");
				}
				_AckInfomation1 = value;
			}
		}

		public uint Payload2
		{
			get
			{
				return _Payload2;
			}
			set
			{
				_Payload2 = value;
			}
		}

		public uint FirstClock2
		{
			get
			{
				return _FirstClock2;
			}
			set
			{
				_FirstClock2 = value;
			}
		}

		public uint LastClock2
		{
			get
			{
				return _LastClock2;
			}
			set
			{
				_LastClock2 = value;
			}
		}

		public uint RetransmissionCount2
		{
			get
			{
				return _RetransmissionCount2;
			}
			set
			{
				if (value > 255)
				{
					throw new Exception("Maximum possible value for RetransmissionCount2 is 0xFF");
				}
				_RetransmissionCount2 = value;
			}
		}

		public uint VariousInfo2
		{
			get
			{
				return _VariousInfo2;
			}
			set
			{
				if (value > 255)
				{
					throw new Exception("Maximum possible value for VariousInfo2 is 0xFF");
				}
				_VariousInfo2 = value;
			}
		}

		public uint AckInfomation2
		{
			get
			{
				return _AckInfomation2;
			}
			set
			{
				if (value > 255)
				{
					throw new Exception("Maximum possible value for AckInfomation2 is 0xFF");
				}
				_AckInfomation2 = value;
			}
		}

		public uint Payload3
		{
			get
			{
				return _Payload3;
			}
			set
			{
				_Payload3 = value;
			}
		}

		public uint FirstClock3
		{
			get
			{
				return _FirstClock3;
			}
			set
			{
				_FirstClock3 = value;
			}
		}

		public uint LastClock3
		{
			get
			{
				return _LastClock3;
			}
			set
			{
				_LastClock3 = value;
			}
		}

		public uint RetransmissionCount3
		{
			get
			{
				return _RetransmissionCount3;
			}
			set
			{
				if (value > 255)
				{
					throw new Exception("Maximum possible value for RetransmissionCount3 is 0xFF");
				}
				_RetransmissionCount3 = value;
			}
		}

		public uint VariousInfo3
		{
			get
			{
				return _VariousInfo3;
			}
			set
			{
				if (value > 255)
				{
					throw new Exception("Maximum possible value for VariousInfo3 is 0xFF");
				}
				_VariousInfo3 = value;
			}
		}

		public uint AckInfomation3
		{
			get
			{
				return _AckInfomation3;
			}
			set
			{
				if (value > 255)
				{
					throw new Exception("Maximum possible value for AckInfomation3 is 0xFF");
				}
				_AckInfomation3 = value;
			}
		}

		public VariousInfo0EnumCollection GetVariousInfo0AsVariousInfo0EnumCollection()
		{
			return VariousInfo0Info.ValueToVariousInfo0(_VariousInfo0);
		}

		public void SetVariousInfo0AsVariousInfo0EnumCollection(VariousInfo0EnumCollection enumCollection)
		{
			VariousInfo0 = VariousInfo0Info.VariousInfo0ToValue(enumCollection);
		}

		public AckInfomation0EnumCollection GetAckInfomation0AsAckInfomation0EnumCollection()
		{
			return AckInfomation0Info.ValueToAckInfomation0(_AckInfomation0);
		}

		public void SetAckInfomation0AsAckInfomation0EnumCollection(AckInfomation0EnumCollection enumCollection)
		{
			AckInfomation0 = AckInfomation0Info.AckInfomation0ToValue(enumCollection);
		}

		public VariousInfo1EnumCollection GetVariousInfo1AsVariousInfo1EnumCollection()
		{
			return VariousInfo1Info.ValueToVariousInfo1(_VariousInfo1);
		}

		public void SetVariousInfo1AsVariousInfo1EnumCollection(VariousInfo1EnumCollection enumCollection)
		{
			VariousInfo1 = VariousInfo1Info.VariousInfo1ToValue(enumCollection);
		}

		public AckInfomation1EnumCollection GetAckInfomation1AsAckInfomation1EnumCollection()
		{
			return AckInfomation1Info.ValueToAckInfomation1(_AckInfomation1);
		}

		public void SetAckInfomation1AsAckInfomation1EnumCollection(AckInfomation1EnumCollection enumCollection)
		{
			AckInfomation1 = AckInfomation1Info.AckInfomation1ToValue(enumCollection);
		}

		public VariousInfo2EnumCollection GetVariousInfo2AsVariousInfo2EnumCollection()
		{
			return VariousInfo2Info.ValueToVariousInfo2(_VariousInfo2);
		}

		public void SetVariousInfo2AsVariousInfo2EnumCollection(VariousInfo2EnumCollection enumCollection)
		{
			VariousInfo2 = VariousInfo2Info.VariousInfo2ToValue(enumCollection);
		}

		public AckInfomation2EnumCollection GetAckInfomation2AsAckInfomation2EnumCollection()
		{
			return AckInfomation2Info.ValueToAckInfomation2(_AckInfomation2);
		}

		public void SetAckInfomation2AsAckInfomation2EnumCollection(AckInfomation2EnumCollection enumCollection)
		{
			AckInfomation2 = AckInfomation2Info.AckInfomation2ToValue(enumCollection);
		}

		public VariousInfo3EnumCollection GetVariousInfo3AsVariousInfo3EnumCollection()
		{
			return VariousInfo3Info.ValueToVariousInfo3(_VariousInfo3);
		}

		public void SetVariousInfo3AsVariousInfo3EnumCollection(VariousInfo3EnumCollection enumCollection)
		{
			VariousInfo3 = VariousInfo3Info.VariousInfo3ToValue(enumCollection);
		}

		public AckInfomation3EnumCollection GetAckInfomation3AsAckInfomation3EnumCollection()
		{
			return AckInfomation3Info.ValueToAckInfomation3(_AckInfomation3);
		}

		public void SetAckInfomation3AsAckInfomation3EnumCollection(AckInfomation3EnumCollection enumCollection)
		{
			AckInfomation3 = AckInfomation3Info.AckInfomation3ToValue(enumCollection);
		}
	}

	private const uint _EventCode = 255u;

	private Type[] expectedResponseTypes = new Type[0];

	private PacketInfoBase info;

	private uint _PayloadLength;

	public UserFieldsWrapper _UserFields = new UserFieldsWrapper();

	public override PacketType Type => PacketType.Notification;

	public override Type[] ExpectedResponseTypes => expectedResponseTypes;

	public override PacketInfoBase Info
	{
		get
		{
			if (info == null)
			{
				info = new DbfwLmpDebugInfoInfo(this);
			}
			return info;
		}
	}

	public uint EventCode => 255u;

	public uint PayloadLength
	{
		get
		{
			ToBitString();
			return _PayloadLength;
		}
	}

	public UserFieldsWrapper UserFields => _UserFields;

	protected override bool FromBitBuilder(ref BitBuilder bitBuilder)
	{
		if (bitBuilder.RemoveBitsAsUint(8) != EventCode)
		{
			return false;
		}
		_PayloadLength = bitBuilder.RemoveBitsAsUint(8);
		int numberOfBits = bitBuilder.GetNumberOfBits();
		if (numberOfBits > _PayloadLength * 8 + 7)
		{
			return false;
		}
		if (numberOfBits < _PayloadLength * 8)
		{
			return false;
		}
		if (bitBuilder.RemoveBitsAsUint(8) != UserFields.DbfwEventCode)
		{
			return false;
		}
		if (bitBuilder.RemoveBitsAsUint(8) != UserFields.SubEventCode)
		{
			return false;
		}
		UserFields.Payload0 = bitBuilder.RemoveBitsAsUintLittleEndian(32);
		UserFields.FirstClock0 = bitBuilder.RemoveBitsAsUintLittleEndian(32);
		UserFields.LastClock0 = bitBuilder.RemoveBitsAsUintLittleEndian(32);
		UserFields.RetransmissionCount0 = bitBuilder.RemoveBitsAsUint(8);
		UserFields.VariousInfo0 = bitBuilder.RemoveBitsAsUint(8);
		UserFields.AckInfomation0 = bitBuilder.RemoveBitsAsUint(8);
		UserFields.Payload1 = bitBuilder.RemoveBitsAsUintLittleEndian(32);
		UserFields.FirstClock1 = bitBuilder.RemoveBitsAsUintLittleEndian(32);
		UserFields.LastClock1 = bitBuilder.RemoveBitsAsUintLittleEndian(32);
		UserFields.RetransmissionCount1 = bitBuilder.RemoveBitsAsUint(8);
		UserFields.VariousInfo1 = bitBuilder.RemoveBitsAsUint(8);
		UserFields.AckInfomation1 = bitBuilder.RemoveBitsAsUint(8);
		UserFields.Payload2 = bitBuilder.RemoveBitsAsUintLittleEndian(32);
		UserFields.FirstClock2 = bitBuilder.RemoveBitsAsUintLittleEndian(32);
		UserFields.LastClock2 = bitBuilder.RemoveBitsAsUintLittleEndian(32);
		UserFields.RetransmissionCount2 = bitBuilder.RemoveBitsAsUint(8);
		UserFields.VariousInfo2 = bitBuilder.RemoveBitsAsUint(8);
		UserFields.AckInfomation2 = bitBuilder.RemoveBitsAsUint(8);
		UserFields.Payload3 = bitBuilder.RemoveBitsAsUintLittleEndian(32);
		UserFields.FirstClock3 = bitBuilder.RemoveBitsAsUintLittleEndian(32);
		UserFields.LastClock3 = bitBuilder.RemoveBitsAsUintLittleEndian(32);
		UserFields.RetransmissionCount3 = bitBuilder.RemoveBitsAsUint(8);
		UserFields.VariousInfo3 = bitBuilder.RemoveBitsAsUint(8);
		UserFields.AckInfomation3 = bitBuilder.RemoveBitsAsUint(8);
		if (bitBuilder.GetNumberOfBits() > 7)
		{
			return false;
		}
		return true;
	}

	public override string ToBitString()
	{
		BitBuilder bitBuilder = new BitBuilder();
		bitBuilder.AddBitsAsUint(EventCode, 8);
		int numberOfBits = bitBuilder.GetNumberOfBits();
		bitBuilder.AddBitsAsUint(0u, 8);
		bitBuilder.AddBitsAsUint(UserFields.DbfwEventCode, 8);
		bitBuilder.AddBitsAsUint(UserFields.SubEventCode, 8);
		bitBuilder.AddBitsAsUintLittleEndian(UserFields.Payload0, 32);
		bitBuilder.AddBitsAsUintLittleEndian(UserFields.FirstClock0, 32);
		bitBuilder.AddBitsAsUintLittleEndian(UserFields.LastClock0, 32);
		bitBuilder.AddBitsAsUint(UserFields.RetransmissionCount0, 8);
		bitBuilder.AddBitsAsUint(UserFields.VariousInfo0, 8);
		bitBuilder.AddBitsAsUint(UserFields.AckInfomation0, 8);
		bitBuilder.AddBitsAsUintLittleEndian(UserFields.Payload1, 32);
		bitBuilder.AddBitsAsUintLittleEndian(UserFields.FirstClock1, 32);
		bitBuilder.AddBitsAsUintLittleEndian(UserFields.LastClock1, 32);
		bitBuilder.AddBitsAsUint(UserFields.RetransmissionCount1, 8);
		bitBuilder.AddBitsAsUint(UserFields.VariousInfo1, 8);
		bitBuilder.AddBitsAsUint(UserFields.AckInfomation1, 8);
		bitBuilder.AddBitsAsUintLittleEndian(UserFields.Payload2, 32);
		bitBuilder.AddBitsAsUintLittleEndian(UserFields.FirstClock2, 32);
		bitBuilder.AddBitsAsUintLittleEndian(UserFields.LastClock2, 32);
		bitBuilder.AddBitsAsUint(UserFields.RetransmissionCount2, 8);
		bitBuilder.AddBitsAsUint(UserFields.VariousInfo2, 8);
		bitBuilder.AddBitsAsUint(UserFields.AckInfomation2, 8);
		bitBuilder.AddBitsAsUintLittleEndian(UserFields.Payload3, 32);
		bitBuilder.AddBitsAsUintLittleEndian(UserFields.FirstClock3, 32);
		bitBuilder.AddBitsAsUintLittleEndian(UserFields.LastClock3, 32);
		bitBuilder.AddBitsAsUint(UserFields.RetransmissionCount3, 8);
		bitBuilder.AddBitsAsUint(UserFields.VariousInfo3, 8);
		bitBuilder.AddBitsAsUint(UserFields.AckInfomation3, 8);
		_PayloadLength = (uint)((bitBuilder.GetNumberOfBits() - numberOfBits - 8) / 8);
		if ((bitBuilder.GetNumberOfBits() - numberOfBits - 8) % 8 != 0)
		{
			_PayloadLength++;
		}
		bitBuilder.ChangeBitsAsUint(numberOfBits, _PayloadLength, 8);
		return bitBuilder.ToString();
	}
}
