diff --git a/CHANGELOG.md b/CHANGELOG.md new file mode 100644 --- /dev/null +++ b/CHANGELOG.md @@ -0,0 +1,6 @@ +# Revision history for libasterix + +## 0.11.0 -- 2026-04-22 + +* Initial version. + diff --git a/LICENSE b/LICENSE new file mode 100644 --- /dev/null +++ b/LICENSE @@ -0,0 +1,29 @@ +Copyright (c) 2024, Zoran Bošnjak + + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + + * Redistributions of source code must retain the above copyright + notice, this list of conditions and the following disclaimer. + + * Redistributions in binary form must reproduce the above + copyright notice, this list of conditions and the following + disclaimer in the documentation and/or other materials provided + with the distribution. + + * Neither the name of the copyright holder nor the names of its + contributors may be used to endorse or promote products derived + from this software without specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. diff --git a/README.md b/README.md new file mode 100644 --- /dev/null +++ b/README.md @@ -0,0 +1,1581 @@ +# Asterix data processing library for haskell + +Features: + +- pure haskell implementation +- asterix data parsing/decoding from bytes +- asterix data encoding/unparsing to bytes +- precise conversion functions for physical quantities +- support for many asterix categories and editions +- support for Reserved Expansion Fields (REF) +- support for Random Field Sequencing (RFS) +- support for categories with multiple UAPs, eg. cat001 +- support for context dependent items, eg. I062/380/IAS +- support for strict or partial record parsing, to be used + with so called blocking or non-blocking asterix categories +- support to encode zero, one or more records in a datablock +- type annotations for static type checking, + including subitem access by name + +## Asterix encoding and decoding example + +```haskell +-- | file: readme-samples/example0.hs +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE LambdaCase #-} + +import Data.Maybe +import Data.ByteString (ByteString) +import Asterix.Coding +import Asterix.Generated as Gen + +assert :: Bool -> IO () +assert True = pure () +assert False = error "Assertion error" + +-- Select particular asterix categories and editions +type Cat034 = Gen.Cat_034_1_29 +type Cat048 = Gen.Cat_048_1_32 + +type TSacSic = SameType '[ Cat034 ~> "010", Cat048 ~> "010"] + +-- Example messages for this application +data Token + = NorthMarker + | SectorCrossing Double -- Azimuth + | Plot Double Double String -- Rho, Theta, SSR + deriving (Eq, Show) + +-- example message to be encoded +txMessage :: [Token] +txMessage = + [ NorthMarker + , SectorCrossing 0.0 + , Plot 10.0 45.0 "7777" + , SectorCrossing 45.0 + ] + +sacSic :: NonSpare TSacSic +sacSic = group (item @"SAC" 1 *: item @"SIC" 2 *: nil) + +-- encode token to datablock +encode :: Token -> SBuilder +encode = \case + NorthMarker -> + let db :: Datablock (DatablockOf Cat034) = datablock (r *: nil) + r = record + ( item @"000" 1 -- North marker message + *: item @"010" sacSic + *: nil ) + in unparse db + SectorCrossing azimuth -> + let db :: Datablock (DatablockOf Cat034) = datablock (r *: nil) + r = record + ( item @"000" 2 -- Sector crossing message + *: item @"010" sacSic + *: item @"020" (quantity @"°" (Quantity azimuth)) + *: nil ) + in unparse db + Plot rho theta ssr -> + let db :: Datablock (DatablockOf Cat048) = datablock (r *: nil) + r = record + ( item @"010" sacSic + *: item @"040" ( group + ( item @"RHO" ( quantity @"NM" (Quantity rho)) + *: item @"THETA" ( quantity @"°" (Quantity theta)) + *: nil )) + *: item @"070" ( group (0 *: 0 *: 0 *: 0 + *: item @"MODE3A" (string ssr) + *: nil)) + *: nil ) + in unparse db + +-- decode bytes to message list +decode :: ByteString -> [Token] +decode rxBytes = fromRight $ do + rawDatablocks <- parseRawDatablocks rxBytes + tokens <- mapM go rawDatablocks + pure $ mconcat tokens + where + fromRight = \case + Left (ParsingError e) -> error (show e) + Right val -> val + + go :: RawDatablock -> Either ParsingError [Token] + go rawDb = case rawDatablockCategory rawDb of + 34 -> do + let act = parseRecords (schema @(RecordOf Cat034) Proxy) + records <- fmap Record <$> parse @StrictParsing act (getRawRecords rawDb) + pure (mapMaybe handleCat034 records) + 48 -> do + let act = parseRecords (schema @(RecordOf Cat048) Proxy) + records <- fmap Record <$> parse @StrictParsing act (getRawRecords rawDb) + pure (mapMaybe handleCat048 records) + _ -> pure [] + + handleCat034 :: Record (RecordOf Cat034) -> Maybe Token + handleCat034 rec = case asUint @Int i000 of + 1 -> Just NorthMarker + 2 -> Just $ SectorCrossing (unQuantity $ asQuantity @"°" i020) + _ -> Nothing + where + i000 = fromMaybe (error "missing item") (getItem @"000" rec) + i020 = fromMaybe (error "missing item") (getItem @"020" rec) + + handleCat048 :: Record (RecordOf Cat048) -> Maybe Token + handleCat048 rec = Just $ Plot rho theta ssr where + i040 = fromMaybe (error "missing item") (getItem @"040" rec) + rho = unQuantity $ asQuantity @"NM" $ getItem @"RHO" i040 + theta = unQuantity $ asQuantity @"°" $ getItem @"THETA" i040 + i070 = fromMaybe (error "missing item") (getItem @"070" rec) + ssr = asString $ getItem @"MODE3A" i070 + +expected :: ByteString +expected = fromJust $ unhexlify "220007c0010201220008d00102020030000c9801020a0020000fff220008d001020220" + +main :: IO () +main = do + -- encode message to bytes + print ("sending message: " <> show txMessage) + let datablocks = fmap encode txMessage + tx = toByteString $ mconcat datablocks + putStrLn ("bytes on the wire: " <> hexlify tx) + assert (tx == expected) + + -- decode bytes back to message, expect the same message + let rx = tx + rxMessage = decode rx + assert (rxMessage == txMessage) +``` + +## Installation and library import + +This tutorial assumes importing complete `asterix` module into the current +namespace. In practice however only the required objects could be imported +or the modules might be imported qualified. + +```haskell +import Asterix.Coding +import Asterix.Generated as Gen +``` + +## Asterix object hierarchy and terminology + +This library is built aroud the following concepts: + +- **Datagram** is a raw binary data as received for example from UDP socket. +- **RawDatablock** is asterix datablock in the form `cat|length|data` with + correct byte size. A datagram can contain multiple datablocks. + In some cases it might be sufficient to work with raw datablocks, for + example "asterix category filtering". In this case, it is not necessary + to fully parse all asterix records, but is sufficient and faster to + parse only up to the `RawDatablock` level. +- **Datablock/Record** + is a higher level construct, where we have a guarantee that all containing + elements (records, subitems) are semantically correct (asterix is fully + parsed or correctly constructed). +- **Item** is a union of **regular item** or **spare item**, where the + spare item is a wrapper around raw bits (normally zero). +- **Variation** is a union of + `[element, group, extended, repetitive compound]` constructors. + +## Constructing, parsing/unparsing, encoding/decoding + +This library uses term to **construct asterix**, when a +record/datablock/datagram is "constructed" inside the application source code. + +Once the datablock is constructed, it is **unparsed** to bytes, ready to +be sent over the network. Similarly, the term **parsing** is used when we +perform oposite transformation from unstructured bytes to structured +Datablock/Record. This operation can obviously fail at runtime, so some +form of error handling is required inside application. + +The terms **encoding/decoding** are used to denote conversion between +objects from this library to application specific objects, +for example *target reports* or *sector messages* + +``` + application objects (e.g. Sector crossing message) + ^ | + | | decoding / encoding + | v + asterix objects (e.g. Record) + ^ | + | | parsing / unparsing + | v + (bytes) +``` + +## Subitem and content access + +A `Record` contains `Items`, which in turn contains subitems at various +nesting levels. To access a subitem, use `getItem @"itemName"` function. + +The result (if not `Nothing`) can be in turn querried for nested subitems +or converted to required value. + +This is a typical usage: + +```haskell +-- | file: readme-samples/subitems-get.hs +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE LambdaCase #-} + +import Data.Maybe +import Asterix.Coding +import Asterix.Generated as Gen + +type Cat048 = Gen.Cat_048_1_32 + +-- test record +rec048 :: Record (RecordOf Cat048) +rec048 = record ( item @"040" 0 *: item @"070" 0 *: nil) + +main :: IO () +main = do + let i040 = fromJust $ getItem @"040" rec048 + i070 = fromJust $ getItem @"070" rec048 + + -- access subitems + rho :: Double = unQuantity $ asQuantity @"NM" (getItem @"RHO" i040) + theta :: Double = unQuantity $ asQuantity @"°" (getItem @"THETA" i040) + ssr :: String = asString $ getItem @"MODE3A" i070 + print (rho, theta, ssr) +``` + +## Setting subitem + +This library provides `setItem @"itemName" subItem parentItem` and +`maybeSetItem @"itemName" subItem parentItem` functions to manipulate asterix +constructs. For example: + +```haskell +-- | file: readme-samples/subitems-set.hs +{-# LANGUAGE DataKinds #-} + +import Data.Function ((&)) + +import Asterix.Coding +import Asterix.Generated as Gen + +type Cat048 = Gen.Cat_048_1_32 + +assert :: Bool -> IO () +assert True = pure () +assert False = error "Assertion error" + +main :: IO () +main = do + -- construct compound item + let i120a:: NonSpare (Cat048 ~> "120") + i120a = compound + ( item @"CAL" (group + ( item @"D" 0 + *: spare + *: item @"CAL" 0 + *: nil)) + *: item @"RDS" (repetitive [1,2,3]) + *: nil) + + -- construct empty compound item and add items + let i120b :: NonSpare (Cat048 ~> "120") + i120b = compound nil + & setItem @"CAL" (group + ( item @"D" 0 + *: spare + *: item @"CAL" 0 + *: nil)) + & maybeSetItem @"RDS" (Just (repetitive [1,2,3])) + + -- the result shall be the same + assert (unparse @Bits i120a == unparse i120b) + assert (isEmpty i120b == False) + + -- same scenario is possible on 'Record' too + let recordA :: Record (RecordOf Cat048) + recordA = record + ( item @"010" 0x0102 + *: item @"120" i120a + *: nil) + + let recordB :: Record (RecordOf Cat048) + recordB = record nil + & setItem @"010" 0x0102 + & maybeSetItem @"020" Nothing + & setItem @"120" i120b + assert (unparse @Bits recordA == unparse recordB) +``` + +## Modifying extended subitem + +Extended item contains always-present primary part and optional +extensions and so some subitems might not be present. + +`modifyExtendedSubitemIfPresent @subitemName f item` function provides +necessary checking and if a subitem is present, it applies a modifier function +`f` to the subitem. Otherwises, if the subitem is not present, the function +returns complete item unchanged. + +```haskell +-- | file: readme-samples/modify-extended-subitem.hs +{-# LANGUAGE DataKinds #-} +import Asterix.Coding +import Asterix.Generated as Gen + +type Cat048 = Gen.Cat_048_1_32 + +assert :: Bool -> IO () +assert True = pure () +assert False = error "Assertion error" + +main :: IO () +main = do + -- construct extended item with only the first group present + let i020 :: NonSpare (Cat048 ~> "020") + i020 = extendedGroups (0 *: nil) + + -- "TYP" is part of the first group (present), we are changing it + result1 = modifyExtendedSubitemIfPresent @"TYP" (const 1) i020 + + -- "TST" is part of the second group (not present), + -- so the function call shall have no effect + result2 = modifyExtendedSubitemIfPresent @"TST" (const 1) i020 + + assert $ not (unparse @Bits i020 == unparse result1) + assert (unparse @Bits i020 == unparse result2) +``` + +## Application examples + +### Category filter + +**Example**: Category filter, drop datablocks if category == 1 + +```haskell +-- | file: readme-samples/catflt.hs +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE LambdaCase #-} + +import Control.Monad +import Data.Maybe +import Data.ByteString (ByteString) +import Asterix.Coding + +-- UDP rx test function +receiveFromUdp :: IO ByteString +receiveFromUdp = pure $ fromJust $ unhexlify $ join + [ "01000401" -- cat1 datablock + , "02000402" -- cat2 datablock + ] + +-- UDP tx test function +sendToUdp :: SBuilder -> IO () +sendToUdp = putStrLn . hexlify . toByteString + +main :: IO () +main = do + inputData <- receiveFromUdp + let rawDatablocks = case (parseRawDatablocks inputData) of + Left _ -> error "unable to parse" + Right val -> val + validDatablocks = do + db <- rawDatablocks + guard $ rawDatablockCategory db /= 1 + pure $ unparse @SBuilder db + outputData = mconcat validDatablocks + sendToUdp outputData +``` + +### Rewrite SAC/SIC in item 010 + +**Example**: Asterix filter, rewrite SAC/SIC code. + +```haskell +-- | file: readme-samples/rewrite-sacsic.hs +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE LambdaCase #-} +{-# LANGUAGE MonoLocalBinds #-} + +import GHC.TypeLits +import Data.Maybe +import Data.Either +import Data.ByteString (ByteString) + +import Asterix.Coding +import Asterix.Generated as Gen + +-- categories/editions of interest +type Cat048 = Gen.Cat_048_1_31 +type Cat062 = Gen.Cat_062_1_19 +type Cat063 = Gen.Cat_063_1_6 + +-- All of the following types have the same item "010" +type TSacSic = SameType '[ Cat048 ~> "010", Cat062 ~> "010", Cat063 ~> "010"] + +handleDatablock :: forall cat. + ( Schema (RecordOf cat) VRecord + , SetItem "010" (Record (RecordOf cat)) (NonSpare TSacSic) + , KnownNat (CategoryOf cat) + ) => Proxy cat -> NonSpare TSacSic -> ByteString -> SBuilder +handleDatablock _p sacSic bs = + let act = parseRecords (schema @(RecordOf cat) Proxy) + records :: [Record (RecordOf cat)] + records = case parse @StrictParsing act bs of + Left e -> error (show e) + Right lst -> (setItem @"010" sacSic) . Record <$> lst + urecords = fmap unRecord records + in datablockBuilder (natVal (Proxy @(CategoryOf cat))) urecords + +handleRawDatablock :: NonSpare TSacSic -> RawDatablock -> SBuilder +handleRawDatablock sacSic rawDb = case rawDatablockCategory rawDb of + 48 -> handleDatablock @Cat048 Proxy sacSic rawRecords + 62 -> handleDatablock @Cat062 Proxy sacSic rawRecords + 63 -> handleDatablock @Cat063 Proxy sacSic rawRecords + cat -> error ("unsupported category: " <> show cat) + where + rawRecords = getRawRecords rawDb + +rewriteSacSic :: NonSpare TSacSic -> ByteString -> SBuilder +rewriteSacSic sacSic bs = output where + rawDatablocks = fromRight (error "unexpected") $ parseRawDatablocks bs + result = fmap (handleRawDatablock sacSic) rawDatablocks + output = mconcat result + +-- Dummy rx function (generate valid asterix datagram). +readBytesFromTheNetwork :: IO ByteString +readBytesFromTheNetwork = do + let rec :: Record (RecordOf Cat048) + rec = record + ( item @"010" 0 + *: item @"040" 0 + *: nil) + db1, db2 :: Datablock (DatablockOf Cat048) + db1 = datablock (rec *: rec *: nil) + db2 = datablock (rec *: nil) + pure $ toByteString (unparse @SBuilder db1 <> unparse @SBuilder db2) + +-- Dummy tx function +txBytesToTheNetwork :: SBuilder -> IO () +txBytesToTheNetwork = putStrLn . hexlify . toByteString + +main :: IO () +main = do + sInput <- readBytesFromTheNetwork + let newSacSic :: NonSpare TSacSic + newSacSic = group (1 *: 2 *: nil) + sOutput = rewriteSacSic newSacSic sInput + expected = fromJust $ unhexlify $ "300011900102000000009001020000000030000a90010200000000" + txBytesToTheNetwork sOutput + case expected == (toByteString sOutput) of + True -> print "OK" + False -> error "unexpected output" +``` + +### Spare bits + +Some bits are defined as *Spare*, which are normally set to `0`. +With this library: + +- A user is able set spare bits to any value, including abusing spare bits + to contain non-zero value. +- When parsing data, tolerate spare bits to contain any value. It is up + to the application to check the spare bits if desired. + +Multiple spare bit groups can be defined on a single item. +`getSpares` function returns the actual values of all spare bit groups. + +**Example** + +```haskell +-- | file: readme-samples/spares.hs +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE LambdaCase #-} +{-# LANGUAGE MonoLocalBinds #-} + +import Data.Maybe + +import Asterix.Coding +import Asterix.Generated as Gen + +-- I062/120 contain single group of spare bits +type Spec = Gen.Cat_062_1_20 + +assert :: Bool -> IO () +assert True = pure () +assert False = error "Assertion error" + +main :: IO () +main = do + -- create regular record with spare bits set to '0' + let rec1 :: Record (RecordOf Spec) + rec1 = record (item @"120" (group (0 *: item @"MODE2" 0x1234 *: nil)) + *: nil) + i120a = fromJust $ getItem @"120" rec1 + assert ((bitsToNum <$> getSpares i120a) == [0::Int]) + + -- create record, abuse spare bits, set to '0xf' + let rec2 :: Record (RecordOf Spec) + rec2 = record (item @"120" (group (0xf *: item @"MODE2" 0x1234 *: nil)) + *: nil) + i120b = fromJust $ getItem @"120" rec2 + assert ((bitsToNum <$> getSpares i120b) == [0xf::Int]) +``` + +## Reserved expansion (RE) fields + +This library supports working with expansion fields. From the `Record` +prespective, the `RE` item contains raw bytes, without any structure, similar +to how a datablock contains raw bytes without a structure. Parsing raw +datablocks and parsing records are 2 separate steps. Similarly, parsing `RE` +out of the record would be a third step. Once parsed, the `RE` item gets it's +structure, and it's possible to access it's subitems, similar to a regular +record/subitem situation. + +When constructing a record with the `RE` item, a user must first +construct the `RE` item itself, unparse it to bytes and insert bytes +as a value of the `RE` item of a record. + +A reason for this separate stage approach is that a category and expansion +specification can remain separate to one another. In addition, a user has +a possiblity to explicitly select both editions individually. + +This example demonstrates required steps for constructing and parsing: + +```haskell +-- | file: readme-samples/ref.hs +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE LambdaCase #-} + +import Data.Either +import Data.Maybe +import Asterix.Coding +import Asterix.Generated as Gen + +type Spec = Gen.Cat_062_1_20 +type Ref = Gen.Ref_062_1_3 + +assert :: Bool -> IO () +assert True = pure () +assert False = error "Assertion error" + +-- create 'RE' subitem +ref :: Expansion (ExpansionOf Ref) +ref = expansion + ( item @"CST" (repetitive [0]) + *: item @"CSN" (repetitive [1, 2]) + *: item @"V3" (compound + ( item @"PS3" 0 + *: nil )) + *: nil ) + +-- create record, insert 'RE' subitem +rec :: Record (RecordOf Spec) +rec = record + ( item @"010" (group (item @"SAC" 1 *: item @"SIC" 2 *: nil)) + *: item @"RE" (explicit ref) + *: nil ) + +db :: Datablock (DatablockOf Spec) +db = datablock (rec *: nil) + +main :: IO () +main = do + let s = unparse @SBuilder db + bs = toByteString s + expected = fromJust $ unhexlify $ "3e001b8101010104010211c8010000000000020000010000028000" + assert (bs == expected) + + -- first stage, parse to the record + let rawDatablocks = fromRight (error "unexpected") (parseRawDatablocks bs) + assert (length rawDatablocks == 1) -- expecting 1 datablock + let rawDatablock = rawDatablocks !! 0 + act = parseRecords (schema @(RecordOf Spec) Proxy) + result1 = fromRight (error "unexpected") + (parse @StrictParsing act (getRawRecords rawDatablock)) + assert (length result1 == 1) -- expecting one record + let rec2 :: Record (RecordOf Spec) + rec2 = Record (result1 !! 0) + + -- get 'RE' subitem, + let reSubitem = getVariation $ fromJust $ getItem @"RE" rec2 + reBytes = toByteString $ bitsToBuilder $ getExplicitData reSubitem + + -- second stage: parse 'RE' structure + let act2 = parseExpansion (schema @(ExpansionOf Ref) Proxy) + refReadback :: Expansion (ExpansionOf Ref) + refReadback = Expansion (fromRight (error "unexpected") + (parse @StrictParsing act2 reBytes)) + + -- expecting the same 'ref' as the original + assert (unparse @Bits refReadback == unparse ref) + + -- we have a structure back and we can extract the values + let iCsn = fromJust (getItem @"CSN" refReadback) + lst = getRepetitiveItems $ getVariation iCsn + assert (length lst == 2) + assert (asUint @Int (lst !! 0) == 1) + assert (asUint @Int (lst !! 1) == 2) + + putStrLn "OK" +``` + +## Generic asterix processing + +*Generic processing* in this context means working with asterix data where +the subitem names and types are determined at runtime. That is: the explicit +subitem names are never mentioned in the application source code. + +This is in contrast to *application specific processing*, where we are +explicit about subitems, for example `["010", "SAC"]`. + +**Example**: Show raw content of all toplevel items of each record + +```haskell +-- | file: readme-samples/generic-names.hs +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE LambdaCase #-} + +import Control.Monad +import Data.Word +import Data.Maybe +import Data.Either +import Data.Map as Map +import Data.ByteString (ByteString) + +import Asterix.Coding +import Asterix.Generated as Gen + +specs :: Map Word8 VRecord +specs = Map.fromList + [ (48, schema @(RecordOf Cat_048_1_31) Proxy) + , (62, schema @(RecordOf Cat_062_1_19) Proxy) + , (63, schema @(RecordOf Cat_063_1_6) Proxy) + -- , ... + ] + +-- some test input bytes +s :: ByteString +s = mconcat $ fmap (fromJust . unhexlify) + [ "3e00a5254327d835a95a0d0a2baf256af940e8a8d0caa1a594e1e525f2e32bc0448b" + , "0e34c0b6211b5847038319d1b88d714b990a6e061589a414209d2e1d00ba5602248e" + , "64092c2a0410138b2c030621c2043080fe06182ee40d2fa51078192cce70e9af5435" + , "aeb2e3c74efc7107052ce9a0a721290cb5b2b566137911b5315fa412250031b95579" + , "03ed2ef47142ed8a79165c82fb803c0e38c7f7d641c1a4a77740960737" + ] + + +handleNonspare :: Word8 -> (GUapItem ValueLevel, Maybe (RecordItem UNonSpare)) + -> IO () +handleNonspare cat = \case + (GUapItem (GNonSpare name _title _rv), Just (RecordItem nsp)) -> do + print (cat, name, debugBits $ unparse @Bits nsp) + -- depending on the application, we might want to display + -- deep subitems, which is possible by examining 'nsp' object + _ -> pure () + +main :: IO () +main = do + let rawDatablocks = fromRight (error "unexpected") $ parseRawDatablocks s + forM_ rawDatablocks $ \db -> do + let cat = rawDatablockCategory db + case Map.lookup cat specs of + Nothing -> print ("unsupported category", cat) + Just (GRecord sch) -> do + let act = parseRecords (GRecord sch) + records = fromRight (error "unexpected") + (parse @StrictParsing act (getRawRecords db)) + forM_ records $ \rec -> do + mapM_ (handleNonspare cat) (zip sch $ uRecItems rec) +``` + +**Example**: Generate dummy single record datablock with all fixed items set to zero + +```haskell +-- | file: readme-samples/generic-zero.hs +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE LambdaCase #-} + +import Data.Maybe +import Asterix.Coding +import Asterix.Generated as Gen + +assert :: Bool -> IO () +assert True = pure () +assert False = error "Assertion error" + +-- we could even randomly select a category/edition from the 'manifest', +-- but for simplicity just use a particular spec's schema +schAsterix :: VAsterix +schAsterix = schema @Cat_062_1_20 Proxy + +schCat :: Int +schCat = case schAsterix of + GAsterixBasic cat _ed _uap -> cat + GAsterixExpansion cat _ed _exp -> cat + +schRecord :: VRecord +schRecord = case schAsterix of + GAsterixBasic _cat _ed (GUap r) -> r + _ -> error "unexpected" + +schItems :: [VUapItem] +schItems = + let GRecord lst = schRecord + in lst + +rec :: URecord +rec = URecord bld items + where + goVar :: VVariation -> Maybe UVariation + goVar = \case + GElement o n _cont -> Just $ UElement $ integerToBits o n 0 + GGroup _o lst -> UGroup <$> mapM goItem lst + _ -> Nothing -- skip for this test + + goItem :: VItem -> Maybe UItem + goItem = \case + GSpare o n -> Just $ USpare $ integerToBits o n 0 + GItem nsp -> UItem <$> goNsp nsp + + goRv :: VRule VVariation -> Maybe URuleVar + goRv = \case + GContextFree var -> URuleVar <$> goVar var + GDependent _lst1 var _lst2 -> URuleVar <$> goVar var + + goNsp :: VNonSpare -> Maybe UNonSpare + goNsp (GNonSpare _name _title rv) = UNonSpare <$> goRv rv + + f :: VUapItem -> Maybe (RecordItem UNonSpare) + f = \case + GUapItem nsp -> RecordItem <$> goNsp nsp + _ -> Nothing + items = fmap f schItems + bld = rebuildRecord items + +db :: UDatablock +db = UDatablock bld records + where + records = [(Nothing, rec)] + bld = datablockBuilder schCat (fmap snd records) + +main :: IO () +main = do + let expected = fromJust $ unhexlify $ "3e0038bfe9bd5000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" + result = toByteString $ unparse @SBuilder db + putStrLn $ hexlify result + assert (result == expected) +``` + +### Library manifest + +This library defines a `manifest` structure in the form: + +```haskell +manifest :: [GAsterix 'ValueLevel] +manifest = + [ schema @Cat_001_1_2 Proxy + , schema @Cat_001_1_3 Proxy + , schema @Cat_001_1_4 Proxy + -- ... + ] +``` + +This structure can be used to extract *latest* editions for each defined +category, for example: + +```haskell +-- | file: readme-samples/generic-latest.hs +import Control.Monad +import Data.List (sort) +import Data.Map as Map +import Data.Map.Merge.Lazy as Map +import Asterix.Schema +import Asterix.Generated as Gen + +latest :: Map VInt VEdition +latest = Prelude.foldr f mempty Gen.manifest + where + f :: VAsterix -> Map VInt VEdition -> Map VInt VEdition + f sch acc = case sch of + GAsterixBasic cat ed _uap -> Map.merge + preserveMissing + preserveMissing + (zipWithMatched (\_key ed1 ed2 -> max ed1 ed2)) + acc + (Map.singleton cat ed) + GAsterixExpansion _cat _ed _exp -> acc + +main :: IO () +main = forM_ (sort (Map.keys latest)) $ \cat -> do + print (cat, latest Map.! cat) +``` + +Alternatively, a prefered way is to be explicit about each edition, +for example: + +```haskell +-- | file: readme-samples/generic-editon.hs +import Data.List (sort) +import Data.Map as Map +import Asterix.Schema +import Asterix.Generated as Gen + +specs :: Map VInt VAsterix +specs = Map.fromList + [ (48, schema @Cat_048_1_31 Proxy) + , (62, schema @Cat_062_1_19 Proxy) + , (63, schema @Cat_063_1_6 Proxy) + -- , ... + ] +main :: IO () +main = mapM_ print (sort $ Map.keys specs) +``` + +## Error handling + +Some operation (eg. parsing) can fail on unexpected input. In such case, +this library returns `ParsingError`. + +```haskell +parseDataBlocks :: ByteString -> [RawDatablock] +parseDataBlocks s = case parseRawDatablocks s of + Left (ParsingError _err) -> [] -- decide what to do in case of error + Right val -> val +``` + +For clarity, the error handling part is skipped in some parts of this tutorial. + +## Miscellaneous project and source code remarks + +A core part of this project is the `Asterix.Generated` module, where +all important aspect of asterix data format is captured as haskell types. +Having asterix specifications defined as types is important, to be able to +catch errors at compile time (e.g. compiler can detect access attempt +into unspecified item). + +The specifications are available at runtime too. For example, +we want to be able to generate random record of some category/edition or +generically convert binary asterix data to `json`. So, each type level +specification is converted into a value level counterpart. +The `Asterix.Schema` provides the necessary conversion function `schema` +from types to term: + +```haskell +valueLevel = schema @typeLevel Proxy +``` + +### Schema naming conventions + +Naming conventions for types describing asterix schema: + +``` +GType u - generic data structure, parametrized over 'usecase', + to be used on a type and value level +TType - type TType = GType 'TypeLevel (all generated types) +VType - type VType = GType 'ValueLevel (TType converted to value level) +``` + +See `Asterix.Schema` module for details. + +### Data naming conventions + +For types containing actual asterix data. + +``` +UType - Untyped value, for example UItem, UVariation, ... +Type t - Typed wrapper around Untyped value: (Item t), (Variation t), ... +``` + +### Constructing + +A simplified syntax is provided to construct asterix objects within the source +code. It's based on processing `HList` of subitems (list of different types). +'HList' constuction is performed with `*:` as `HCons` operator and `nil` as +list termination `HNil`. For example: + +```haskell +-- | file: readme-samples/construct1.hs +{-# LANGUAGE DataKinds #-} + +import Data.Maybe + +import Asterix.Coding +import Asterix.Generated as Gen + +assert :: Bool -> IO () +assert True = pure () +assert False = error "Assertion error" + +db062 :: Datablock (DatablockOf Cat_062_1_21) +db062 = datablock (rec1 *: nil) + where + rec1 = record + ( item @"010" 0x0102 + *: item @"120" ( group + ( spare + *: item @"MODE2" (string "1234") -- octal string + *: nil )) + *: item @"380" ( compound + ( item @"ID" (string "ICAO") -- icao string + *: nil )) + *: item @"070" (quantity @"s" 123.4 ) -- quantity with units + *: nil ) + +main :: IO () +main = do + let sb :: SBuilder = unparse db062 + result = toByteString sb + expected = fromJust $ unhexlify $ "3e0015911101100102003db34024304f820820029c" + assert (result == expected) + putStrLn $ hexlify result +``` + +### Parsing + +Regular asterix parsing with this library is performed in the following stages: +- Parsing datagram (`ByteString` as received on the network) to + `RawDatablocks`. A `RawDatablock` represents input data which is + correctly parsed, according to *asterix datablock cat/length* schema. +- Depending on *asterix category*, each `RawDatablock` can be either + skipped or parsed to the next level, resulting in list of records. +- Once the records are parsed according to a particular UAP schema, + each record is normally wrapped inside typed `Record t`, such that a + content structure is statically known and the subitems can be accessed + by name (at the type level), using type application. + +Parsing is performed using `parse` function, for example: + +```haskell +-- | file: readme-samples/parsing-normal.hs +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE LambdaCase #-} + +import Data.ByteString (ByteString) +import Asterix.Coding +import Asterix.Generated as Gen + +type Cat034 = Gen.Cat_034_1_29 + +db :: Datablock (DatablockOf Cat034) +db = datablock (record (item @"000" 1 *: nil ) *: nil) + +sample :: ByteString +sample = toByteString $ unparse @SBuilder db + +main :: IO () +main = do + let rawDatablocks :: [RawDatablock] + rawDatablocks = case parseRawDatablocks sample of + Left (ParsingError _) -> error "can not parse raw datablocks" + Right val -> val + rawDatablock :: RawDatablock = rawDatablocks !! 0 + rawRecords = case rawDatablockCategory rawDatablock of + 34 -> getRawRecords rawDatablock + _ -> error "unexpected category" + parsingAction = parseRecords (schema @(RecordOf Cat034) Proxy) + records :: [Record (RecordOf Cat034)] + records = case parse @StrictParsing parsingAction rawRecords of + Left (ParsingError _) -> error "can not parse records" + Right lst -> fmap Record lst + record0 = records !! 0 + i000 = case getItem @"000" record0 of + Nothing -> error "Missing item 000" + Just val -> val + + case asUint @Integer i000 of + 1 -> print "OK" + _ -> error "unexpected result" +``` + +In some cases, the parsing result type is not 'a priori' known and the +second stage of parsing becomes more complicated. + +### Unparsing + +`Asterix.Base` module provides `class Unparsing r t` for types that can be +unparsed into target value, such as `Bits` or `SBuilder`. Unparsing into +regular `ByteString` is not efficient (a problem is slow `ByteString` +concatenation) and so the instances are not provided. It is however possible to +(inefficiently) convert from `SBuilder` to `ByteString` if necessary for debug +purposes. + +The target type argument in a typeclass comes first, for simplified type +application when necessary, for example: + +```haskell +instance Unparsing Bits UItem +instance Unparsing Bits (Item t) +instance Unparsing SBuilder (Record t) + +let s1 = unparse @Bits item + s2 = unparse @SBuilder record + +-- explicit type application is not required here +print $ debugBits $ unparse record +``` + +## Rare asterix cases + +### Dependent specifications + +In some rare cases, asterix definitions depend on a value of some other +item(s). In such cases, the asterix processing is more involved. This +dependency manifests itself in two ways: + +- **content dependency**, where a content (interpretation of bits) of some + item depends on the value of some other item(s). For example: + `I062/380/IAS/IAS`, the structure is always 15 bits long, + but the interpretation of bits could be either speed in `NM/s` or `Mach`, + with different scaling factors, depending on the values of a sibling item. +- **variation dependency**, where not only the content, but also a complete + item stucture depends on some other item(s). For example, the structure + of item `I004/120/CC/CPC` depends on 2 other item values. + +This library can handle all structure cases, however it does not automatically +correlate to the values of items that a structure depends on. When creating +records, it is a user responsibility to properly set "other item values" for +a record to be valid. +Similarly, after a record is parsed, a user shall cast a default structure to a +target structure, depending on the other items values. Whenever there is a +dependency, there is also a statically known *default* structure, which is +used during automatic record parsing. + +#### Handling **content dependency** + +This example demonstrates how to work with **content dependency**, +such as `I062/380/IAS`. + +```haskell +-- | file: readme-samples/dep-content.hs +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE LambdaCase #-} + +import Control.Monad +import Data.Maybe +import Data.Either +import Data.ByteString (ByteString) + +import Asterix.Coding +import Asterix.Generated as Gen + +type Spec = Gen.Cat_062_1_20 + +assert :: Bool -> IO () +assert True = pure () +assert False = error "Assertion error" + +-- create records by different methods + +-- set raw value +rec0 :: Record (RecordOf Spec) +rec0 = record + ( item @"380" (compound + ( item @"IAS" (group + ( item @"IM" 0 -- set IM to 0 + *: item @"IAS" 1 -- set IAS to raw value 1 (no unit conversion) + *: nil)) + *: nil)) + *: nil ) + +-- set raw value using default case +rec1 :: Record (RecordOf Spec) +rec1 = record + ( item @"380" (compound + ( item @"IAS" (group + ( item @"IM" 0 -- set IM to 0 + *: item @"IAS" 1 -- same as above + *: nil)) + *: nil)) + *: nil ) + +-- set IAS speed (NM/s) +rec2 :: Record (RecordOf Spec) +rec2 = record + ( item @"380" (compound + ( item @"IAS" (group + ( item @"IM" 0 -- set IM to 0 + -- use case with index 0 (IAS), set IAS to 1.2 NM/s + *: item @"IAS" (quantity @"NM/s" @('Just 0) 1.2) + *: nil)) + *: nil)) + *: nil ) + +-- set Mach speed +rec3 :: Record (RecordOf Spec) +rec3 = record + ( item @"380" (compound + ( item @"IAS" (group + ( item @"IM" 1 -- set IM to 1 (Mach) + -- use case with index 1 (Mach), set IAS to 0.8 Mach + *: item @"IAS" (quantity @"Mach" @('Just 1) 0.8) + *: nil)) + *: nil)) + *: nil ) + +db0 :: Datablock (DatablockOf Spec) +db0 = datablock (rec0 *: rec1 *: rec2 *: rec3 *: nil) + +expected :: ByteString +expected = fromJust $ unhexlify "3e0017011010000101101000010110104ccd0110108320" + +main :: IO () +main = do + assert ((toByteString $ unparse @SBuilder db0) == expected) + + -- parse and interpret data from the example above + let rx = expected + rawDatablocks = fromRight (error "unexpected") (parseRawDatablocks rx) + forM_ rawDatablocks $ \db -> do + assert (rawDatablockCategory db == 62) + let act = parseRecords (schema @(RecordOf Spec) Proxy) + records :: [Record (RecordOf Spec)] + records = fromRight (error "unexpected") + (fmap Record <$> parse @StrictParsing act (getRawRecords db)) + forM_ (zip [0::Int ..] records) $ \(cnt, rec) -> do + let i380 = fromJust $ getItem @"380" rec + iIAS1 = fromJust $ getItem @"IAS" $ getVariation i380 + iIM = getItem @"IM" iIAS1 + iIAS2 = getItem @"IAS" iIAS1 + value :: Double + value = case asUint @Int iIM of + -- this is IAS, convert to 'NM/s', use case with index (0,) + 0 -> unQuantity $ asQuantity @"NM/s" @('Just 0) iIAS2 + -- this is Mach, convert to 'Mach', use case with index (1,) + 1 -> unQuantity $ asQuantity @"Mach" @('Just 1) iIAS2 + _ -> error "unexpected value" + + print ("--- record", cnt, "---") + print ("I062/380/IAS/IM raw value:", asUint @Integer iIM) + print ("I062/380/IAS/IAS raw value:", asUint @Integer iIAS2) + print ("converted value", value) +``` + +#### Handling **variation dependency** + +This example demonstrates how to work with **variation dependency**, +such as `I004/120/CC/CPC`. + +```haskell +-- | file: readme-samples/dep-variation.hs +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE LambdaCase #-} + +import Control.Monad +import Data.Maybe +import Data.Either +import Data.ByteString (ByteString) +import Asterix.Coding +import Asterix.Generated as Gen + +type Spec = Gen.Cat_004_1_13 -- Cat 004, edition 1.13 + +-- Item 'I004/120/CC/CPC' depends on I004/000 and I004/120/CC/TID values +-- Default case is: element3, raw, but there are many other cases. +-- See asterix specification for details. +-- This example handles the following cases: +-- case (5, 1): element 3, table +-- case (9, 2): group (('RAS', element1, table), spare 2) + +assert :: Bool -> IO () +assert True = pure () +assert False = error "Assertion error" + +-- case (0, 0) - invalid combination +rec0 :: Record (RecordOf Spec) +rec0 = record + ( item @"000" 0 -- invalid value + *: item @"120" (compound + ( item @"CC" (group + ( item @"TID" 0 + *: item @"CPC" 0 -- set to raw value 0 + *: item @"CS" 0 + *: nil)) + *: nil)) + *: nil) + +-- case (5, 1) +rec1 :: Record (RecordOf Spec) +rec1 = record + ( item @"000" 5 -- Area Proximity Warning (APW) + *: item @"120" (compound + ( item @"CC" (group + ( item @"TID" 1 + *: item @"CPC" 0 -- set to raw value 0 + *: item @"CS" 0 + *: nil)) + *: nil)) + *: nil) + +-- case (9, 2) +-- get variation structure of case (9, 2) +-- and create object of that structure ('RAS' + spare item) +obj :: Variation (DepRule (Spec ~> "120" ~> "CC" ~> "CPC") '[ 9, 2]) +obj = group (item @"RAS" 1 *: spare *: nil) +rec2 :: Record (RecordOf Spec) +rec2 = record + ( item @"000" 9 -- RIMCAS Arrival / Landing Monitor (ALM) + *: item @"120" (compound + ( item @"CC" (group + ( item @"TID" 2 + *: item @"CPC" (fromInteger $ asUint obj) + *: item @"CS" 0 + *: nil)) + *: nil)) + *: nil) + +db0 :: Datablock (DatablockOf Spec) +db0 = datablock (rec0 *: rec1 *: rec2 *: nil) + +expected :: ByteString +expected = fromJust $ unhexlify "040012412000400041200540104120094028" + +main :: IO () +main = do + assert ((toByteString $ unparse @SBuilder db0) == expected) + + -- parse and interpret data from the example above + let rx = expected + rawDatablocks = fromRight (error "unexpected") (parseRawDatablocks rx) + forM_ rawDatablocks $ \db -> do + assert (rawDatablockCategory db == 4) + let act = parseRecords (schema @(RecordOf Spec) Proxy) + records :: [Record (RecordOf Spec)] + records = fromRight (error "unexpected") + (fmap Record <$> parse @StrictParsing act (getRawRecords db)) + forM_ (zip [0::Int ..] records) $ \(cnt, rec) -> do + print ("--- record", cnt, "---") + let i000 = fromJust $ getItem @"000" rec + i120 = fromJust $ getItem @"120" rec + iCC = fromJust $ getItem @"CC" $ getVariation i120 + iTID = asUint @Int (getItem @"TID" iCC) + iCPC = getItem @"CPC" iCC + _iCS = asUint @Int (getItem @"CS" iCC) + index = (asUint @Int i000, iTID) + value = case index of + (5, 1) -> + let x = asUint @Int iCPC + in Just ("case 5,1 raw " <> show x) + (9, 2) -> + let fromRight' = fromRight (error "unexpected") + varCPC = fromRight' $ getDepVariation @'[ 9, 2] iCPC + ras = asUint @Int (getItem @"RAS" varCPC) + spares = asUint @Int <$> getSpares varCPC + in Just ("case 9,2 RAS " + <> show ras <> ", " <> show spares) + _ -> Nothing :: Maybe String + print value +``` + +### Multiple UAP categories + +With multiple UAP categories, it is in general not possible to unambiguously +determine parsing success or failure result. +In this case, a user has the following options: +- try to parse all possible UAP combinations and post-process results +- enforce parsing according to particular UAP and recover unambiguously + parsing result (success or failure) + +**Trying all possible combinations** + +This kind of parsing is provided by `parseRecordsTry` function. +In this case, the result is a 'list of possible parsing results', where +- An empty list represents parsing failure. +- Single element list is the actual result, which is normally expected. + The (one) element of a list is itself a list of records. +- Multi element list are all valid parsing results, library user shall + decide what to do with multiple results. Typically a user might want + to check each record in turn if it actually represents a valid record, + based on the content of particular subitems. + +For example, cat001 defines `plot` and `track` UAPs. Parsing of a particular +input string might be (all valid at parsing stage): +- `Datagram of [plot, plot, plot]` +- `Datagram of [track, track, track]` +- `Datagram of [plot, track, track]` +- ... and so on + +Library user might examine each record (after parsing stage), to determine if +all records are actually valid, according to the subitem content. With this +additional step, some parsing solutions might be rejected and with some luck, +there is only one remaining result. + +Example: + +```haskell +-- | file: readme-samples/parsing-cat001-try.hs +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE LambdaCase #-} +{-# LANGUAGE OverloadedStrings #-} + +import Control.Monad +import Data.ByteString (ByteString) +import Asterix.Coding +import Asterix.Generated as Gen + +type Cat001 = Gen.Cat_001_1_4 + +recPlot :: Record (RecordOfUap Cat001 "plot") +recPlot = record + ( item @"020" (extended + ( item @"TYP" 0 *: 0 *: 0 *: 0 *: 0 *: 0 *: fx *: nil)) + *: nil ) + +recTrack :: Record (RecordOfUap Cat001 "track") +recTrack = record + ( item @"020" (extended + ( item @"TYP" 1 *: 0 *: 0 *: 0 *: 0 *: 0 *: fx *: nil)) + *: nil ) + +db :: Datablock (DatablockOf Cat001) +db = datablock ( recPlot *: recTrack *: nil) + +sample :: ByteString +sample = toByteString $ unparse @SBuilder db + +handlePlot :: Record (RecordOfUap Cat001 "plot") -> IO () +handlePlot _rec = putStrLn "got plot" + +handleTrack :: Record (RecordOfUap Cat001 "track") -> IO () +handleTrack _rec = putStrLn "got track" + +main :: IO () +main = do + let rawDatablocks :: [RawDatablock] + rawDatablocks = case parseRawDatablocks sample of + Left (ParsingError _) -> error "can not parse raw datablocks" + Right val -> val + rawDatablock :: RawDatablock = rawDatablocks !! 0 + rawRecords = case rawDatablockCategory rawDatablock of + 1 -> getRawRecords rawDatablock + _ -> error "unexpected category" + parsingAction = parseRecordsTry (Just 10) (schema @Cat001 Proxy) + results = case parse @StrictParsing parsingAction rawRecords of + Left (ParsingError _) -> error "unexpected parse failure" + Right val -> val + + case length results of + 4 -> pure () + _ -> error "unexpected length of results" + + forM_ results $ \result -> do + putStrLn "possible result" + forM_ result $ \(name, rec) -> case name of + "plot" -> handlePlot (Record rec) + "track" -> handleTrack (Record rec) + _ -> error "unexpected record type" +``` + +**Enforce parsing according to a particular UAP*** + +When the input is 'known' to contain only 'tracks' for example, a user +can enforce parsing to try only that UAP and avoid additional processing +stage. In this case, the situation is similar to the regular single +UAP parsing. Example: + +```haskell +-- | file: readme-samples/parsing-cat001-tracks.hs +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE LambdaCase #-} +{-# LANGUAGE OverloadedStrings #-} + +import Data.ByteString (ByteString) +import Asterix.Coding +import Asterix.Generated as Gen + +type Cat001 = Gen.Cat_001_1_4 + +recTrack :: Record (RecordOfUap Cat001 "track") +recTrack = record + ( item @"020" (extended + ( item @"TYP" 1 *: 0 *: 0 *: 0 *: 0 *: 0 *: fx *: nil)) + *: nil ) + +db :: Datablock (DatablockOf Cat001) +db = datablock ( recTrack *: recTrack *: nil) + +sample :: ByteString +sample = toByteString $ unparse @SBuilder db + +handleTrack :: Record (RecordOfUap Cat001 "track") -> IO () +handleTrack _rec = putStrLn "got track" + +main :: IO () +main = do + let rawDatablocks :: [RawDatablock] + rawDatablocks = case parseRawDatablocks sample of + Left (ParsingError _) -> error "can not parse raw datablocks" + Right val -> val + rawDatablock :: RawDatablock = rawDatablocks !! 0 + rawRecords = case rawDatablockCategory rawDatablock of + 1 -> getRawRecords rawDatablock + _ -> error "unexpected category" + parsingAction = parseRecords (schema @(RecordOfUap Cat001 "track") Proxy) + records = case parse @StrictParsing parsingAction rawRecords of + Left (ParsingError _) -> error "can not parse records" + Right lst -> fmap Record lst + mapM_ handleTrack records +``` + +### RFS handling + +This library supports RFS mechanism for categories that include RFS +indicators. For such cases, it is possible to sequence subitems in +any order. Once such record is created or parsed, a user can extract +subitems using `getRfsItem` function. The result in this case is +a list, since the item can be present in the record multiple times. +An empty list indicates that no such item is present in the RFS. + +**Example** + +```haskell +-- | file: readme-samples/rfs.hs +{-# LANGUAGE DataKinds #-} + +import Control.Monad +import Data.Maybe +import Asterix.Coding +import Asterix.Generated as Gen + +-- cat008 contains RFS indicator, so we are able to add RFS items +type Spec = Gen.Cat_008_1_3 + +assert :: Bool -> IO () +assert True = pure () +assert False = error "Assertion error" + +rec1 :: Record (RecordOf Spec) +rec1 = record + -- add some regular items + ( item @"000" 1 + *: item @"010" (group (item @"SAC" 1 *: item @"SIC" 2 *: nil)) + -- add items as RFS (may repeat) + *: rfs + ( item @"010" (group (item @"SAC" 1 *: item @"SIC" 2 *: nil)) + *: item @"010" (group (item @"SAC" 1 *: item @"SIC" 2 *: nil)) + *: nil) + *: nil ) + +main :: IO () +main = do + -- extract regular item 010 + let i010Regular = fromJust $ getItem @"010" rec1 + putStrLn $ debugBits $ unparse @Bits i010Regular + + -- extract RFS items 010, expecting 2 such items + let i010Rfs = getRfsItem @"010" rec1 + assert (length i010Rfs == 2) + forM_ i010Rfs $ \i -> do + putStrLn $ debugBits $ unparse @Bits i + + -- but item '000' is not present in RFS + assert (length (getRfsItem @"000" rec1) == 0) +``` + +### Strict and partial record parsing modes + +This library supports parsing records strictly or partially. + +In a strict mode, we want to make sure that all data is parsed exactly +as specified in the particular category/edition schema. The record parsing +fails if the FSPEC parsing fails or if any subsequent item parsing fails. + +In a partial mode, we don't require exact parsing match. If we know where +in a bytestring a record starts, we can try to parse *some* information out of +the data stream, even in the case if the editions of the transmitter and the +receiver do not match exactly. In particular: if the transmitter sends some +additional items, unknown to the receiver. In that case, the receiver can still +parse up to some point in a datablock. + +Partial record parsing means to parse the FSPEC (which might fail) followed +by parsing subitems up to the point until items parsing is successful. The +record parsing only fails if the FSPEC parsing itself fails. + +This is useful in situations where a datablock contains only one record +(known as *non-blocking* in Asterix Maintenance Group vocabulary) or if +we are interested only in the first record (even if there are more). The idea +is to regain some forward compatibility on the receiver side, such that the +receiver does not need to upgrade edition immediately as the transmitter +upgrades or even before that. Whether this is safe or not, depends on the +application and the exact differences between transmitter and receiver +asterix editions. + +The following parsing methods exist: + +```haskell +data ParsingMode + = StrictParsing + | PartialParsing +``` + +This example demonstrates both parsing modes: + +```haskell +-- | file: readme-samples/parsing-partial-mode.hs +{-# LANGUAGE DataKinds #-} + +import Data.Maybe +import Data.Either +import Data.ByteString (ByteString) + +import Asterix.Coding +import Asterix.Generated as Gen + +type SpecOld = Gen.Cat_063_1_6 +type SpecNew = Gen.Cat_063_1_7 + +assert :: Bool -> IO () +assert True = pure () +assert False = error "Assertion error" + +-- In the new spec, item 060 is extended to contain 3 groups, +-- while in the old spec it only contain2 groups. +-- Create record according to the new spec +rec0 :: Record (RecordOf SpecNew) +rec0 = record + ( item @"010" (group (item @"SAC" 1 *: item @"SIC" 2 *: nil)) + *: item @"015" 3 + *: item @"060" (extendedGroups (1 *: 2 *: 3 *: nil)) + *: nil ) + +-- This bytestring represents the record of SpecNew +bs :: ByteString +bs = toByteString $ unparse @SBuilder rec0 + +main :: IO () +main = do + let expected = fromJust $ unhexlify "c8010203030506" + assert (bs == expected) + + -- We should be able to parse the record, using the new spec + -- and get the same record back. + let act1 = parseRecord (schema @(RecordOf SpecNew) Proxy) + rec1 = fromRight (error "unexpected") (parse @StrictParsing act1 bs) + assert (unparse @Bits rec1 == unparse rec0) + + -- Strict parsing with the old spec fails. + let act2 = parseRecord (schema @(RecordOf SpecOld) Proxy) + rec2 = parse @StrictParsing act2 bs + assert $ isLeft rec2 + + -- However, we can still try to parse using the PartialParsing mode. + let act3 = parseRecord (schema @(RecordOf SpecOld) Proxy) + rec3 :: Record (RecordOf SpecOld) + rec3 = Record $ fromRight (error "unexpected") + (parse @PartialParsing act3 bs) + + -- We accept the fact that resulting record might not be complete, but + -- items "010" and "015" are valid, even if parsing using the old edition. + let i010 = fromJust $ getItem @"010" rec3 + i015 = fromJust $ getItem @"015" rec3 + assert (asUint @Int i010 == 0x0102) + assert (asUint @Int i015 == 3) + + -- Note, that the result in this case in not equal to the original record. + assert (unparse @Bits rec3 /= unparse rec0) +``` + +## Unit tests + +For more examples using test specifications, see also project repository +[unit tests](https://github.com/zoranbosnjak/asterix-libs/tree/main/libs/haskell/test). + diff --git a/libasterix.cabal b/libasterix.cabal new file mode 100644 --- /dev/null +++ b/libasterix.cabal @@ -0,0 +1,84 @@ +cabal-version: 3.0 +name: libasterix +version: 0.14.0 +synopsis: Asterix data processing library +description: + This library provides features to process asterix data format, including + parsing, unparsing, constructing and manipulating asterix records. + + Asterix data format is a set of specifications, defined by Eurocontrol. + It is mostly used for exchanging surveillance related information in air + traffic control applications. + + For more details and tutorial see + . + +license: BSD-3-Clause +license-file: LICENSE +author: Zoran Bošnjak +maintainer: zoran.bosnjak@via.si +homepage: https://github.com/zoranbosnjak/asterix-libs/tree/main/libs/haskell +bug-reports: https://github.com/zoranbosnjak/asterix-libs/issues +-- copyright: +category: Data +build-type: Simple +extra-doc-files: CHANGELOG.md +extra-source-files: + README.md + +source-repository head + type: git + location: https://github.com/zoranbosnjak/asterix-libs + +common base + ghc-options: + -Wall + -Wincomplete-uni-patterns + -Wincomplete-record-updates + -Wcompat + -Widentities + -Wredundant-constraints + -Wunused-packages + -Wpartial-fields + default-language: GHC2021 + build-depends: + , base < 5 + +library + import: base + exposed-modules: + Asterix.Schema + Asterix.BitString + Asterix.Base + Asterix.Generated + Asterix.Coding + -- other-modules: + -- other-extensions: + hs-source-dirs: src + build-depends: + , text ^>= 2.1.3 + , bytestring ^>= 0.12.2.0 + , base16-bytestring ^>= 1.0.2.0 + , transformers ^>= 0.6.1.1 + , containers ^>= 0.7 + +test-suite libasterix-test + import: base + other-modules: + Common + Generated + TestBits + TestRawDatablock + TestAsterix + TestCoding + -- other-extensions: + type: exitcode-stdio-1.0 + hs-source-dirs: test + main-is: Main.hs + build-depends: + , libasterix + , bytestring + , tasty + , tasty-quickcheck + , tasty-hunit + diff --git a/src/Asterix/Base.hs b/src/Asterix/Base.hs new file mode 100644 --- /dev/null +++ b/src/Asterix/Base.hs @@ -0,0 +1,871 @@ +-- | +-- Module: Asterix.Base +-- +-- Asterix base data structures and functions. + +-- Some constraints seems redundant to ghc, but are actually required. +{-# OPTIONS_GHC -Wno-redundant-constraints #-} + +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE GADTs #-} +{-# LANGUAGE LambdaCase #-} +{-# LANGUAGE MultiWayIf #-} +{-# LANGUAGE OverloadedStrings #-} +{-# LANGUAGE TypeFamilies #-} + +module Asterix.Base ( + +-- * RawDatablock +-- +-- | A 'RawDatablock' represents a valid 'ByteString', according to the +-- first level of asterix: @[cat|length|records...]@, where the record +-- bytes are not yet fully parsed. +RawDatablock(..) +, rawDatablockCategory +, parseRawDatablock +, parseRawDatablocks +, unparseRawDatablock +, getRawRecords +, processDatablocks + +-- * Basic asterix building blocks +, ItemName +, FRN +, RecordItem(..) + +-- * Parsing +, KnownParsingMode(..) +, ParsingStore(..) +, ParsingM +, ParsingError(..) +, ParsingMode(..) +, Env(..) +, runParsing +, parseVariation +, parseExpansion +, parseNonSpare +, parseRecord +, parseRecords +, parseRecordsTry + +-- * Unparsing +, Unparsing(..) +, unparseToNum + +-- * Asterix related support types and functions +, recreateExtended +, mkFspecFx +, mkFspecFixed +, bitsToString +, bitsToInteger +, bitsToDouble +, asUint +, endOffset +, bitsPerChar +, evalNum + +-- * Other support types and functions +, intError +, IsEmpty(..) +, KnownBool(..) +, Fst +, Snd + +-- * Heterogeneous list +, HList(..) +, hlUncons +, hlHead +, hlTail +, nil +, (*:) +, FoldHList(..) + +) where + +import Control.Applicative +import Control.Monad +import Control.Monad.Trans.Class +import Control.Monad.Trans.RWS +import Data.Bits (testBit) +import Data.Bool +import Data.ByteString (ByteString) +import qualified Data.ByteString as BS +import Data.ByteString.Builder as BSB +import Data.Char (chr, ord) +import Data.Coerce +import Data.Kind (Type) +import qualified Data.List as L +import Data.Map (Map) +import qualified Data.Map as Map +import Data.Maybe +import Data.Proxy +import Data.String as S +import Data.Text (Text) +import Data.Word +import GHC.Stack + +import Asterix.BitString +import Asterix.Schema + +-- | First part of a Pair. +type family Fst t where Fst '(a, b) = a + +-- | Second part of a Pair. +type family Snd t where Snd '(a, b) = b + +-- | Raise internal error. +intError :: HasCallStack => a +intError = error $ "Internal error, " <> prettyCallStack callStack + +-- | Number of bits per character for different string types. +bitsPerChar :: VStringType -> Int +bitsPerChar = \case + GStringAscii -> 8 + GStringICAO -> 6 + GStringOctal -> 3 + +-- | Evaluate GZ number to Integer. +evalGz :: VZ -> Integer +evalGz (GZ pm i) = fromIntegral $ i * case pm of + GPlus -> 1 + GMinus -> -1 + +-- | Evaluate VNumber. +evalNum :: Fractional a => VNumber -> a +evalNum = \case + GNumInt gz -> fromIntegral $ evalGz gz + GNumDiv a b -> evalNum a / evalNum b + GNumPow a b -> fromIntegral (evalGz a ^ evalGz b) + +-- | Convert structure to unsigned integer, via Bits representation. +asUint :: forall b a. (Unparsing Bits a, Integral b) => a -> b +asUint = bitsToNum . unparse + +-- | Convert Bits to String, according to string type rules. +bitsToString :: VStringType -> Int -> Bits -> String +bitsToString st bitSize = + let bpc :: Int + bpc = bitsPerChar st + + toChar :: Int -> Char + toChar x = case st of + GStringAscii -> chr x + GStringICAO -> if + | x >= 0x01 && x <= 0x1A -> chr (ord 'A' + x - 0x01) + | x == 0x20 -> ' ' + | x >= 0x30 && x <= 0x39 -> chr (ord '0' + x - 0x30) + | otherwise -> '?' + GStringOctal -> chr (ord '0' + x) + + p = 2 ^ bpc + n = div bitSize bpc + + go :: Int -> Integer -> String + go cnt x + | cnt > 0 = + let (y, i) = divMod x p + c = toChar $ fromIntegral i + in c : go (pred cnt) y + | cnt == 0 = "" + | otherwise = intError + in reverse . go n . bitsToNum @Integer + +-- | Map Unsigned values unchanged, apply proper modulo for signed values. +-- This is a helper function when converting unsigned bits to signed integer. +applySignedness :: (Integral b, Num a, Ord a) => GSignedness -> b -> a -> a +applySignedness sig n val = case sig of + GUnsigned -> val + GSigned -> withAssumption (n > 0) $ + let half = 2 ^ (n-1) + in case val < half of + True -> val + False -> val - (2 * half) + +-- | Convert bits to integer. +bitsToInteger :: VSignedness -> Int -> Bits -> Integer +bitsToInteger sig n + = applySignedness sig n + . bitsToNum @Integer + +-- | Convert bits to double. +bitsToDouble :: VSignedness -> Int -> Double -> Bits -> Double +bitsToDouble sig n lsb + = applyLsb + . applySignedness sig n + . bitsToNum @Integer + where + applyLsb = (* lsb) . fromIntegral + +-- | Empty structure check. +class IsEmpty t where + isEmpty :: t -> Bool + +-- | Conversion from typelevel to value level bool. +class KnownBool t where boolVal :: Proxy t -> Bool +instance KnownBool 'False where boolVal _ = False +instance KnownBool 'True where boolVal _ = True + +-- | Heterogeneous list. +data HList t where + HNil :: HList '[] + HCons :: t -> HList ts -> HList (t ': ts) + +-- | Empty HList. +nil :: HList '[] +nil = HNil + +-- | HList cons operator. +infixr 5 *: +(*:) :: x -> HList xs -> HList (x ': xs) +(*:) = HCons + +-- | Uncons head and tail from HList. +hlUncons :: HList (t ': ts) -> (t, HList ts) +hlUncons (HCons x xs) = (x, xs) + +-- | Head of HList. +hlHead :: HList (c : ts) -> c +hlHead = fst . hlUncons + +-- | Tail of HList. +hlTail :: HList (a : ts) -> HList ts +hlTail = snd . hlUncons + +-- | Split HList based on type level index. +class HListSplit (ix :: [Type]) (ts :: [Type]) where + type HListSplitL ix ts :: [Type] + type HListSplitR ix ts :: [Type] + hListSplit :: Proxy ix -> HList ts + -> (HList (HListSplitL ix ts), HList (HListSplitR ix ts)) + +instance HListSplit '[] ts where + type HListSplitL '[] ts = '[] + type HListSplitR '[] ts = ts + hListSplit _ lst = (nil, lst) + +instance + ( t1 ~ t2 + , HListSplit ts1 ts2 + ) => HListSplit (t1 ': ts1) (t2 ': ts2) where + type HListSplitL (t1 ': ts1) (t2 ': ts2) = t1 ': HListSplitL ts1 ts2 + type HListSplitR (t1 ': ts1) (t2 ': ts2) = HListSplitR ts1 ts2 + hListSplit _ (HCons x xs) = + let (a, b) = hListSplit (Proxy @ts1) xs + in (x *: a, b) + +-- | Append 2 HLists. +class HListAppend l1 l2 where + type HListAppendR l1 l2 :: [Type] + hListAppend :: HList l1 -> HList l2 -> HList (HListAppendR l1 l2) + +instance HListAppend '[] l2 where + type HListAppendR '[] l2 = l2 + hListAppend HNil l = l + +instance HListAppend ts l2 => HListAppend (t ': ts) l2 where + type HListAppendR (t ': ts) l2 = t ': HListAppendR ts l2 + hListAppend (HCons x xs) l2 = HCons x (hListAppend xs l2) + +-- | Fold HList by converting each element to a Monoid +-- and combining the results. +-- A 'c' represents a constraint on each element of HList. +-- A caller of 'foldHList' should provide 'c' as type application, +-- for example: foldHList @Show (\x -> [show x]) someHList, +-- would convert HList to [String], given that each element has +-- Show instance. +class FoldHList c t where + foldHList :: Monoid r => (forall a. c a => a -> r) -> HList t -> r + +instance FoldHList c '[] where + foldHList _f HNil = mempty + +instance + ( c t + , FoldHList c ts + ) => FoldHList c (t ': ts) where + foldHList f (HCons x xs) = f x <> foldHList @c f xs + +-- | Overload 'unparse' function to work on various structures and results. +class Unparsing r t where + unparse :: t -> r + +instance Unparsing Bits Bits where + unparse = id + +instance Unparsing Bits ByteString where + unparse = byteStringToBits + +instance Unparsing SBuilder ByteString where + unparse = fromByteString + +-- | If we can unparse to bits, we can also get a number. +unparseToNum :: (Unparsing Bits t, Integral a) => t -> a +unparseToNum = bitsToNum . unparse + +-- | Item name alias. +type ItemName = Text + +-- | RawDatablock wrapper around ByteString. +newtype RawDatablock = RawDatablock { unRawDatablock :: ByteString } + deriving (Eq, Show) + +instance Unparsing SBuilder RawDatablock where + unparse = fromByteString . unRawDatablock + +-- | Fspec flag bits, without fx bits and without trailing bits. +newtype Fspec = Fspec { fspecBits :: [Bool] } + deriving Show + +-- | Frame number. +type FRN = Word8 + +-- | Parsing mode. +data ParsingMode + = StrictParsing + | PartialParsing + deriving (Eq, Enum, Bounded, Show) + +-- | Parsing mode type to value instances. +class KnownParsingMode t where parsingMode :: Proxy t -> ParsingMode +instance KnownParsingMode 'StrictParsing where parsingMode _ = StrictParsing +instance KnownParsingMode 'PartialParsing where parsingMode _ = PartialParsing + +-- | Record item, containing some NonSpare type. +data RecordItem nsp + = RecordItem nsp + | RecordItemSpare + | RecordItemRFS [(FRN, nsp)] + deriving (Eq, Show) + +-- | All 'Nothing' items represent FX which must be '1', +-- except for the last which must be '0' (if FX). +recreateExtended :: Unparsing Bits i => [Maybe i] -> Bits +recreateExtended = \case + [] -> intError + [Nothing] -> setFx False + [Just i] -> unparse @Bits i + (x:xs) -> case x of + Nothing -> setFx True `appendBits` recreateExtended xs + Just i -> unparse @Bits i `appendBits` recreateExtended xs + where + setFx = integerToBits 7 1 . bool 0 1 + +-- | Create raw fspec from given binary flags, put fx in between. +mkFspecFx :: [Bool] -> SBuilder +mkFspecFx + = bitsToSBuilder + . boolsToBits 0 + . mconcat + . reverse + . zipWith addFx (False : repeat True) + . keepAtLeastOne + . dropWhile (== replicate 7 False) + . reverse + . splitToGroupsOf7 + where + splitToGroupsOf7 :: [Bool] -> [[Bool]] + splitToGroupsOf7 lst + | Prelude.length lst <= 7 = [take 7 (lst <> repeat False)] + | otherwise = take 7 lst : splitToGroupsOf7 (drop 7 lst) + + addFx :: Bool -> [Bool] -> [Bool] + addFx fxBit lst = lst <> [fxBit] + + keepAtLeastOne :: [[Bool]] -> [[Bool]] + keepAtLeastOne = \case + [] -> [replicate 7 False] + lst -> lst + +-- | Create fixed size raw fspec from given binary flags (no fx). +mkFspecFixed + :: Int -- ^ number of resulting bytes + -> [Bool] -- ^ input flags + -> SBuilder +mkFspecFixed nBytes + = bitsToSBuilder + . boolsToBits 0 + . take (nBytes * 8) + . (<> repeat False) + +-- | Helper structure for parsing. +-- This module implements actual low-level asterix parsing. +-- Each concrete implementation shall provide a structure of this type +-- as a way to specify how the parsing result shall be stored. +-- This mostly depends on a usecase. +data ParsingStore var rv nsp item rec exp = ParsingStore + -- variation + + -- Element consumes the actual bits. + { psElement :: Bits -> var + -- Group consumes actual bits + list of parsed items + , psGroup :: Bits -> [item] -> var + -- Extended consumes actual bits + list of parsed items or fx bits + , psExtended :: Bits -> [Maybe item] -> var + -- Repetitive consumes actual bits + list of variations + , psRepetitive :: Bits -> [var] -> var + -- Explicit consumes all bits + data bits (all bits except first octet) + , psExplicit :: Bits -> Bits -> var + -- Compound consumes (raw fspec, raw items, items) + , psCompound :: Bits -> Bits -> [Maybe nsp] -> var + + -- rule variation + , psRuleVar :: var -> rv + + -- non-spare + , psNsp :: rv -> nsp + + -- items + , psSpare :: Bits -> item + , psItem :: nsp -> item + + -- record + , psRecord :: + Bits -- raw fspec + -> Bits -- raw items + -> [Maybe (RecordItem nsp)] -- items + -> rec + + -- expansion + , psExpansion :: + Bits -- raw fspec + -> Bits -- raw items + -> [Maybe nsp] -- items + -> exp + } + +-- | Parsing environment. +-- This data type is parametrized with several data types, +-- like 'var', 'item', 'rec'..., such that a Coding module can select concrete +-- types to store 'Variation', 'Item', 'Record'... and this module can remain +-- generic. +data Env (pm :: ParsingMode) var rv nsp item rec exp = Env + { envStore :: ParsingStore var rv nsp item rec exp + , envInput :: ByteString + } + +-- | Extract category number from RawDatablock. +rawDatablockCategory :: RawDatablock -> Word8 +rawDatablockCategory (RawDatablock bs) = BS.index bs 0 + +-- | Extract bytes, representing raw records from RawDatablock. +getRawRecords :: RawDatablock -> ByteString +getRawRecords (RawDatablock bs) = BS.drop 3 bs + +-- | Parsing error text. +newtype ParsingError = ParsingError Text + deriving (Show, IsString) + +-- | Parsing monad. It combines several effects, which are already +-- provided by the RWST type from the 'mtl' library. +-- - reader type is the environment +-- - writer type is not used () +-- - state type is the current parsing offfset +-- - monad is (Either ParsingError r), where the 'r' represents +-- eventual parsing result +-- All type parameters are required by the environment (see 'Env'). +type ParsingM pm a b c d e f = RWST (Env pm a b c d e f) () Offset (Either ParsingError) + +-- | Run parsing action. +runParsing :: Monad m => RWST r w s m a -> r -> s -> m (a, s) +runParsing act r s = do + (a, s', _w) <- runRWST act r s + pure (a, s') + +-- | Raise parsing error. +parsingError :: ParsingError -> ParsingM pm a b c d e f r +parsingError = lift . Left + +-- | Check bit alignment. +aligned :: Offset -> Int -> Bool +aligned o o8 = numBits o == o8 + +-- | End of a bytestring. +endOffset :: ByteString -> Offset +endOffset = intToNumBits . (*8) . BS.length + +-- | End of input. +eof :: ParsingM pm a b c d e f Bool +eof = do + o <- get + o2 <- asks (endOffset . envInput) + case compare o o2 of + LT -> pure False + EQ -> pure True + GT -> intError + +-- | Move offset pointer by 'n' bits. +moveOffset :: Size -> ParsingM pm a b c d e f () +moveOffset n = do + bs <- asks envInput + o <- get + let o' = o + coerce n + when (o' > endOffset bs) $ parsingError "overflow" + put o' + +-- | Fetch some number of bits. +parseBits :: Int -> Size -> ParsingM pm a b c d e f Bits +parseBits o8 n = do + bs <- asks envInput + o <- get + withAssumption (aligned o o8) $ do + moveOffset n + pure $ Bits bs o n + +-- | Parse Word8. +parseWord8 :: ParsingM pm a b c d e f Word8 +parseWord8 = do + bs <- asks envInput + o <- get + withAssumption (aligned o 0) $ do + moveOffset 8 + pure $ BS.index bs (numBytes o) + +-- | Parse 'n' bytes. +parseBytes :: Int -> ParsingM pm a b c d e f ByteString +parseBytes n = do + bs <- asks envInput + o <- get + withAssumption (aligned o 0) $ do + moveOffset $ intToNumBits $ n * 8 + pure $ BS.take n $ BS.drop (numBytes o) bs + +-- | Parse 'fx' bit. +parseFx :: ParsingM pm a b c d e f Bool +parseFx = do + Bits bs o _ <- parseBits 7 1 + pure $ testBit (BS.index bs (numBytes o)) 0 + +-- | Parse complete fspec, take fx bits into account +-- The ParsingMode is present in the environment, which is ignored in this +-- function. Explicit parameter is used instead. The reason is that a +-- caller can override mode, for example... fspec in compound is always +-- strict and for the record it depends on user preferences. +parseFspec :: ParsingMode -> Int -> ParsingM pm a b c d e f Fspec +parseFspec pm definedItems = do + result <- go + let n = length result + (a, b) = divMod definedItems 7 + maxSize + | b == 0 = definedItems + | otherwise = (a+1) * 7 + when (n == 0) $ parsingError "empty fspec" + case pm of + StrictParsing -> when (n > maxSize) $ parsingError "fspec too big" + PartialParsing -> pure () + pure $ Fspec $ take definedItems result + where + go :: ParsingM pm a b c d e f [Bool] + go = do + w <- word8ToBools <$> parseWord8 + let (flags, fx) = (init w, last w) + case fx of + False -> pure flags + True -> (<>) <$> pure flags <*> go + +-- | Parse Variation. +parseVariation :: VVariation -> ParsingM pm var b c d e f var +parseVariation sch = ask >>= \env -> case sch of + GElement o n _ruleCont -> do + psElement (envStore env) <$> parseBits o (intToNumBits n) + GGroup _o lst -> do + o1 <- get + items <- go lst + o2 <- get + let bits = Bits (envInput env) o1 (coerce $ o2 - o1) + pure $ psGroup (envStore env) bits items + where + go [] = pure [] + go (x:xs) = (:) <$> parseItem x <*> go xs + GExtended lst -> do + o1 <- get + mItems <- go lst + o2 <- get + let bits = Bits (envInput env) o1 (coerce $ o2 - o1) + pure $ psExtended (envStore env) bits mItems + where + go [] = pure [] + go (mx:xs) = case mx of + Nothing -> parseFx >>= \case + False -> pure [Nothing] + True -> case xs of + [] -> parsingError "last FX bit is expected to be zero" + _ -> (:) <$> pure Nothing <*> go xs + Just x -> ((:) . Just <$> parseItem x) <*> go xs + GRepetitive rt var -> do + o1 <- get + lst <- case rt of + GRepetitiveRegular rep -> do + parseBytes rep >>= goRegular . byteStringToNum @Int + GRepetitiveFx -> goFx + o2 <- get + let bits = Bits (envInput env) o1 (coerce $ o2 - o1) + pure $ psRepetitive (envStore env) bits lst + where + goRegular = \case + 0 -> pure [] + n -> (:) <$> parseVariation var <*> goRegular (pred n) + goFx = do + x <- parseVariation var + parseFx >>= \case + False -> pure [x] + True -> (:) <$> pure x <*> goFx + GExplicit _met -> do + o1 <- get + n <- parseWord8 + o2 <- get + _ <- case n of + 0 -> parsingError "unexpected size of explicit item" + _ -> parseBytes (fromIntegral $ pred n) + o3 <- get + let b1 = Bits (envInput env) o1 (coerce $ o3 - o1) + b2 = Bits (envInput env) o2 (coerce $ o3 - o2) + pure $ psExplicit (envStore env) b1 b2 + GCompound lst -> do + o1 <- get + fspec <- parseFspec StrictParsing (length lst) + o2 <- get + items <- go $ zip (fspecBits fspec <> repeat False) lst + o3 <- get + let rawFspec = Bits (envInput env) o1 (coerce $ o2 - o1) + rawItems = Bits (envInput env) o2 (coerce $ o3 - o2) + pure $ psCompound (envStore env) rawFspec rawItems items + where + go :: [(Bool, Maybe VNonSpare)] + -> ParsingM pm a b nsp d e f [Maybe nsp] + go [] = pure mempty + go ((flag,spec) : xs) + | not flag = (:) <$> pure Nothing <*> go xs + | otherwise = case spec of + Nothing -> parsingError "FX bit set for non-defined item" + Just nsp -> ((:) . Just <$> parseNonSpare nsp) <*> go xs + +-- | Parse RuleVariation. +parseRuleVariation :: VRule VVariation + -> ParsingM pm a rv c d e f rv +parseRuleVariation sch1 = ask >>= \env -> do + let sch2 = case sch1 of + GContextFree sch -> sch + GDependent _ sch _ -> sch + psRuleVar (envStore env) <$> parseVariation sch2 + +-- | Parse NonSpare. +parseNonSpare :: VNonSpare -> ParsingM pm var rv nsp d e f nsp +parseNonSpare (GNonSpare _name _title rvSch) = ask >>= \env -> do + psNsp (envStore env) <$> parseRuleVariation rvSch + +-- | Parse Item. +parseItem :: VItem -> ParsingM pm a b c item e f item +parseItem sch = ask >>= \env -> case sch of + GSpare o n -> psSpare (envStore env) <$> parseBits o (intToNumBits n) + GItem nsp -> psItem (envStore env) <$> parseNonSpare nsp + +-- | Parse Record. +parseRecord :: forall pm a b c d rec f. + ( KnownParsingMode pm + ) => VRecord -> ParsingM pm a b c d rec f rec +parseRecord (GRecord lst) = ask >>= \env -> do + o1 <- get + fspec <- parseFspec pm (length lst) + o2 <- get + (items, clean) <- goItems (fspecBits fspec) lst + o3 <- get + let rawItems = Bits (envInput env) o2 (coerce $ o3 - o2) + -- We can reuse original bits only if the parsing was 'clean', + -- otherwise we need to recreate the fspec. + rawFspec = case clean of + True -> Bits (envInput env) o1 (coerce $ o2 - o1) + False -> recreateFspec (fmap isJust items) + pure $ psRecord (envStore env) rawFspec rawItems items + where + pm :: ParsingMode + pm = parsingMode @pm Proxy + + findSchema :: FRN -> [VUapItem] -> Maybe VNonSpare + findSchema _ [] = Nothing + findSchema n (x:xs) + | n == 0 = case x of + GUapItem nsp -> Just nsp + _ -> Nothing + | otherwise = findSchema (pred n) xs + + goRfs :: ParsingM pm a b nsp d e f ([(FRN, nsp)], Bool) + goRfs = parseWord8 >>= go + where + go :: Word8 -> ParsingM pm a b nsp d e f ([(FRN, nsp)], Bool) + go = \case + 0 -> pure (mempty, True) + cnt -> do + frn <- parseWord8 >>= \case + 0 -> parsingError "invalid FRN" + n -> pure n + nsp <- maybe + (parsingError "RFS subitem not defined") + pure (findSchema (pred frn) lst) + env <- ask + offset <- get + case runParsing (parseNonSpare nsp) env offset of + Left err -> case pm of + StrictParsing -> parsingError err + PartialParsing -> pure (mempty, False) + Right (x, offset') -> do + put offset' + (xs, clean) <- go (pred cnt) + pure ((frn, x) : xs, clean) + + goItems :: [Bool] -> [VUapItem] + -> ParsingM pm a b nsp d e f ([Maybe (RecordItem nsp)], Bool) + goItems [] [] = pure (mempty, True) + goItems [] (_:ts) = do + (items, clean) <- goItems [] ts + pure (Nothing : items, clean) + goItems _flags [] = case pm of + StrictParsing -> parsingError "record subitem not defined" + PartialParsing -> pure (mempty, False) + goItems (flag:flags) (spec:specs) + | not flag = do + (items, clean) <- goItems flags specs + pure (Nothing : items, clean) + | otherwise = case spec of + GUapItemSpare -> case pm of + StrictParsing -> parsingError "FX bit set for spare item" + PartialParsing -> pure (mempty, False) + GUapItemRFS -> do + (rfs, clean1) <- goRfs + case clean1 of + False -> pure ([Just (RecordItemRFS rfs)], False) + True -> do + (items, clean2) <- goItems flags specs + pure (Just (RecordItemRFS rfs) : items, clean2) + GUapItem nsp -> do + env <- ask + offset <- get + case runParsing (parseNonSpare nsp) env offset of + Left err -> case pm of + StrictParsing -> parsingError err + PartialParsing -> pure (mempty, False) + Right (x, offset') -> do + put offset' + (items, clean) <- goItems flags specs + pure (Just (RecordItem x) : items, clean) + +-- | Recreate Fspec as Bits. +recreateFspec :: [Bool] -> Bits +recreateFspec + = byteStringToBits + . BS.pack + . terminateFx -- set last FX bit to '0' + . fmap ((+ 1) . (* 2) . boolsToNum) + . L.dropWhileEnd (replicate 7 False ==) + . groupsOf False 7 + where + groupsOf :: a -> Int -> [a] -> [[a]] + groupsOf a n lst + | m == 0 = [] + | m < n = [lst <> replicate (n-m) a] + | m == n = [lst] + | otherwise = L.take n lst : groupsOf a n (L.drop n lst) + where + m = Prelude.length lst + terminateFx :: Num a => [a] -> [a] + terminateFx [] = [] + terminateFx lst = init lst <> [last lst - 1] + +-- | Parse multiple records of the same UAP. +parseRecords :: + ( pm ~ StrictParsing -- only makes sense with StrictParsing + ) => VRecord -> ParsingM pm a b c d rec f [rec] +parseRecords sch = eof >>= \case + True -> pure [] + False -> (:) <$> parseRecord sch <*> parseRecords sch + +-- | Try to parse multiple UAP combinations. +-- This function consumes complete input or fails if maxDepth reached. +parseRecordsTry :: + ( pm ~ StrictParsing -- only makes sense with StrictParsing + ) => Maybe Int -> [(VText, VRecord)] + -> ParsingM pm a b c d rec f [[(VText, rec)]] +parseRecordsTry mMaxDepth schs = do + env <- ask + offset <- get + let eo = endOffset $ envInput env + result <- go 0 eo env offset + put eo + pure result + where + isOverflow depth = case mMaxDepth of + Nothing -> False + Just maxDepth -> depth > maxDepth + go depth eo env offset + | isOverflow depth = parsingError "max_depth reached" + | offset > eo = intError + | offset == eo = pure [[]] + | otherwise = do + let result1 = do + (name, sch) <- schs + (x, offset') <- either (const empty) pure + (runParsing (parseRecord sch) env offset) + pure (name, x, offset') + result2 <- forM result1 $ \(name, x, offset') -> do + cont <- go (succ depth) eo env offset' + pure (name, x, cont) + pure $ do + (name, x, ys) <- result2 + y <- ys + pure ((name, x) : y) + +-- | Parse Expansion. +parseExpansion :: VExpansion -> ParsingM pm a b c d e exp exp +parseExpansion (GExpansion mn lst) = ask >>= \env -> do + o1 <- get + fspec <- case mn of + Nothing -> parseFspec StrictParsing (length lst) + Just n -> Fspec . mconcat . fmap word8ToBools . BS.unpack <$> parseBytes n + o2 <- get + items <- go $ zip (fspecBits fspec <> repeat False) lst + o3 <- get + let rawFspec = Bits (envInput env) o1 (coerce $ o2 - o1) + rawItems = Bits (envInput env) o2 (coerce $ o3 - o2) + pure $ psExpansion (envStore env) rawFspec rawItems items + where + go :: [(Bool, Maybe VNonSpare)] + -> ParsingM pm a b nsp d e f [Maybe nsp] + go [] = pure mempty + go ((flag, spec) : xs) + | not flag = (:) <$> pure Nothing <*> go xs + | otherwise = case spec of + Nothing -> parsingError "FX bit set for non-defined item" + Just nsp -> ((:) . Just <$> parseNonSpare nsp) <*> go xs + +-- | Parse ByteString to RawDatablock and the remaining ByteString. +parseRawDatablock :: ByteString -> Either ParsingError (RawDatablock, ByteString) +parseRawDatablock bs = do + let n = BS.length bs + when (n < 3) $ Left "overflow datablock header" + let m = fromIntegral (BS.index bs 1) * 256 + fromIntegral (BS.index bs 2) + when (m < 3) $ Left "unexpected length" + when (m > n) $ Left "overflow datablock records" + pure (RawDatablock $ BS.take m bs, BS.drop m bs) + +-- | Parse many RawDatablocks. +parseRawDatablocks :: ByteString -> Either ParsingError [RawDatablock] +parseRawDatablocks bs + | BS.null bs = pure [] + | otherwise = do + (x, bs') <- parseRawDatablock bs + (:) <$> pure x <*> parseRawDatablocks bs' + +-- | Given a map from asterix category to processing function, +-- process known categories and create list of results. The +-- result is 'Nothing' for unknown category. +processDatablocks :: Map Word8 (RawDatablock -> r) -> ByteString + -> Either ParsingError [Maybe r] +processDatablocks mapping bs = fmap go <$> parseRawDatablocks bs + where + go db = do + f <- Map.lookup (rawDatablockCategory db) mapping + pure $ f db + +-- | Unparse RawDatablock. +unparseRawDatablock :: RawDatablock -> Builder +unparseRawDatablock = BSB.byteString . unRawDatablock + diff --git a/src/Asterix/BitString.hs b/src/Asterix/BitString.hs new file mode 100644 --- /dev/null +++ b/src/Asterix/BitString.hs @@ -0,0 +1,326 @@ +-- | +-- Module: Asterix.BitString +-- +-- Bits and bytes manipulation module. + +{-# LANGUAGE LambdaCase #-} + +module Asterix.BitString where + +import Data.Bits (complement, shift, testBit, (.&.), + (.|.)) +import Data.Bool +import Data.ByteString (ByteString) +import qualified Data.ByteString as BS +import qualified Data.ByteString.Base16 as B16 +import Data.ByteString.Builder as BSB +import qualified Data.ByteString.Char8 as BS8 +import qualified Data.ByteString.Lazy as BSL +import Data.Coerce +import qualified Data.List as L +import Data.List.NonEmpty (NonEmpty (..), uncons) +import Data.Maybe +import Data.Word +import GHC.Stack + +-- | numBytes and numBits function overloading for various structures. +class IsNumBits t where + numBytes :: t -> Int + numBits :: t -> Int + +-- | Number of bits, stored as 'divMod n 8'. +data NumBits = NumBits + { _numBytes :: !Int + , _numBits :: !Int + } deriving (Eq, Show) + +-- | Convert structure's number of bits to Int. +numBitsToInt :: IsNumBits t => t -> Int +numBitsToInt x = numBytes x * 8 + numBits x + +-- | Convert Int to NumBits. +intToNumBits :: Coercible NumBits t => Int -> t +intToNumBits i = coerce (uncurry NumBits $ divMod i 8) + +instance IsNumBits NumBits where + numBytes = _numBytes + numBits = _numBits + +instance Num NumBits where + a + b = intToNumBits (numBitsToInt a + numBitsToInt b) + a * b = intToNumBits (numBitsToInt a * numBitsToInt b) + abs = intToNumBits . abs . numBitsToInt + signum = intToNumBits . signum . numBitsToInt + fromInteger = intToNumBits . fromIntegral + negate = intToNumBits . negate . numBitsToInt + +instance Ord NumBits where + compare (NumBits a1 a2) (NumBits b1 b2) + = compare a1 b1 + <> compare a2 b2 + +-- | Bit offset. +newtype Offset = Offset NumBits deriving (Eq, Ord, Num, Show, IsNumBits) + +-- | Bit size. +newtype Size = Size NumBits deriving (Eq, Ord, Num, Show, IsNumBits) + +-- | A bitstring, capturing fragment of a ByteString. +data Bits = Bits + { bitsData :: ByteString + , bitsOffset :: !Offset + , bitsSize :: !Size + } deriving Show + +-- | ByteString Builder with known byte size. +data SBuilder = SBuilder + { sbByteSize :: Int + , sbData :: Builder + } deriving Show + +-- | For types that can be converted to bits. +class ToBits t where + toBits :: t -> Bits + +-- | For types that can be converted to/from ByteString. +-- Be aware that some conversions might be slow. +class ToFromByteString t where + toByteString :: t -> ByteString + fromByteString :: ByteString -> t + +-- | Convert bytestring to hex representation. +hexlify :: BS.ByteString -> String +hexlify = BS8.unpack . B16.encode + +-- | Convert hex representation back to a bytestring. +unhexlify :: String -> Maybe BS.ByteString +unhexlify = either (const Nothing) Just . B16.decode . BS8.pack + +-- | Helper function for expression evaluation. +withAssumption :: HasCallStack => Bool -> a -> a +withAssumption False _ = + error $ "Internal error (wrong assumption), " <> prettyCallStack callStack +withAssumption True val = val + +-- | Conversion from 'Builder' to 'ByteString'. +builderToByteStringSlow :: Builder -> ByteString +builderToByteStringSlow = BSL.toStrict . BSB.toLazyByteString + +-- | Conversion from 'ByteString' to unsigned number. +byteStringToNum :: Num a => ByteString -> a +byteStringToNum bs + | BS.null bs = 0 + | otherwise = + let (xs, x) = (BS.init bs, BS.last bs) + in byteStringToNum xs * 256 + fromIntegral x + +-- | Calculate 'left' and 'right' bit alignment. +alignment :: Bits -> (Int, Int) +alignment (Bits _ o n) = (a, b) + where + a = numBits o + b = numBits (o + coerce n) + +-- | Calculate 'left' bit alignment. +leftAlignment :: Bits -> Int +leftAlignment = fst . alignment + +-- | Calculate 'right' bit alignment. +rightAlignment :: Bits -> Int +rightAlignment = snd . alignment + +-- | Test whether 'Bits' are empty. +nullBits :: Bits -> Bool +nullBits = (<= 0) . bitsSize + +-- | Convert from 'ByteString' to 'Bits'. +byteStringToBits :: ByteString -> Bits +byteStringToBits bs = Bits bs 0 (intToNumBits $ BS.length bs * 8) + +-- | Calculate required bytes + additional bits. +requiredBytes :: Int -> Int -> (Int, Int) +requiredBytes o8 n = divMod (o8 + n) 8 + +-- | Convert 'Integer' to 'Bits'. +integerToBits :: Int -> Int -> Integer -> Bits +integerToBits o8 n val = Bits bs o (Size $ intToNumBits n) + where + o = Offset (NumBits 0 o8) + (m, b) = withAssumption (n >= 0) requiredBytes o8 n + m' = m + bool 1 0 (b == 0) + shiftedVal + | b == 0 = val + | otherwise = shift val (8 - b) + byteList x = \case + 0 -> [] + k -> + let (x1, x2) = divMod x 256 + in fromInteger x2 : byteList x1 (pred k) + bs = BS.pack (reverse $ byteList shiftedVal m') + +-- | Split 'Word8' to 8 boolean flags. +word8ToBools :: Word8 -> [Bool] +word8ToBools w = [testBit w i | i <- [7,6..0]] + +-- | Fold boolean flags to Num. +boolsToNum :: Num a => [Bool] -> a +boolsToNum = go . Prelude.reverse + where + go = \case + [] -> 0 + (x:xs) -> go xs * 2 + bool 0 1 x + +-- | Convert list of bool flags to bits. +boolsToBits :: Int -> [Bool] -> Bits +boolsToBits o8 lst = Bits bs (Offset $ intToNumBits o8) (Size $ intToNumBits n) + where + n = Prelude.length lst + prefix = replicate o8 False + bs = BS.pack $ byteList (prefix <> lst) + byteList i = + let (a, b) = splitAt 8 i + in case Prelude.length a < 8 of + True -> [boolsToNum $ take 8 $ a <> repeat False] + False -> boolsToNum a : byteList b + +-- | Calculate 'compact' version of Bits - helper function. +compactBits :: Bits -> (ByteString, Maybe Word8) +compactBits (Bits bs o n) = (bs', padding) + where + k = numBytes o + (m, b) = requiredBytes (numBits o) (numBitsToInt n) + bs' = BS.take m $ BS.drop k bs + padding + | b == 0 = Nothing + | otherwise = Just $ BS.index bs (k+m) + +-- | Append properly aligned bits. +appendBits :: Bits -> Bits -> Bits +appendBits s1 s2 = withAssumption (rightAlignment s1 == leftAlignment s2) go + where + (a1, a2) = compactBits s1 + (b1, b2) = compactBits s2 + padding = maybe BS.empty BS.singleton b2 + bs = case a2 of + Nothing -> a1 <> b1 <> padding + Just w1 -> + let w2 = case BS.null b1 of + False -> BS.head b1 + True -> fromJust b2 + m = shift 0xff (- rightAlignment s1) + w = (w1 .&. complement m) .|. (w2 .&. m) + in a1 <> BS.singleton w <> bool (BS.tail b1) mempty (BS.null b1) <> padding + o = Offset $ NumBits 0 $ leftAlignment s1 + n = bitsSize s1 + bitsSize s2 + go + | nullBits s1 = s2 + | nullBits s2 = s1 + | otherwise = Bits bs o n + +-- | Concatinate non-empty list of 'Bits'. +concatBits :: NonEmpty Bits -> Bits +concatBits lst = case uncons lst of + (x, Nothing) -> x + (x, Just xs) -> appendBits x (Asterix.BitString.concatBits xs) + +-- | Convert Bits to Integral. +bitsToNum :: Integral a => Bits -> a +bitsToNum s = case n of + 0 -> 0 + _ -> + let (bs, mw) = compactBits s + val1 = byteStringToNum bs + (a, b) = alignment s + val2 = val1 * (2 ^ b) + fromIntegral (shift (fromJust mw) (- (8-b))) + in case (a, b) of + (0, 0) -> val1 + (_, 0) -> mod val1 (2 ^ n) + (0, _) -> val2 + (_, _) -> mod val2 (2 ^ n) + where + n = numBitsToInt $ bitsSize s + +-- | Extract 'Bits' to list of bool flags. +bitsToBools :: Bits -> [Bool] +bitsToBools (Bits bs o n') = + let n = numBitsToInt n' + o8 = numBits o + (m, _b) = requiredBytes o8 n + s = BS.take (succ m) $ BS.drop (numBytes o) bs + lst = mconcat (word8ToBools <$> BS.unpack s) + in Prelude.take n $ drop o8 lst + +-- | Convert properly aligned 'Bits' to 'Builder'. +bitsToBuilder :: Bits -> Builder +bitsToBuilder s@(Bits bs o n') = withAssumption (alignment s == (0, 0)) bld + where + n = numBitsToInt n' + o8 = numBits o + (m, _b) = requiredBytes o8 n + bld = BSB.byteString $ BS.take m $ BS.drop (numBytes o) bs + +-- | Convert properly aligned 'Bits' to 'SBuilder'. +bitsToSBuilder :: Bits -> SBuilder +bitsToSBuilder arg = SBuilder + (numBytes $ bitsSize arg) + (bitsToBuilder arg) -- this call contains 'withAssumption' + +-- | Convert 'Word8' to 'SBuilder'. +word8ToSBuilder :: Word8 -> SBuilder +word8ToSBuilder = SBuilder 1 . BSB.word8 + +-- | Show value as binary string. +debugBits :: ToBits t => t -> String +debugBits val = mconcat $ L.intersperse " " (goOctet <$> octets) + where + Bits bs o n' = toBits val + n = numBitsToInt n' + o8 = numBits o + (m, b) = requiredBytes o8 n + k = bool m (pred m) (b == 0) + a = numBytes o + octets = [a .. (a+k)] + goOctet ix = + let w = BS.index bs ix + in do + i <- [7,6..0] + let j = 7 - i + x = bool '0' '1' $ testBit w i + o2 = Offset $ NumBits ix j + pure $ bool '.' x (o2 >= o && o2 < (o + coerce n')) + +instance Eq Bits where + b1 == b2 + = numBits (bitsOffset b1) == numBits (bitsOffset b2) + && bitsToBools b1 == bitsToBools b2 + +instance ToBits Bits where + toBits = id + +instance ToBits ByteString where + toBits = byteStringToBits + +instance ToBits Builder where + toBits = toBits . BSL.toStrict . BSB.toLazyByteString + +instance ToBits SBuilder where + toBits = toBits . sbData + +instance Semigroup SBuilder where + SBuilder a1 a2 <> SBuilder b1 b2 = SBuilder (a1+b1) (a2 <> b2) + +instance Monoid SBuilder where + mempty = SBuilder 0 mempty + +instance ToFromByteString ByteString where + toByteString = id + fromByteString = id + +instance ToFromByteString Builder where + toByteString = BSL.toStrict . BSB.toLazyByteString + fromByteString = BSB.byteString + +instance ToFromByteString SBuilder where + toByteString = toByteString . sbData + fromByteString s = SBuilder (BS.length s) (BSB.byteString s) + diff --git a/src/Asterix/Coding.hs b/src/Asterix/Coding.hs new file mode 100644 --- /dev/null +++ b/src/Asterix/Coding.hs @@ -0,0 +1,1993 @@ +-- | +-- Module: Asterix.Coding +-- +-- Asterix data structures and functions to decode, encode and +-- manipulate asterix data. +-- +-- The 'U' prefix in some types stands for 'Untyped' version of data, in +-- contrast to 'Typed' versions, for example `Variation` and `UVariation`. +-- +-- In some data structures, the fields are stored redundantly, +-- to optimize some parsing/unparsing scenarios. + +{-# LANGUAGE AllowAmbiguousTypes #-} +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE FunctionalDependencies #-} +{-# LANGUAGE LambdaCase #-} +{-# LANGUAGE MultiWayIf #-} +{-# LANGUAGE OverloadedStrings #-} +{-# LANGUAGE TypeFamilies #-} +{-# LANGUAGE UndecidableInstances #-} + +module Asterix.Coding +( module Asterix.Coding +, module Asterix.Schema +, module Asterix.BitString +, module Asterix.Base +) where + +import Control.Applicative +import Control.Monad +import Data.Bool +import Data.ByteString (ByteString) +import Data.Char (isAsciiUpper, isDigit, ord) +import Data.Coerce +import Data.Kind (Type) +import qualified Data.List.NonEmpty as NE +import Data.Maybe +import Data.Proxy +import qualified Data.Text as T +import Data.Type.Bool +import Data.Type.Equality +import GHC.TypeLits + +import Asterix.Base +import Asterix.BitString +import Asterix.Schema + +-- | Untyped variation. +data UVariation + = UElement Bits + | UGroup [UItem] + | UExtended SBuilder [Maybe UItem] + | URepetitive SBuilder [UVariation] + | UExplicit SBuilder Bits + | UCompound SBuilder [Maybe UNonSpare] + deriving Show + +-- | Untyped 'rule', capturing a 'Variation'. +newtype URuleVar = URuleVar { unURuleVar :: UVariation } + deriving Show + +-- | Untyped NonSpare item. +newtype UNonSpare = UNonSpare { unUNonSpare :: URuleVar } + deriving Show + +-- | Untyped item. +data UItem + = USpare Bits + | UItem UNonSpare + deriving Show + +-- | Untyped record. +data URecord = URecord + { uRecUnparse :: SBuilder + , uRecItems :: [Maybe (RecordItem UNonSpare)] + } deriving Show + +-- | Untyped expansion. +data UExpansion = UExpansion + { uExpUnparse :: SBuilder + , uExpItems :: [Maybe UNonSpare] + } deriving Show + +-- | In case of multiple uaps, we keep UAP name in addition to the record. +data UDatablock = UDatablock + { uDatablockUnparse :: SBuilder + , uDatablockRecords :: [(Maybe VText, URecord)] + } deriving Show + +-- Typed wrappers around U-version of data structures + +-- | Typed variation. +newtype Variation (t :: TVariation) = Variation { unVariation :: UVariation } + deriving Show + +-- | Typed rule variation. +newtype RuleVar (t1 :: TRule t2) = RuleVar { unRuleVar :: URuleVar } + deriving Show + +-- | Typed nonSpare item. +newtype NonSpare (t :: TNonSpare) = NonSpare { unNonSpare :: UNonSpare } + deriving Show + +-- | Typed item. +newtype Item (t :: TItem) = Item { unItem :: UItem } + deriving Show + +-- | Typed record. +newtype Record (t :: TRecord) = Record { unRecord :: URecord } + deriving Show + +-- | Typed expansion. +newtype Expansion (t :: TExpansion) = Expansion { unExpansion :: UExpansion } + deriving Show + +-- | Typed datablock. +newtype Datablock (db :: TDatablock) = Datablock { unDatablock :: UDatablock } + deriving Show + +-- IsEmpty instances + +instance IsEmpty + (NonSpare ('GNonSpare name title ('GContextFree ('GRepetitive a b)))) + where + isEmpty (NonSpare (UNonSpare (URuleVar var))) = case var of + URepetitive _bld lst -> null lst + _ -> intError + +instance IsEmpty + (NonSpare ('GNonSpare name title ('GContextFree ('GCompound lst)))) + where + isEmpty (NonSpare (UNonSpare (URuleVar var))) = case var of + UCompound _bld lst -> null $ catMaybes lst + _ -> intError + +instance IsEmpty URecord where + isEmpty = null . catMaybes . uRecItems + +instance IsEmpty (Record t) where + isEmpty = isEmpty . unRecord + +-- Unparsing to 'Bits' instances + +instance Unparsing Bits UVariation where + unparse = \case + UElement bits -> bits + UGroup lst -> case NE.nonEmpty lst of + Nothing -> toBits @ByteString mempty + Just ne -> concatBits (fmap unparse ne) + UExtended b _ -> byteStringToBits $ builderToByteStringSlow $ sbData b + URepetitive b _ -> byteStringToBits $ builderToByteStringSlow $ sbData b + UExplicit b _ -> byteStringToBits $ builderToByteStringSlow $ sbData b + UCompound b _ -> byteStringToBits $ builderToByteStringSlow $ sbData b + +instance Unparsing Bits URuleVar where + unparse = unparse . unURuleVar + +instance Unparsing Bits UNonSpare where + unparse = unparse . unUNonSpare + +instance Unparsing Bits UItem where + unparse = \case + USpare b -> b + UItem nsp -> unparse nsp + +instance Unparsing Bits URecord where + unparse + = byteStringToBits + . builderToByteStringSlow + . sbData + . uRecUnparse + +instance Unparsing Bits UExpansion where + unparse + = byteStringToBits + . builderToByteStringSlow + . sbData + . uExpUnparse + +instance Unparsing Bits UDatablock where + unparse + = byteStringToBits + . builderToByteStringSlow + . sbData + . uDatablockUnparse + +instance Unparsing Bits (Variation t) where + unparse = unparse . unVariation + +instance Unparsing Bits (RuleVar t) where + unparse = unparse . unRuleVar + +instance Unparsing Bits (NonSpare t) where + unparse = unparse . unNonSpare + +instance Unparsing Bits (Item t) where + unparse = unparse . unItem + +instance Unparsing Bits (Record t) where + unparse = unparse . unRecord + +instance Unparsing Bits (Expansion t) where + unparse = unparse . unExpansion + +instance Unparsing Bits (Datablock db) where + unparse = unparse . unDatablock + +-- Unparsing to 'SBuilder' instances + +instance Unparsing SBuilder (RecordItem UNonSpare) where + unparse = \case + RecordItem nsp -> bitsToSBuilder $ unparse nsp + RecordItemSpare -> mempty + RecordItemRFS lst -> numItems <> items + where + numItems = word8ToSBuilder (fromIntegral (length lst)) + items = mconcat $ do + (frn, nsp) <- lst + pure + ( word8ToSBuilder frn + <> bitsToSBuilder (unparse nsp)) + +instance Unparsing SBuilder URecord where + unparse = uRecUnparse + +instance Unparsing SBuilder UExpansion where + unparse = uExpUnparse + +instance Unparsing SBuilder UDatablock where + unparse = uDatablockUnparse + +instance Unparsing SBuilder (Record t) where + unparse = unparse . unRecord + +instance Unparsing SBuilder (Expansion t) where + unparse = unparse . unExpansion + +instance Unparsing SBuilder (Datablock db) where + unparse = unparse . unDatablock + +-- Num instances +-- Normally, only 'fromInteger' method is required, +-- but the existing Num typeclass makes it possible +-- for better syntactic sugar, without function name. + +instance + ( KnownNat8 o + , KnownNat n + ) => Num (Variation ('GElement o n rc)) where + a + b = fromInteger (unparseToNum a + unparseToNum b) + a * b = fromInteger (unparseToNum a * unparseToNum b) + abs = fromInteger . abs . unparseToNum + signum = fromInteger . signum . unparseToNum + negate = fromInteger . negate . unparseToNum + fromInteger = Variation . UElement . integerToBits + (unInt8 $ natVal8 (Proxy @o)) + (fromInteger $ natVal (Proxy @n)) + +instance Num (Variation ('GGroup o '[])) where + a + b = fromInteger (unparseToNum a + unparseToNum b) + a * b = fromInteger (unparseToNum a * unparseToNum b) + abs = fromInteger . abs . unparseToNum + signum = fromInteger . signum . unparseToNum + negate = fromInteger . negate . unparseToNum + fromInteger _ = Variation $ UGroup [] + +instance + ( Num (Item t) + , Num (Variation ('GGroup o ts)) + , KnownNat (BitSizeOf ts) + ) => Num (Variation ('GGroup o (t ': ts))) where + a + b = fromInteger (unparseToNum a + unparseToNum b) + a * b = fromInteger (unparseToNum a * unparseToNum b) + abs = fromInteger . abs . unparseToNum + signum = fromInteger . signum . unparseToNum + negate = fromInteger . negate . unparseToNum + fromInteger i = + let n = natVal (Proxy @(BitSizeOf ts)) + (a, b) = divMod i (2 ^ n) + x = unItem $ fromInteger @(Item t) a + xs = case fromInteger @(Variation ('GGroup o ts)) b of + Variation (UGroup lst) -> lst + _ -> intError + in Variation $ UGroup (x : xs) + +instance + ( Num (Variation t) + ) => Num (RuleVar ('GContextFree t)) where + a + b = fromInteger (unparseToNum a + unparseToNum b) + a * b = fromInteger (unparseToNum a * unparseToNum b) + abs = fromInteger . abs . unparseToNum + signum = fromInteger . signum . unparseToNum + negate = fromInteger . negate . unparseToNum + fromInteger = RuleVar . URuleVar . unVariation + . fromInteger @(Variation t) + +instance + ( Num (Variation t) + ) => Num (RuleVar ('GDependent ts1 t ts2)) where + a + b = fromInteger (unparseToNum a + unparseToNum b) + a * b = fromInteger (unparseToNum a * unparseToNum b) + abs = fromInteger . abs . unparseToNum + signum = fromInteger . signum . unparseToNum + negate = fromInteger . negate . unparseToNum + fromInteger = RuleVar . URuleVar . unVariation + . fromInteger @(Variation t) + +instance + ( Num (RuleVar rv) + ) => Num (NonSpare ('GNonSpare name title rv)) where + a + b = fromInteger (unparseToNum a + unparseToNum b) + a * b = fromInteger (unparseToNum a * unparseToNum b) + abs = fromInteger . abs . unparseToNum + signum = fromInteger . signum . unparseToNum + negate = fromInteger . negate . unparseToNum + fromInteger = NonSpare . UNonSpare . unRuleVar . fromInteger @(RuleVar rv) + +instance + ( KnownNat8 o + , KnownNat n + ) => Num (Item ('GSpare o n)) where + a + b = fromInteger (unparseToNum a + unparseToNum b) + a * b = fromInteger (unparseToNum a * unparseToNum b) + abs = fromInteger . abs . unparseToNum + signum = fromInteger . signum . unparseToNum + negate = fromInteger . negate . unparseToNum + fromInteger = Item . USpare . integerToBits + (unInt8 $ natVal8 (Proxy @o)) + (fromInteger $ natVal (Proxy @n)) + +instance + ( Num (NonSpare nsp) + ) => Num (Item ('GItem nsp)) where + a + b = fromInteger (unparseToNum a + unparseToNum b) + a * b = fromInteger (unparseToNum a * unparseToNum b) + abs = fromInteger . abs . unparseToNum + signum = fromInteger . signum . unparseToNum + negate = fromInteger . negate . unparseToNum + fromInteger = Item . UItem . unNonSpare . fromInteger @(NonSpare nsp) + +-- | The Asterix.Base module performs the actual parsing. +-- This structure tells how to store parsing results. +parsingStore :: ParsingStore UVariation URuleVar UNonSpare UItem URecord UExpansion +parsingStore = ParsingStore + -- variations + { psElement = UElement + , psGroup = \_bits lst -> UGroup lst + , psExtended = UExtended . bitsToSBuilder + , psRepetitive = URepetitive . bitsToSBuilder + , psExplicit = UExplicit . bitsToSBuilder + , psCompound = \rawFspec rawItems items -> UCompound + (bitsToSBuilder rawFspec <> bitsToSBuilder rawItems) items + + -- rule variation + , psRuleVar = URuleVar + + -- non-spare + , psNsp = UNonSpare + + -- items + , psSpare = USpare + , psItem = UItem + + -- record + , psRecord = \rawFspec rawItems items -> URecord + (bitsToSBuilder rawFspec <> bitsToSBuilder rawItems) items + + -- expansion + , psExpansion = \rawFspec rawItems items -> UExpansion + (bitsToSBuilder rawFspec <> bitsToSBuilder rawItems) items + } + +-- | ParsingM with some type parameters instantiated. +type Parsing pm = ParsingM pm UVariation URuleVar UNonSpare UItem URecord UExpansion + +-- | The actual parsing function. +parse :: forall pm r. + ( KnownParsingMode pm + ) + => Parsing pm r -- ^ parsing action, returning result 'r' + -> ByteString -- ^ input + -> Either ParsingError r -- ^ parsing result +parse act bs = do + (result, o) <- runParsing act (Env parsingStore bs) 0 + case parsingMode @pm Proxy of + StrictParsing -> case o == endOffset bs of + True -> pure result + False -> Left "remaining bits" + PartialParsing -> pure result + +-- Constructing + +-- | Type level index. +data Ix + = IxItem Symbol + | IxRfs Nat + +-- | Indexed value. +newtype Indexed (ix :: Ix) a = Indexed a + deriving (Eq, Show) + +-- | Named value. +type Named name = Indexed ('IxItem name) + +-- | Random field sequencing. +type Rfs cnt ts = Indexed ('IxRfs cnt) (HList ts) + +deriving instance (Num a) => Num (Indexed ('IxItem name) a) + +-- | Helper function to construct (Named) items. +item :: forall name a. a -> Named name a +item = Indexed + +-- | Helper function to construct RFS. +rfs :: forall cnt ts. HList ts -> Rfs cnt ts +rfs = Indexed + +-- | Reserved spare bits might contain non-zero value. +newtype AbuseSpare a = AbuseSpare a + deriving (Eq, Show, Num) + +-- | Set spare bits to any value. +abuseSpare :: a -> AbuseSpare a +abuseSpare = AbuseSpare + +-- | Construct spare bits. +spare :: Num a => AbuseSpare a +spare = abuseSpare 0 + +-- | Data structure, representing Fx bit. +data Fx = Fx + deriving (Eq, Show) + +-- | Fx bit constructor. +fx :: Fx +fx = Fx + +-- Construct string + +-- | Function name overloading for different resulting types. +class MkString t where + string :: String -> t + +instance + ( KnownNat8 o + , KnownNat n + , Schema st GStringType + ) => MkString (Variation ('GElement o n ('GContextFree + ('GContentString st)))) + where + string val = Variation $ UElement $ integerToBits + (unInt8 $ natVal8 @o Proxy) + (fromIntegral $ natVal @n Proxy) + (foldInt 0 $ unChar <$> padAndStrip val) + where + + padChar :: Char + padChar = case schema @st Proxy of + GStringAscii -> ' ' + GStringICAO -> ' ' + GStringOctal -> '0' + + bpc :: Int + bpc = bitsPerChar (schema @st Proxy) + + foldInt :: Integer -> [Integer] -> Integer + foldInt acc = \case + [] -> acc + (x : xs) -> foldInt (acc*(2^bpc) + x) xs + + unChar :: Char -> Integer + unChar ch = fromIntegral $ case schema @st Proxy of + GStringAscii -> ord ch + GStringICAO -> if + | isAsciiUpper ch -> 0x01 + ord ch - ord 'A' + | ch == ' ' -> 0x20 + | isDigit ch -> 0x30 + ord ch - ord '0' + | otherwise -> 0 + GStringOctal -> ord ch - ord '0' + + padAndStrip :: String -> String + padAndStrip s = take n (s <> repeat padChar) where + n = fromIntegral (natVal @n Proxy) `div` bpc + +instance + ( MkString (Variation var) + ) => MkString (RuleVar ('GContextFree var)) where + string = RuleVar . URuleVar . unVariation . string @(Variation var) + +instance + ( MkString (RuleVar rv) + ) => MkString (NonSpare ('GNonSpare name title rv)) where + string = NonSpare . UNonSpare . unRuleVar . string @(RuleVar rv) + +instance + ( MkString (NonSpare nsp) + ) => MkString (Item ('GItem nsp)) where + string = Item . UItem . unNonSpare . string @(NonSpare nsp) + +instance + ( MkString val + , item ~ Item ('GItem nsp) + , nsp ~ 'GNonSpare name2 title rv + , name1 ~ name2 + ) => MkString (Named name1 val) + where + string = item . string @val + +-- Construct quantity + +-- | A Double wrapper with statically known unit, such as NM. +newtype Quantity (unit :: Symbol) (ruleIx :: (Maybe Nat)) = Quantity + { unQuantity :: Double + } deriving (Eq, Ord, Show, Num, Fractional) + +-- There is a lot of code just to extract the lsb out of the type. +-- This would otherwise be easy to do on value level schema, however +-- we want type safety on 'unit' matching. + +-- | Helper class to extract 'lsb' value, required for quantity function. +class GetLsb unit ruleIx t where + getLsb :: VNumber + +instance + ( Schema lsb VNumber + , ruleIx ~ 'Nothing + , unit1 ~ unit2 + ) => GetLsb unit1 ruleIx (Variation + ('GElement o n ('GContextFree ('GContentQuantity sig lsb unit2)))) + where + getLsb = schema @lsb Proxy + +-- | Helper class to handle dependent cases. +class GetLsb2 (flag :: Bool) (unit :: Symbol) (ix :: Nat) (rules :: [k]) + where + getLsb2 :: Proxy flag -> Proxy unit -> Proxy ix -> Proxy rules -> VNumber + +instance + ( ix ~ 0 + , unit1 ~ unit2 + , Schema lsb VNumber + ) => GetLsb2 'True unit1 ix ( '( val, 'GContentQuantity sig lsb unit2) ': ts) + where + getLsb2 _ _ _ _ = schema @lsb Proxy + +instance + ( iy ~ ix - 1 + , flag ~ (iy == 0) + , GetLsb2 flag unit iy ts + ) => GetLsb2 'False unit ix (t ': ts) + where + getLsb2 _ _ _ _ + = getLsb2 (Proxy @flag) (Proxy @unit) (Proxy @iy) (Proxy @ts) + +-- We can now define GetLsb instance using the auxilary GetLsb2 +instance + ( ruleIx ~ 'Just ix + , flag ~ (ix == 0) + , GetLsb2 flag unit ix rules + ) => GetLsb unit ruleIx (Variation + ('GElement o n ('GDependent sel dt rules))) + where + getLsb = getLsb2 (Proxy @flag) (Proxy @unit) (Proxy @ix) (Proxy @rules) + +-- | Function name overloading for different output types. +class MkQuantity unit ruleIx t where + quantity :: Quantity unit ruleIx -> t + +-- | When converting from Double to t, the 'sig' field is not important. +-- It only becomes important when converting back from t to Double. +processQuantity :: Int8 -> Int -> Double -> Quantity unit ruleIx -> Variation t +processQuantity (Int8 o) n lsb = Variation . UElement . integerToBits o n + . round . (/ lsb) . unQuantity + +instance + ( KnownNat8 o + , KnownNat n + , GetLsb unit ruleIx (Variation (GElement o n rc)) + ) => MkQuantity unit ruleIx (Variation ('GElement o n rc)) + where + quantity = + let lsb = getLsb @unit @ruleIx @(Variation ('GElement o n rc)) + in processQuantity + (natVal8 @o Proxy) + (fromIntegral $ natVal @n Proxy) + (evalNum lsb) + +instance + ( MkQuantity unit ix (Variation var) + ) => MkQuantity unit ix (RuleVar ('GContextFree var)) + where + quantity = RuleVar . URuleVar . unVariation + . quantity @unit @ix @(Variation var) + +instance + ( MkQuantity unit ix (RuleVar rv) + ) => MkQuantity unit ix (NonSpare ('GNonSpare name title rv)) + where + quantity = NonSpare . UNonSpare . unRuleVar + . quantity @unit @ix @(RuleVar rv) + +instance + ( MkQuantity unit ix (NonSpare nsp) + ) => MkQuantity unit ix (Item ('GItem nsp)) + where + quantity = Item . UItem . unNonSpare + . quantity @unit @ix @(NonSpare nsp) + +instance + ( MkQuantity unit ix val + ) => MkQuantity unit ix (Named name val) + where + quantity = item . quantity @unit @ix @val + +-- Group construction +-- +-- It's implemented in 2 staged: +-- - CGroup instances creates [UItem] +-- - MkGroup instances creates target types +-- (Variation, NonSpare, Item, Named) + +-- | Helper class to construct groups. +class CGroup ts2 ts1 where + groupConstruct :: Proxy ts2 -> HList ts1 -> [UItem] + +instance + TypeError ('Text "CGroup missing spare item") + => CGroup ('GSpare o n ': ts) '[] where + groupConstruct = intError + +instance + TypeError ('Text "CGroup missing item: " :<>: 'ShowType name) + => CGroup ('GItem ('GNonSpare name title rv) ': ts) '[] where + groupConstruct = intError + +instance + TypeError ('Text "CGroup unexpected item: " :<>: 'ShowType t) + => CGroup '[] (t ': ts) where + groupConstruct = intError + +instance CGroup '[] '[] where + groupConstruct _ _ = [] + +instance + ( t1 ~ AbuseSpare a + , a ~ Item ('GSpare o n) + , CGroup ts2 ts1 + ) => CGroup ('GSpare o n ': ts2) (t1 ': ts1) where + groupConstruct _proxy (HCons (AbuseSpare x) xs) = + unItem x : groupConstruct (Proxy @ts2) xs + +instance + ( t1 ~ Named name1 a + , a ~ Item ('GItem ('GNonSpare name2 title rv)) + , name1 ~ name2 + , CGroup ts2 ts1 + ) => CGroup ('GItem ('GNonSpare name2 title rv) ': ts2) (t1 ': ts1) where + groupConstruct _proxy (HCons (Indexed x) xs) + = unItem x : groupConstruct (Proxy @ts2) xs + +-- | 'group' function is overloaded for different output types +class MkGroup t ts1 where + group :: HList ts1 -> t + +instance + ( CGroup ts2 ts1 + ) => MkGroup (Variation ('GGroup o ts2)) ts1 where + group lst1 = Variation $ UGroup lst2 where + lst2 :: [UItem] + lst2 = groupConstruct (Proxy @ts2) lst1 + +instance + ( MkGroup (Variation var) ts1 + ) => MkGroup (NonSpare ('GNonSpare name title ('GContextFree var))) ts1 + where + group = NonSpare . UNonSpare . URuleVar . unVariation + . group @(Variation var) + +instance + ( MkGroup (NonSpare ('GNonSpare name title rv)) ts1 + ) => MkGroup (Item ('GItem ('GNonSpare name title rv))) ts1 + where + group = Item . UItem . unNonSpare + . group @(NonSpare ('GNonSpare name title rv)) + +instance + ( name1 ~ name2 + , MkGroup (Item ('GItem ('GNonSpare name2 title (GContextFree var)))) ts1 + ) => MkGroup (Named name1 + (Item ('GItem ('GNonSpare name2 title ('GContextFree var))))) ts1 + where + group = item + . group @(Item ('GItem ('GNonSpare name2 title ('GContextFree var)))) + +-- Extended construction +-- +-- It's implemented in 2 stages +-- - CExtended instances create [Maybe UItem] +-- - MkExtended, MkExtendedGroups create target types +-- It is possible to construct extended either by +-- 1) extended (HList of individual items, fx...) +-- 2) extendedGroups (HList of groups-of-items) + +-- Extended construction by items + +-- | Helper class to construct extended item. +class CExtended ts2 done ts1 where + extendedConstruct :: Proxy ts2 -> Proxy done -> HList ts1 -> [Maybe UItem] + +instance + TypeError ('Text "CExtended missing FX item") + => CExtended ('Nothing ': ts) 'False '[] where + extendedConstruct = intError + +instance + TypeError ('Text "CExtended missing spare item") + => CExtended ('Just ('GSpare o n) ': ts) 'False '[] where + extendedConstruct = intError + +instance + TypeError ('Text "CExtended missing item: " :<>: 'ShowType name) + => CExtended ('Just ('GItem ('GNonSpare name title rv)) ': ts) 'False '[] where + extendedConstruct = intError + +instance + TypeError ('Text "CExtended unexpected item: " :<>: 'ShowType t) + => CExtended '[] done (t ': ts) where + extendedConstruct = intError + +instance CExtended ts2 'True '[] where + extendedConstruct _p1 _p2 _hlst = [] + +instance CExtended '[] 'False '[] where + extendedConstruct _p1 _p2 _hlst = [] + +instance + ( t1 ~ Fx + , CExtended ts2 'True ts1 + ) => CExtended ('Nothing ': ts2) done (t1 ': ts1) where + extendedConstruct _p1 _p2 (HCons _fx xs) + = Nothing : extendedConstruct (Proxy @ts2) (Proxy @'True) xs + +instance + ( t1 ~ AbuseSpare a + , a ~ Item ('GSpare o n) + , CExtended ts2 'False ts1 + ) => CExtended ('Just ('GSpare o n) ': ts2) done (t1 ': ts1) where + extendedConstruct _p1 _p2 (HCons (AbuseSpare x) xs) + = Just (unItem x) : extendedConstruct (Proxy @ts2) (Proxy @'False) xs + +instance + ( t1 ~ Named name1 a + , a ~ Item ('GItem ('GNonSpare name2 title rv)) + , name1 ~ name2 + , CExtended ts2 'False ts1 + ) => CExtended ('Just ('GItem ('GNonSpare name2 title rv)) ': ts2) done + (t1 ': ts1) + where + extendedConstruct _p1 _p2 (HCons (Indexed x) xs) + = Just (unItem x) : extendedConstruct (Proxy @ts2) (Proxy @'False) xs + +-- | 'extended' function is overloaded for different output types +class MkExtended t ts1 where + extended :: HList ts1 -> t + +instance + ( CExtended ts2 'False ts1 + ) => MkExtended (Variation ('GExtended ts2)) ts1 + where + extended lst1 = Variation $ UExtended bld lst2 + where + lst2 :: [Maybe UItem] + lst2 = extendedConstruct (Proxy @ts2) (Proxy @'False) lst1 + + bld :: SBuilder + bld = bitsToSBuilder $ recreateExtended lst2 + +instance + ( MkExtended (Variation var) ts1 + ) => MkExtended (NonSpare ('GNonSpare name title ('GContextFree var))) ts1 + where + extended = NonSpare . UNonSpare . URuleVar . unVariation + . extended @(Variation var) + +instance + ( MkExtended (NonSpare ('GNonSpare name title rv)) ts1 + ) => MkExtended (Item ('GItem ('GNonSpare name title rv))) ts1 + where + extended = Item . UItem . unNonSpare + . extended @(NonSpare ('GNonSpare name title rv)) + +instance + ( name1 ~ name2 + , MkExtended (Item ('GItem ('GNonSpare name2 title (GContextFree var)))) ts1 + ) => MkExtended (Named name1 + (Item ('GItem ('GNonSpare name2 title ('GContextFree var))))) ts1 + where + extended = item + . extended @(Item ('GItem ('GNonSpare name2 title ('GContextFree var)))) + +-- Extended construction by groups + +-- | Helper class to construct extended groups. +class CExtendedGroups ts2 ts1 where + extendedConstructGroups :: Proxy ts2 -> HList ts1 -> [Maybe UItem] + +instance + ( TypeError ('Text + "CExtendedGroups at least one extended group shall be provided") + ) => CExtendedGroups ts2 '[] where + extendedConstructGroups = intError + +instance -- this instance matches last group (t1 ': '[]) + ( t1 ~ Variation ('GGroup 0 lst) + , lst ~ ExtendedFirstGroup ts2 + , fx ~ ExtendedTrailingFx ts2 + , KnownBool fx + ) => CExtendedGroups ts2 (t1 ': '[]) where + extendedConstructGroups _p (HCons (Variation val) HNil) = case val of + UGroup lst -> fmap Just lst <> trailingFx + _ -> intError + where + appendFx = boolVal @fx Proxy + trailingFx = bool [] [Nothing] appendFx + +instance -- this instance matches non-last group (t1 ': t2 ': '[]) + ( t1 ~ Variation ('GGroup 0 lst) + , lst ~ ExtendedFirstGroup ts2 + , ts3 ~ ExtendedRemainingItems ts2 + , CExtendedGroups ts3 (t2 ': ts1) + ) => CExtendedGroups ts2 (t1 ': t2 ': ts1) where + extendedConstructGroups _p (HCons (Variation val) xs) = case val of + UGroup lst -> + fmap Just lst + <> [Nothing] + <> extendedConstructGroups @ts3 @(t2 ': ts1) Proxy xs + _ -> intError + +-- | 'extendedGroups' function is overloaded for different output types +class MkExtendedGroups t ts1 where + extendedGroups :: HList ts1 -> t + +instance + ( CExtendedGroups ts2 ts1 + ) => MkExtendedGroups (Variation ('GExtended ts2)) ts1 + where + extendedGroups lst1 = Variation $ UExtended bld lst2 + where + lst2 :: [Maybe UItem] + lst2 = extendedConstructGroups (Proxy @ts2) lst1 + + bld :: SBuilder + bld = bitsToSBuilder $ recreateExtended lst2 + +instance + ( MkExtendedGroups (Variation var) ts1 + ) => MkExtendedGroups (NonSpare ('GNonSpare name title ('GContextFree var))) + ts1 + where + extendedGroups = NonSpare . UNonSpare . URuleVar . unVariation + . extendedGroups @(Variation var) + +instance + ( MkExtendedGroups (NonSpare ('GNonSpare name title rv)) ts1 + ) => MkExtendedGroups (Item ('GItem ('GNonSpare name title rv))) ts1 + where + extendedGroups = Item . UItem . unNonSpare + . extendedGroups @(NonSpare ('GNonSpare name title rv)) + +instance + ( name1 ~ name2 + , MkExtendedGroups (Item ('GItem ('GNonSpare name2 title (GContextFree var)))) + ts1 + ) => MkExtendedGroups (Named name1 + (Item ('GItem ('GNonSpare name2 title ('GContextFree var))))) ts1 + where + extendedGroups = item . extendedGroups + @(Item ('GItem ('GNonSpare name2 title ('GContextFree var)))) + +-- Repetitive construction + +-- | 'repetitive' function is overloaded for different output types +class MkRepetitive t2 t1 | t2 -> t1 where + type RepetitiveInputList t2 :: Type -> Type + repetitive :: RepetitiveInputList t2 t1 -> t2 + +instance + ( KnownNat n + ) => MkRepetitive + (Variation ('GRepetitive ('GRepetitiveRegular n) var)) + (Variation var) + where + type RepetitiveInputList + (Variation ('GRepetitive ('GRepetitiveRegular n) var)) = [] + repetitive lst1 = Variation $ URepetitive bld lst2 + where + lst2 :: [UVariation] + lst2 = fmap unVariation lst1 + + bld :: SBuilder + bld = + let nBytes = fromIntegral $ natVal (Proxy @n) + n = integerToBits 0 (nBytes*8) + (fromIntegral $ Prelude.length lst2) + items = fmap unparse lst1 + in bitsToSBuilder $ concatBits (n NE.:| items) + +instance MkRepetitive + (Variation ('GRepetitive 'GRepetitiveFx var)) + (Variation var) + where + type RepetitiveInputList + (Variation ('GRepetitive 'GRepetitiveFx var)) = NE.NonEmpty + repetitive lst1 = Variation $ URepetitive (bld lst1) lst2 + where + lst2 :: [UVariation] + lst2 = fmap unVariation (NE.toList lst1) + + addFx :: Bool -> Bits -> Bits + addFx flag arg = appendBits arg (boolsToBits 7 [flag]) + + bld :: NE.NonEmpty (Variation var) -> SBuilder + bld = bitsToSBuilder + . concatBits + . NE.reverse + . NE.zipWith addFx (False NE.:| repeat True) + . NE.reverse + . fmap unparse + +instance + ( MkRepetitive (Variation var) ts1 + ) => MkRepetitive (NonSpare ('GNonSpare name title ('GContextFree var))) ts1 + where + type RepetitiveInputList (NonSpare ('GNonSpare name title ('GContextFree var))) + = RepetitiveInputList (Variation var) + repetitive = NonSpare . UNonSpare . URuleVar . unVariation + . repetitive @(Variation var) + +instance + ( MkRepetitive (NonSpare ('GNonSpare name title rv)) ts1 + ) => MkRepetitive (Item ('GItem ('GNonSpare name title rv))) ts1 + where + type RepetitiveInputList (Item ('GItem ('GNonSpare name title rv))) + = RepetitiveInputList (NonSpare ('GNonSpare name title rv)) + repetitive = Item . UItem . unNonSpare + . repetitive @(NonSpare ('GNonSpare name title rv)) + +instance + ( name1 ~ name2 + , MkRepetitive (Item ('GItem ('GNonSpare name2 title (GContextFree var)))) + ts1 + ) => MkRepetitive (Named name1 + (Item ('GItem ('GNonSpare name2 title ('GContextFree var))))) ts1 + where + type RepetitiveInputList + (Named name1 + (Item ('GItem ('GNonSpare name2 title ('GContextFree var))))) + = RepetitiveInputList + (Item ('GItem ('GNonSpare name2 title (GContextFree var)))) + repetitive = item . repetitive + @(Item ('GItem ('GNonSpare name2 title ('GContextFree var)))) + +-- | 'explicit' function is overloaded for different output types +class MkExplicit t2 t1 where + explicit :: t1 -> t2 + +instance + ( Unparsing SBuilder t1 + , Unparsing Bits t1 + ) => MkExplicit (Variation var) t1 + where + explicit val = Variation $ UExplicit bld s where + s :: Bits + s = unparse val + + nBytes :: Int + nBytes = numBytes $ bitsSize s + + n :: SBuilder + n = bitsToSBuilder $ integerToBits 0 8 (succ $ fromIntegral nBytes) + + bld :: SBuilder + bld = n <> unparse val + +instance + ( MkExplicit (Variation var) t1 + ) => MkExplicit (NonSpare ('GNonSpare name title ('GContextFree var))) t1 + where + explicit = NonSpare . UNonSpare . URuleVar . unVariation + . explicit @(Variation var) + +instance + ( MkExplicit (NonSpare ('GNonSpare name title rv)) ts1 + ) => MkExplicit (Item ('GItem ('GNonSpare name title rv))) ts1 + where + explicit = Item . UItem . unNonSpare + . explicit @(NonSpare ('GNonSpare name title rv)) + +instance + ( name1 ~ name2 + , MkExplicit (Item ('GItem ('GNonSpare name2 title (GContextFree var)))) + ts1 + ) => MkExplicit (Named name1 + (Item ('GItem ('GNonSpare name2 title ('GContextFree var))))) ts1 + where + explicit = item . explicit + @(Item ('GItem ('GNonSpare name2 title ('GContextFree var)))) + +-- | Helper class for compound and record construction. +class CSetItem nsp ts1 where + cSetItem :: Proxy nsp -> HList ts1 -> Maybe UNonSpare + +instance CSetItem nsp '[] where + cSetItem _p _hlist = Nothing + +instance {-# OVERLAPPING #-} + ( nsp ~ NonSpare ('GNonSpare name title rv) + ) => CSetItem ('GNonSpare name title rv) (Named name nsp ': ts) + where + cSetItem _p (HCons (Indexed nsp) _ts) = Just $ unNonSpare nsp + +instance + ( CSetItem ('GNonSpare name1 title rv) ts + ) => CSetItem ('GNonSpare name1 title rv) (Named name2 nsp ': ts) + where + cSetItem p (HCons _nsp ts) = cSetItem p ts + +-- | Check if name is present in HList. +type family ElemName ix ts where + ElemName ix '[] = 'False + ElemName ix (Named ix1 a ': ts) = If (ix == ix1) 'True (ElemName ix ts) + ElemName ix (Rfs cnt a ': ts) = ElemName ix ts + ElemName ix ts = TypeError ('Text "ElemName unexpected argument: " + :<>: 'ShowType ix :<>: 'Text ", " :<>: 'ShowType ts) + +-- | Check if rfs index is present in HList. +type family ElemRfs ix ts where + ElemRfs ix '[] = 'False + ElemRfs ix (Named name a ': ts) = ElemRfs ix ts + ElemRfs ix (Rfs cnt a ': ts) = If (ix == cnt) 'True (ElemRfs ix ts) + ElemRfs ix ts = TypeError ('Text "ElemRfs unexpected argument: " + :<>: 'ShowType ix :<>: 'Text ", " :<>: 'ShowType ts) + +-- | Assert there are no duplicates in a HList +-- This type level function could simply return the constraint, +-- however, GHC sometimes takes it as redundant, so return types instead. +type family NoDuplicates t where + NoDuplicates '[] = '[] + NoDuplicates (Named name a ': ts) = If + (ElemName name ts) + (TypeError ('Text "NoDuplicates duplicated item: " :<>: 'ShowType name)) + (Named name a ': NoDuplicates ts) + NoDuplicates (Rfs cnt a ': ts) = If + (ElemRfs cnt ts) + (TypeError ('Text "NoDuplicates duplicated rfs: " :<>: 'ShowType cnt)) + (Rfs cnt a ': NoDuplicates ts) + NoDuplicates t + = TypeError ('Text "NoDuplicates unexpected argument: " :<>: 'ShowType t) + +-- Compound construction + +-- | Check if name is defined inside Compound. +type family IsDefinedCompound ts name where + IsDefinedCompound '[] name = 'False + IsDefinedCompound ('Nothing ': ts) name = IsDefinedCompound ts name + IsDefinedCompound ('Just ('GNonSpare name1 title rv) ': ts) name = If + (name1 == name) + 'True + (IsDefinedCompound ts name) + IsDefinedCompound ts name + = TypeError ('Text "IsDefinedCompound unexpected argument: " + :<>: 'ShowType ts :<>: 'Text ", " :<>: 'ShowType name) + +-- | Check if all names are defined inside Compound. +type family AllDefinedCompound ts2 ts1 where + AllDefinedCompound ts2 '[] = '[] + AllDefinedCompound ts2 (Named name rv ': ts) = If + (IsDefinedCompound ts2 name == 'True) + (Named name rv ': AllDefinedCompound ts2 ts) + (TypeError ('Text "AllDefinedCompound unknown item: " :<>: 'ShowType name)) + AllDefinedCompound ts2 ts1 + = TypeError ('Text "AllDefinedCompound unexpected argument: " + :<>: 'ShowType ts2 :<>: 'Text ", " :<>: 'ShowType ts1) + +-- | Helper class to construct compound item. +class CCompound ts2 ts1 where + compoundConstruct :: Proxy ts2 -> HList ts1 -> [Maybe UNonSpare] + +instance CCompound '[] ts1 where + compoundConstruct _p1 _hlist = [] + +instance + ( CCompound ts ts1 + ) => CCompound ('Nothing ': ts) ts1 where + compoundConstruct _p1 hlist + = Nothing + : compoundConstruct (Proxy @ts) hlist + +instance + ( CCompound ts ts1 + , CSetItem nsp ts1 + ) => CCompound ('Just nsp ': ts) ts1 where + compoundConstruct _p1 hlist + = cSetItem (Proxy @nsp) hlist + : compoundConstruct (Proxy @ts) hlist + +-- Compound item is created from HList, where +-- - items are specified in any order +-- - duplicates are not allowed +-- - all items must be named and valid + +-- | 'compound' function is overloaded for different output types +class MkCompound t ts1 where + compound :: HList ts1 -> t + +rebuildCompound :: Unparsing Bits a => [Maybe a] -> SBuilder +rebuildCompound items = mkFspecFx (fmap isJust items) + <> mconcat (bitsToSBuilder . unparse <$> catMaybes items) + +instance + ( CCompound ts2 ts1 + , NoDuplicates ts1 ~ ts1 + , AllDefinedCompound ts2 ts1 ~ ts1 + ) => MkCompound (Variation ('GCompound ts2)) ts1 where + compound lst1 = Variation $ UCompound bld items where + items :: [Maybe UNonSpare] + items = compoundConstruct @ts2 @(AllDefinedCompound ts2 (NoDuplicates ts1)) + Proxy lst1 + + bld :: SBuilder + bld = rebuildCompound items + +instance + ( MkCompound (Variation var) ts1 + ) => MkCompound (NonSpare ('GNonSpare name title ('GContextFree var))) ts1 + where + compound = NonSpare . UNonSpare . URuleVar . unVariation + . compound @(Variation var) + +instance + ( MkCompound (NonSpare ('GNonSpare name title rv)) ts1 + ) => MkCompound (Item ('GItem ('GNonSpare name title rv))) ts1 + where + compound = Item . UItem . unNonSpare + . compound @(NonSpare ('GNonSpare name title rv)) + +instance + ( name1 ~ name2 + , MkCompound (Item ('GItem ('GNonSpare name2 title (GContextFree var)))) ts1 + ) => MkCompound (Named name1 + (Item ('GItem ('GNonSpare name2 title ('GContextFree var))))) ts1 + where + compound = item + . compound @(Item ('GItem ('GNonSpare name2 title ('GContextFree var)))) + +-- Record construction +-- +-- Record is constructed similar to 'compound' item, except: +-- - Result is always a Record, so no need to overload 'record' for that +-- reason, but there are cases, depending on number of allowed RFS blocks. +-- - Input HList may include RFS blocks too. +-- - Regular items follow the same rules (any order, no duplication) +-- - RFS blocks rules: +-- - If the record spec does not include RFS, there shall be no RFS +-- block in input HList. +-- - If the record spec contains 1 RFS flag, the can only be 0 or 1 +-- RFS block in the input HList. RFS block might be enumerated +-- with '@0' tag or without. +-- - Otherwise, if the record spec contains multiple RFS flags, they +-- must be enumerated in HList, but the order of specification +-- is not important. They should not be duplicated. +-- - The items inside RFS block may be duplicated and specified in the +-- order or required result. + +-- | Helper type level function to count Rfs flags. +type family MaxRfs ts where + MaxRfs '[] = 0 + MaxRfs ('GUapItem nsp ': ts) = MaxRfs ts + MaxRfs ('GUapItemSpare ': ts) = MaxRfs ts + MaxRfs ('GUapItemRFS ': ts) = 1 + MaxRfs ts + MaxRfs ts = TypeError ('Text "MaxRfs unexpected argument: " :<>: 'ShowType ts) + +-- | Check if name is defined inside record. +type family IsDefinedRecord ts name where + IsDefinedRecord '[] name = 'False + IsDefinedRecord ('GUapItem ('GNonSpare name1 title rv) ': ts) name2 = If + (name1 == name2) + 'True + (IsDefinedRecord ts name2) + IsDefinedRecord ('GUapItemSpare ': ts) name2 = IsDefinedRecord ts name2 + IsDefinedRecord ('GUapItemRFS ': ts) name2 = IsDefinedRecord ts name2 + IsDefinedRecord ts name + = TypeError ('Text "IsDefinedRecord unexpected argument: " + :<>: 'ShowType ts :<>: 'Text ", " :<>: 'ShowType name) + +-- | Helper type level function to check if Rfs is specified. +type family IsDefinedRfs ix ts cnt where + IsDefinedRfs ix '[] cnt = 'False + IsDefinedRfs ix ('GUapItem nsp ': ts) cnt = IsDefinedRfs ix ts cnt + IsDefinedRfs ix ('GUapItemSpare ': ts) cnt = IsDefinedRfs ix ts cnt + IsDefinedRfs ix ('GUapItemRFS ': ts) cnt = If + (ix == cnt) + 'True + (IsDefinedRfs (ix+1) ts cnt) + IsDefinedRfs ix ts cnt + = TypeError ('Text "IsDefinedRfs unexpected argument: " + :<>: 'ShowType ts :<>: 'Text ", " :<>: 'ShowType cnt) + +-- | Helper function to check if all record items are actually defined. +type family AllDefinedRecord ts2 ts1 where + AllDefinedRecord ts2 '[] = '[] + AllDefinedRecord ts2 (Named name rv ': ts) = If + (IsDefinedRecord ts2 name == 'True) + (Named name rv ': AllDefinedRecord ts2 ts) + (TypeError ('Text "AllDefinedRecord unknown item: " :<>: 'ShowType name)) + AllDefinedRecord ts2 (Rfs cnt a ': ts) = If + (IsDefinedRfs 0 ts2 cnt == 'True) + (Rfs cnt a ': AllDefinedRecord ts2 ts) + (TypeError ('Text "AllDefinedRecord unknown rfs: " :<>: 'ShowType cnt)) + AllDefinedRecord ts2 ts1 + = TypeError ('Text "AllDefinedRecord unexpected argument: " + :<>: 'ShowType ts2 :<>: 'Text ", " :<>: 'ShowType ts1) + +-- | Recreate a record from some items. +rebuildRecord :: [Maybe (RecordItem UNonSpare)] -> SBuilder +rebuildRecord items + = mkFspecFx (fmap isJust items) + <> mconcat (unparse <$> catMaybes items) + +-- | Helper function to extract frame number from list of items. +getFrn :: Enum n + => n -- ^ accumulator + -> VText -- ^ item name to find + -> [VUapItem] -- ^ remaining candidates + -> n +getFrn acc name = \case + [] -> intError + (GUapItem (GNonSpare name2 _title _rv) : ts) -> case name == name2 of + True -> acc + False -> getFrn (succ acc) name ts + (GUapItemSpare : ts) -> getFrn (succ acc) name ts + (GUapItemRFS : ts) -> getFrn (succ acc) name ts + +-- | 'mkRfs' name overloading. +class MkRfs tsAll ts2 ts1 where + mkRfs :: HList ts1 -> [(FRN, UNonSpare)] + +instance MkRfs tsAll ts2 '[] where + mkRfs HNil = [] + +instance + ( TypeError ('Text "MkRfs item not defined: " :<>: 'ShowType name) + ) => MkRfs tsAll '[] (Named name nsp ': ts) where + mkRfs = intError + +instance {-# OVERLAPPING #-} + ( nsp ~ NonSpare ('GNonSpare name title rv) + , MkRfs tsAll tsAll ts2 + , KnownSymbol name + , Schema tsAll [VUapItem] + ) => MkRfs tsAll ('GUapItem ('GNonSpare name title rv) ': ts1) + (Named name nsp ': ts2) where + mkRfs (HCons (Indexed (NonSpare x)) xs) + = (getFrn 1 (schema @name Proxy) (schema @tsAll Proxy), x) + : mkRfs @tsAll @tsAll xs + +instance + ( MkRfs tsAll ts1 (t2 : ts2) + ) => MkRfs tsAll (t1 ': ts1) (t2 ': ts2) where + mkRfs = mkRfs @tsAll @ts1 + +-- | Helper class to set items. +class RSetItem nsp ts1 where + rSetItem :: HList ts1 -> Maybe (RecordItem UNonSpare) + +instance RSetItem nsp '[] where + rSetItem _lst = Nothing + +instance {-# OVERLAPPING #-} + ( nsp ~ NonSpare ('GNonSpare name title rv) + ) => RSetItem ('GNonSpare name title rv) (Named name nsp ': ts) where + rSetItem (HCons (Indexed (NonSpare x)) _xs) = Just (RecordItem x) + +instance + ( RSetItem ('GNonSpare name title rv) ts + ) => RSetItem ('GNonSpare name title rv) (t ': ts) where + rSetItem (HCons _x xs) = rSetItem @('GNonSpare name title rv) xs + +-- | Helper class to set Rfs. +class RSetRfs (rfs :: Nat) tsAll ts1 where + rSetRfs :: HList ts1 -> Maybe (RecordItem UNonSpare) + +instance RSetRfs rfs tsAll '[] where + rSetRfs _lst = Nothing + +instance {-# OVERLAPPING #-} + ( MkRfs tsAll tsAll ts1 + ) => RSetRfs rfs tsAll (Indexed ('IxRfs rfs) (HList ts1) ': ts) where + rSetRfs (HCons (Indexed lst) _xs) + = Just $ RecordItemRFS (mkRfs @tsAll @tsAll lst) + +instance + ( RSetRfs rfs tsAll ts + ) => RSetRfs rfs tsAll (t ': ts) where + rSetRfs (HCons _x xs) = rSetRfs @rfs @tsAll xs + +-- | Helper class for constructing records. +class CRecord maxRfs rfs tsAll ts2 ts1 where + recordConstruct :: HList ts1 -> [Maybe (RecordItem UNonSpare)] + +instance CRecord (maxRfs :: Nat) (rfs :: Nat) tsAll '[] ts1 where + recordConstruct _lst = [] + +instance + ( CRecord maxRfs rfs tsAll ts ts1 + , RSetItem nsp ts1 + ) => CRecord maxRfs rfs tsAll ('GUapItem nsp ': ts) ts1 where + recordConstruct lst + = rSetItem @nsp lst + : recordConstruct @maxRfs @rfs @tsAll @ts lst + +instance + ( CRecord maxRfs rfs tsAll ts ts1 + ) => CRecord maxRfs rfs tsAll ('GUapItemSpare ': ts) ts1 where + recordConstruct lst + = Nothing + : recordConstruct @maxRfs @rfs @tsAll @ts lst + +instance + ( CRecord maxRfs (rfs+1) tsAll ts ts1 + , RSetRfs rfs tsAll ts1 + ) => CRecord maxRfs rfs tsAll ('GUapItemRFS ': ts) ts1 where + recordConstruct lst + = rSetRfs @rfs @tsAll lst + : recordConstruct @maxRfs @(rfs+1) @tsAll @ts lst + +-- | In case of a single rfs, we explicitly set it to 'rfs @0', +-- so that inside the application this type application '@0' +-- becomes optional. +class EnumerateRfs (single :: Bool) ts1 where + type EnumerateRfsR single ts1 :: [Type] + enumerateRfs :: HList ts1 -> HList (EnumerateRfsR single ts1) + +instance EnumerateRfs 'False ts1 where + type (EnumerateRfsR 'False ts1) = ts1 + enumerateRfs lst = lst + +instance EnumerateRfs 'True '[] where + type (EnumerateRfsR 'True '[]) = '[] + enumerateRfs lst = lst + +instance + ( EnumerateRfs 'True ts + ) => EnumerateRfs 'True (Named name a ': ts) where + type (EnumerateRfsR 'True (Named name a ': ts)) + = Named name a ': EnumerateRfsR 'True ts + enumerateRfs (HCons x xs) = HCons x (enumerateRfs @'True @ts xs) + +instance + ( EnumerateRfs 'True ts + , cnt ~ 0 + ) => EnumerateRfs 'True (Rfs cnt a ': ts) where + type (EnumerateRfsR 'True (Rfs cnt a ': ts)) + = Rfs 0 a ': EnumerateRfsR 'True ts + enumerateRfs (HCons x xs) = HCons x (enumerateRfs @'True @ts xs) + +-- | Record constructor function. +record :: forall ts2 ts1 ts1'. + ( ts1' ~ EnumerateRfsR (MaxRfs ts2 == 1) ts1 + , AllDefinedRecord ts2 (NoDuplicates ts1) ~ ts1' + , CRecord (MaxRfs ts2) 0 ts2 ts2 ts1' + , EnumerateRfs (MaxRfs ts2 == 1) ts1 + , NoDuplicates ts1 ~ ts1 + ) => HList ts1 -> Record ('GRecord ts2) +record lst = Record $ URecord bld items + where + items :: [Maybe (RecordItem UNonSpare)] + items = recordConstruct @(MaxRfs ts2) @0 @ts2 @ts2 + @(AllDefinedRecord ts2 (NoDuplicates ts1)) + (enumerateRfs @(MaxRfs ts2 == 1) lst) + + bld :: SBuilder + bld = rebuildRecord items + +-- Expansion construction + +-- | Expansion constructor function. +expansion :: forall mn ts2 ts1. + ( CCompound ts2 ts1 + , NoDuplicates ts1 ~ ts1 + , AllDefinedCompound ts2 ts1 ~ ts1 + , Schema mn (Maybe Int) + ) => HList ts1 -> Expansion ('GExpansion mn ts2) +expansion lst1 = Expansion $ UExpansion bld items + where + items :: [Maybe UNonSpare] + items = compoundConstruct @ts2 @(AllDefinedCompound ts2 (NoDuplicates ts1)) + Proxy lst1 + + fxbits :: SBuilder + fxbits = case schema @mn Proxy of + Nothing -> mkFspecFx (fmap isJust items) + Just nBytes -> mkFspecFixed nBytes (fmap isJust items) + + bld :: SBuilder + bld = fxbits + <> mconcat (bitsToSBuilder . unparse <$> catMaybes items) + +-- Datablock construction + +-- | Helper class to construct databock. +class CDatablock multi dbt ts where + datablockConstruct :: + Proxy multi -- multi UAP datablock (Bool) + -> Proxy dbt -- datablock type + -> HList ts -- list of records + -> [(Maybe VText, URecord)] + +instance CDatablock multi dbt '[] where + datablockConstruct _p1 _p2 _hlist = [] + +-- For single UAP situation, the type of record is determined +instance + ( CDatablock 'False dbt ts + , dbt ~ 'GDatablock cat uap + , t ~ TypeOfRecord dbt -- record must match + ) => CDatablock 'False dbt (Record t ': ts) where + datablockConstruct p1 p2 (HCons x xs) + = (Nothing, unRecord x) + : datablockConstruct p1 p2 xs + +-- For multi UAP situation, the type of record must be explicit +instance + ( CDatablock 'True dbt ts + , dbt ~ 'GDatablock cat uap + , uap ~ 'GUaps lst sel + , name ~ UapName t lst + , KnownSymbol name + ) => CDatablock 'True dbt (Record t ': ts) where + datablockConstruct p1 p2 (HCons x xs) + = (Just uapName, unRecord x) + : datablockConstruct p1 p2 xs + where + uapName = T.pack $ symbolVal (Proxy @name) + +-- | Helper function to compose datablock from records. +datablockBuilder :: Integral n => n -> [URecord] -> SBuilder +datablockBuilder cat lst = + let bldData = mconcat (unparse <$> lst) + n = sbByteSize bldData + 3 + (n1, n2) = divMod n 256 + in word8ToSBuilder (fromIntegral cat) + <> word8ToSBuilder (fromIntegral n1) + <> word8ToSBuilder (fromIntegral n2) + <> bldData + +-- | Datablock constructor function. +datablock :: forall dbt ts. + ( CDatablock (IsMultiUap dbt) dbt ts + , KnownNat (CategoryOf dbt) + ) => HList ts -> Datablock dbt +datablock lst = Datablock $ UDatablock bld records where + records :: [(Maybe VText, URecord)] + records = datablockConstruct (Proxy @(IsMultiUap dbt)) (Proxy @dbt) lst + + bld :: SBuilder + bld = datablockBuilder (natVal (Proxy @(CategoryOf dbt))) (fmap snd records) + +-- | Convert some types to 'String'. +class ToString ruleIx t where + asString :: t -> String + +instance + ( Schema st VStringType + , KnownNat n + ) => ToString ruleIx (Variation + ('GElement o n ('GContextFree ('GContentString st)))) + where + asString (Variation val) = case val of + UElement s -> bitsToString + (schema @st Proxy) + (fromIntegral $ natVal (Proxy @n)) + s + _ -> intError + +instance {-# OVERLAPPING #-} + ( Schema st VStringType + , KnownNat n + ) => ToString ('Just 0) (Variation + ('GElement o n ('GDependent ts1 dt + ( '(x, 'GContentString st) ': ts2)))) + where + asString (Variation val) = case val of + UElement s -> bitsToString + (schema @st Proxy) + (fromIntegral $ natVal (Proxy @n)) + s + _ -> intError + +instance + ( ToString (Just (ix - 1)) + (Variation (GElement o n (GDependent ts1 dt ts2))) + ) => ToString ('Just ix) (Variation + ('GElement o n ('GDependent ts1 dt + ( '(x, 'GContentString st) ': ts2)))) + where + asString (Variation val) = asString + @('Just (ix -1)) + @(Variation ('GElement o n ('GDependent ts1 dt ts2))) + (Variation val) + +instance + ( ToString ruleIx (Variation var) + ) => ToString ruleIx (RuleVar ('GContextFree var)) + where + asString = asString @ruleIx @(Variation var) + . Variation . unURuleVar . unRuleVar + +instance + ( ToString ruleIx (RuleVar rv) + ) => ToString ruleIx (NonSpare ('GNonSpare name title rv)) + where + asString = asString @ruleIx @(RuleVar rv) + . RuleVar . unUNonSpare . unNonSpare + +instance + ( ToString ruleIx (NonSpare nsp) + ) => ToString ruleIx (Item ('GItem nsp)) + where + asString (Item i) = case i of + UItem val -> asString @ruleIx @(NonSpare nsp) (NonSpare val) + _ -> intError + +-- | Convert some types to 'Integer'. +class ToInteger ruleIx t where + asInteger :: t -> Integer + +instance + ( Schema sig VSignedness + , KnownNat n + ) => ToInteger ruleIx (Variation + ('GElement o n ('GContextFree ('GContentInteger sig)))) + where + asInteger (Variation val) = case val of + UElement s -> bitsToInteger + (schema @sig Proxy) + (fromIntegral $ natVal (Proxy @n)) + s + _ -> intError + +instance {-# OVERLAPPING #-} + ( Schema sig VSignedness + , KnownNat n + ) => ToInteger ('Just 0) (Variation + ('GElement o n ('GDependent ts1 dt + ( '(x, 'GContentInteger sig) ': ts2)))) + where + asInteger (Variation val) = case val of + UElement s -> bitsToInteger + (schema @sig Proxy) + (fromIntegral $ natVal (Proxy @n)) + s + _ -> intError + +instance + ( ToInteger (Just (ix - 1)) + (Variation (GElement o n (GDependent ts1 dt ts2))) + ) => ToInteger ('Just ix) (Variation + ('GElement o n ('GDependent ts1 dt + ( '(x, 'GContentString st) ': ts2)))) + where + asInteger (Variation val) = asInteger + @('Just (ix -1)) + @(Variation ('GElement o n ('GDependent ts1 dt ts2))) + (Variation val) + +instance + ( ToInteger ruleIx (Variation var) + ) => ToInteger ruleIx (RuleVar ('GContextFree var)) + where + asInteger = asInteger @ruleIx @(Variation var) + . Variation . unURuleVar . unRuleVar + +instance + ( ToInteger ruleIx (RuleVar rv) + ) => ToInteger ruleIx (NonSpare ('GNonSpare name title rv)) + where + asInteger = asInteger @ruleIx @(RuleVar rv) + . RuleVar . unUNonSpare . unNonSpare + +instance + ( ToInteger ruleIx (NonSpare nsp) + ) => ToInteger ruleIx (Item ('GItem nsp)) + where + asInteger (Item i) = case i of + UItem val -> asInteger @ruleIx @(NonSpare nsp) (NonSpare val) + _ -> intError + +-- | Convert types to 'Quantity'. +class ToQuantity unit ruleIx t where + asQuantity :: t -> Quantity unit ruleIx + +instance + ( Schema sig VSignedness + , KnownNat n + , Schema lsb VNumber + , unit1 ~ unit2 + ) => ToQuantity unit1 ruleIx (Variation + ('GElement o n ('GContextFree ('GContentQuantity sig lsb unit2)))) + where + asQuantity (Variation val) = case val of + UElement s -> Quantity $ bitsToDouble + (schema @sig Proxy) + (fromIntegral $ natVal (Proxy @n)) + (evalNum $ schema @lsb Proxy) + s + _ -> intError + +instance {-# OVERLAPPING #-} + ( Schema sig VSignedness + , KnownNat n + , Schema lsb VNumber + , unit1 ~ unit2 + ) => ToQuantity unit1 ('Just 0) (Variation + ('GElement o n ('GDependent ts1 dt + ( '(x, 'GContentQuantity sig lsb unit2) ': ts2)))) + where + asQuantity (Variation val) = case val of + UElement s -> Quantity $ bitsToDouble + (schema @sig Proxy) + (fromIntegral $ natVal (Proxy @n)) + (evalNum $ schema @lsb Proxy) + s + _ -> intError + +instance + ( ToQuantity unit1 (Just (ix - 1)) + (Variation (GElement o n (GDependent ts1 dt ts2))) + ) => ToQuantity unit1 ('Just ix) (Variation + ('GElement o n ('GDependent ts1 dt + ( '(x, 'GContentQuantity sig lsb unit2) ': ts2)))) + where + asQuantity (Variation val) = Quantity $ unQuantity $ + asQuantity @unit1 @('Just (ix -1)) + @(Variation ('GElement o n ('GDependent ts1 dt ts2))) (Variation val) + +instance + ( ToQuantity unit ruleIx (Variation var) + ) => ToQuantity unit ruleIx (RuleVar ('GContextFree var)) + where + asQuantity = asQuantity @unit @ruleIx @(Variation var) + . Variation . unURuleVar . unRuleVar + +instance + ( ToQuantity unit ruleIx (RuleVar rv) + ) => ToQuantity unit ruleIx (NonSpare ('GNonSpare name title rv)) + where + asQuantity = asQuantity @unit @ruleIx @(RuleVar rv) + . RuleVar . unUNonSpare . unNonSpare + +instance + ( ToQuantity unit ruleIx (NonSpare nsp) + ) => ToQuantity unit ruleIx (Item ('GItem nsp)) + where + asQuantity (Item i) = case i of + UItem val -> asQuantity @unit @ruleIx @(NonSpare nsp) (NonSpare val) + _ -> intError + +type family GetVariationResult t where + GetVariationResult ('GNonSpare name title ('GContextFree var)) = var + GetVariationResult ('GNonSpare name title ('GDependent lst1 d lst2)) = d + GetVariationResult t + = TypeError ('Text "GetVariationResult unexpected argument: " + :<>: 'ShowType t) + +-- | Extract 'Variation' from 'NonSpare'. +getVariation :: NonSpare nsp -> Variation (GetVariationResult nsp) +getVariation = Variation . unURuleVar . unUNonSpare . unNonSpare + +-- | Get Dependent Variation from 'NonSpare'. +getDepVariation :: forall ix nsp. + ( Schema (DepRule nsp ix) VVariation + ) => NonSpare nsp -> Either ParsingError (Variation (DepRule nsp ix)) +getDepVariation nsp = do + let Bits bs o1 size1 = unparse @Bits nsp + act = parseVariation (schema @(DepRule nsp ix) Proxy) + env = Env parsingStore bs + (var, o2) <- runParsing act env o1 + let size2 = coerce $ o2 - o1 + when (size2 /= size1) $ Left $ ParsingError "remaining bits" + pure $ Variation var + +-- | Extract all spare items from group. +getGroupSpares :: Variation ('GGroup o lst) -> [Bits] +getGroupSpares (Variation var) = case var of + UGroup lst -> lst >>= \case + USpare val -> pure val + _ -> empty + _ -> intError + +-- | Extract group subitem by typelevel name. +getGroupItem :: forall name o lst. + ( KnownNat (LookupGroup name lst) + ) => Variation ('GGroup o lst) -> NonSpare ('GGroup o lst ~> name) +getGroupItem (Variation var) = case var of + UGroup lst -> + let ix = fromIntegral (natVal @(LookupGroup name lst) Proxy) + getNsp = \case + UItem nsp -> NonSpare nsp + _ -> intError + in getNsp $ lst !! ix + _ -> intError + +-- | Extract all present spare items from extended. +getExtendedSpares :: Variation ('GExtended lst) -> [Bits] +getExtendedSpares (Variation var) = case var of + UExtended _bld lst -> lst >>= \case + Just (USpare val) -> pure val + _ -> empty + _ -> intError + +-- | Extract extended subitem by typelevel name. +getExtendedItem :: forall name lst. + ( KnownNat (LookupExtended name lst) + ) => Variation ('GExtended lst) + -> Maybe (NonSpare ('GExtended lst ~> name)) +getExtendedItem (Variation var) = case var of + UExtended _bld lst -> do + let n = fromIntegral $ natVal (Proxy @(LookupExtended name lst)) + guard (n < length lst) + case lst !! n of + Just (UItem nsp) -> Just (NonSpare nsp) + _ -> intError + _ -> intError + +-- | Extract repetitive content. +getRepetitiveItems :: Variation ('GRepetitive rt var) -> [Variation var] +getRepetitiveItems (Variation var) = case var of + URepetitive _bld lst -> fmap Variation lst + _ -> intError + +-- | Extract explicit data 'Bits'. +getExplicitData :: Variation ('GExplicit mt) -> Bits +getExplicitData (Variation var) = case var of + UExplicit _bld val -> val + _ -> intError + +-- | Extract compound subitem by typelevel name. +getCompoundItem :: forall name lst. -- t lst ix. + ( KnownNat (LookupCompound name lst) + ) => Variation ('GCompound lst) + -> Maybe (NonSpare ('GCompound lst ~> name)) +getCompoundItem (Variation var) = case var of + UCompound _bld lst -> + let n = fromIntegral $ natVal (Proxy @(LookupCompound name lst)) + in NonSpare <$> (lst !! n) + _ -> intError + +-- | Set compound subitem by typelevel name. +setCompoundItem :: forall name lst. + ( KnownNat (LookupCompound name lst) + ) => NonSpare ('GCompound lst ~> name) -> Variation ('GCompound lst) + -> Variation ('GCompound lst) +setCompoundItem (NonSpare nsp) (Variation var) = case var of + UCompound _bld lst1 -> + -- replace element in a list and rebuild + let n = fromIntegral $ natVal (Proxy @(LookupCompound name lst)) + (a, b) = splitAt n lst1 + lst2 = a <> [Just nsp] <> drop 1 b + bld = rebuildCompound lst2 + in Variation (UCompound bld lst2) + _ -> intError + +-- | Del compound subitem by typelevel name. +delCompoundItem :: forall name lst. + ( KnownNat (LookupCompound name lst) + ) => Variation ('GCompound lst) -> Variation ('GCompound lst) +delCompoundItem (Variation var) = case var of + UCompound _bld lst1 -> + let n = fromIntegral $ natVal (Proxy @(LookupCompound name lst)) + (a, b) = splitAt n lst1 + lst2 = a <> [Nothing] <> drop 1 b + bld = rebuildCompound lst2 + in Variation (UCompound bld lst2) + _ -> intError + +-- | Extract record subitem by typelevel name. +getRecordItem :: forall name lst. + ( KnownNat (LookupRecord name lst) + ) => Record ('GRecord lst) -> Maybe (NonSpare ('GRecord lst ~> name)) +getRecordItem (Record (URecord _bld lst)) = f <$> lst !! n + where + n = fromIntegral (natVal (Proxy @(LookupRecord name lst))) + f :: RecordItem UNonSpare + -> NonSpare (Lookup name (PrependName (RecordNonSpares lst))) + f = \case + RecordItem nsp -> NonSpare nsp + _ -> intError + +-- | Set record subitem by typelevel name. +setRecordItem :: forall name lst. + ( KnownNat (LookupRecord name lst) + ) => NonSpare ('GRecord lst ~> name) -> Record ('GRecord lst) + -> Record ('GRecord lst) +setRecordItem (NonSpare nsp) (Record (URecord _bld lst1)) + = Record (URecord bld lst2) + where + n = fromIntegral (natVal (Proxy @(LookupRecord name lst))) + (a, b) = splitAt n lst1 + lst2 = a <> [Just $ RecordItem nsp] <> drop 1 b + bld = rebuildRecord lst2 + +-- | Del record subitem by typelevel name. +delRecordItem :: forall name lst. + ( KnownNat (LookupRecord name lst) + ) => Record ('GRecord lst) -> Record ('GRecord lst) +delRecordItem (Record (URecord _bld lst1)) = Record (URecord bld lst2) + where + n = fromIntegral (natVal (Proxy @(LookupRecord name lst))) + (a, b) = splitAt n lst1 + lst2 = a <> [Nothing] <> drop 1 b + bld = rebuildRecord lst2 + +-- | Get RFS subitems by typelevel name. +getRfsItem :: forall name lst. + ( KnownSymbol name + , Schema lst [VUapItem] + ) => Record ('GRecord lst) -> [NonSpare ('GRecord lst ~> name)] +getRfsItem (Record (URecord _bld lst)) = mconcat $ fmap f lst + where + frnRequired = getFrn 1 (schema @name Proxy) (schema @lst Proxy) + f Nothing = [] + f (Just ri) = case ri of + RecordItem _nsp -> [] + RecordItemSpare -> [] + RecordItemRFS lst2 -> do + (frn, nsp) <- lst2 + guard $ frn == frnRequired + pure $ NonSpare nsp + +-- | Get Expansion subitems by typelevel name. +getExpansionItem :: forall name mn lst. + ( KnownNat (LookupCompound name lst) + ) => Expansion ('GExpansion mn lst) + -> Maybe (NonSpare ('GExpansion mn lst ~> name)) +getExpansionItem (Expansion (UExpansion _bld lst)) + = NonSpare <$> (lst !! n) + where + n = fromIntegral (natVal (Proxy @(LookupCompound name lst))) + +-- Item access overloaded functions + +-- | 'getItem' name overloading. +class GetItem name parent child | name parent -> child where + getItem :: parent -> child + +instance + ( GetItem name (Variation (GetVariationResult nsp1)) (NonSpare nsp2) + ) => GetItem name (NonSpare nsp1) (NonSpare nsp2) where + getItem obj = getItem @name $ getVariation obj + +instance + ( r ~ 'GRecord lst + , nsp ~ Lookup name (PrependName (RecordNonSpares lst)) + , KnownNat (LookupRecord name lst) + ) => GetItem name (Record r) (Maybe (NonSpare nsp)) where + getItem = getRecordItem @name + +instance + ( nsp ~ 'GGroup o lst ~> name + , KnownNat (LookupGroup name lst) + ) => GetItem name (Variation ('GGroup o lst)) (NonSpare nsp) where + getItem = getGroupItem @name + +instance + ( nsp ~ 'GExtended lst ~> name + , KnownNat (LookupExtended name lst) + ) => GetItem name (Variation ('GExtended lst)) (Maybe (NonSpare nsp)) where + getItem = getExtendedItem @name + +instance + ( nsp ~ 'GCompound lst ~> name + , KnownNat (LookupCompound name lst) + ) => GetItem name (Variation ('GCompound lst)) (Maybe (NonSpare nsp)) where + getItem = getCompoundItem @name + +instance + ( nsp ~ 'GExpansion mn lst ~> name + , KnownNat (LookupCompound name lst) + ) => GetItem name (Expansion ('GExpansion mn lst)) (Maybe (NonSpare nsp)) where + getItem = getExpansionItem @name + +-- | 'getSpares' name overloading. +class GetSpares t where + getSpares :: t -> [Bits] + +instance + ( GetSpares (Variation (GetVariationResult nsp)) + ) => GetSpares (NonSpare nsp) where + getSpares = getSpares . getVariation + +instance GetSpares (Variation ('GGroup o lst)) where + getSpares = getGroupSpares + +-- | 'setItem' name overloading. +class SetItem name parent child | name parent -> child where + setItem :: child -> parent -> parent + +-- | If we are able to perform "setItem @name Variation NonSpare", then +-- we shall also be able to do "setItem @name NonSpare NonSpare". +-- This is useful in situations like: +-- compound nil +-- & setItem @"I1" val1 +-- & setItem @"I2" val2 +instance + ( nspChild ~ nspParent ~> name + , var ~ GetVariationResult nspParent + , SetItem name (Variation var) (NonSpare nspChild) + ) => SetItem name (NonSpare nspParent) (NonSpare nspChild) where + setItem child parent = + let var = getVariation parent + var' = setItem @name child var + in NonSpare $ UNonSpare $ URuleVar $ unVariation var' + +instance + ( r ~ 'GRecord lst + , nsp ~ Lookup name (PrependName (RecordNonSpares lst)) + , KnownNat (LookupRecord name lst) + ) => SetItem name (Record r) (NonSpare nsp) where + setItem = setRecordItem @name + +instance + ( nsp ~ 'GCompound lst ~> name + , KnownNat (LookupCompound name lst) + ) => SetItem name (Variation ('GCompound lst)) (NonSpare nsp) where + setItem = setCompoundItem @name + +-- | Helper function to setItem conditionally. +maybeSetItem :: forall name parent child. + ( SetItem name parent child + ) => Maybe child -> parent -> parent +maybeSetItem Nothing parent = parent +maybeSetItem (Just child) parent = setItem @name child parent + +-- | 'delItem' name overloading. +class DelItem name parent where + delItem :: parent -> parent + +instance + ( r ~ 'GRecord lst + , KnownNat (LookupRecord name lst) + ) => DelItem name (Record r) where + delItem = delRecordItem @name + +instance + ( var ~ 'GCompound lst + , KnownNat (LookupCompound name lst) + ) => DelItem name (Variation var) where + delItem = delCompoundItem @name + +-- | Helper function to manipulate extended subitem if present. +class ExtModify name parent child | name parent -> child where + modifyExtendedSubitemIfPresent :: (child -> child) -> parent -> parent + +instance + ( ExtModify name (Variation (GetVariationResult nsp1)) (NonSpare nsp2) + ) => ExtModify name (NonSpare nsp1) (NonSpare nsp2) where + modifyExtendedSubitemIfPresent f parent = + let Variation v = + modifyExtendedSubitemIfPresent @name f $ getVariation parent + in NonSpare $ UNonSpare $ URuleVar v + +instance + ( nsp ~ 'GExtended lst ~> name + , KnownNat (LookupExtended name lst) + ) => ExtModify name (Variation ('GExtended lst)) (NonSpare nsp) + where + modifyExtendedSubitemIfPresent f (Variation var) = case var of + UExtended _bld lst -> + let ix = fromIntegral $ natVal (Proxy @(LookupExtended name lst)) + in case ix < length lst of + False -> Variation var -- item not present + True -> case lst !! ix of + Just (UItem x) -> + let NonSpare y = f (NonSpare x) + lst2 :: [Maybe UItem] + lst2 = take ix lst ++ Just (UItem y) : drop (ix+1) lst + bld :: SBuilder + bld = bitsToSBuilder $ recreateExtended lst2 + in Variation $ UExtended bld lst2 + _ -> intError + _ -> intError + diff --git a/src/Asterix/Generated.hs b/src/Asterix/Generated.hs new file mode 100644 --- /dev/null +++ b/src/Asterix/Generated.hs @@ -0,0 +1,9509 @@ +-- | Asterix specifications + +-- This file is generated, DO NOT EDIT! +-- For more details, see: +-- - https://github.com/zoranbosnjak/asterix-specs + +-- Types are BIG, disable depth checking. +{-# OPTIONS_GHC -freduction-depth=0 #-} + +{-# LANGUAGE DataKinds #-} + +module Asterix.Generated where + +import Asterix.Schema + +asterixSpecsRef :: String +asterixSpecsRef = "git:c2b3d676a3359c319f672c974553cff7a79f0cae" + +asterixSpecsDate :: String +asterixSpecsDate = "2026-06-29T10:02:11+02:00" + +codeGeneratorVersion :: String +codeGeneratorVersion = "0.13.0" + +-- Asterix types + +type TContent0 = 'GContentRaw +type TRuleContent0 = 'GContextFree TContent0 +type TVariation178 = 'GElement 0 8 TRuleContent0 +type TRuleVariation171 = 'GContextFree TVariation178 +type TNonSpare1795 = 'GNonSpare "SAC" "System Area Code" TRuleVariation171 +type TItem920 = 'GItem TNonSpare1795 +type TNonSpare1851 = 'GNonSpare "SIC" "System Identification Code" TRuleVariation171 +type TItem951 = 'GItem TNonSpare1851 +type TVariation1253 = 'GGroup 0 '[ TItem920, TItem951] +type TRuleVariation1196 = 'GContextFree TVariation1253 +type TNonSpare36 = 'GNonSpare "010" "Data Source Identifier" TRuleVariation1196 +type TUapItem36 = 'GUapItem TNonSpare36 +type TContent451 = 'GContentTable '[ '(0, "Plot"), '(1, "Track")] +type TRuleContent449 = 'GContextFree TContent451 +type TVariation75 = 'GElement 0 1 TRuleContent449 +type TRuleVariation75 = 'GContextFree TVariation75 +type TNonSpare2129 = 'GNonSpare "TYP" "" TRuleVariation75 +type TItem1159 = 'GItem TNonSpare2129 +type TContent22 = 'GContentTable '[ '(0, "Actual plot or track"), '(1, "Simulated plot or track")] +type TRuleContent22 = 'GContextFree TContent22 +type TVariation417 = 'GElement 1 1 TRuleContent22 +type TRuleVariation405 = 'GContextFree TVariation417 +type TNonSpare1870 = 'GNonSpare "SIM" "" TRuleVariation405 +type TItem968 = 'GItem TNonSpare1870 +type TContent364 = 'GContentTable '[ '(0, "No detection"), '(1, "Sole primary detection"), '(2, "Sole secondary detection"), '(3, "Combined primary and secondary detection")] +type TRuleContent362 = 'GContextFree TContent364 +type TVariation611 = 'GElement 2 2 TRuleContent362 +type TRuleVariation599 = 'GContextFree TVariation611 +type TNonSpare1928 = 'GNonSpare "SSRPSR" "Radar Detection in Last Antenna Scan" TRuleVariation599 +type TItem1012 = 'GItem TNonSpare1928 +type TContent507 = 'GContentTable '[ '(0, "Target report from antenna 1"), '(1, "Target report from antenna 2")] +type TRuleContent505 = 'GContextFree TContent507 +type TVariation781 = 'GElement 4 1 TRuleContent505 +type TRuleVariation769 = 'GContextFree TVariation781 +type TNonSpare663 = 'GNonSpare "ANT" "" TRuleVariation769 +type TItem77 = 'GItem TNonSpare663 +type TContent157 = 'GContentTable '[ '(0, "Default"), '(1, "Special Position Identification")] +type TRuleContent157 = 'GContextFree TContent157 +type TVariation867 = 'GElement 5 1 TRuleContent157 +type TRuleVariation836 = 'GContextFree TVariation867 +type TNonSpare1897 = 'GNonSpare "SPI" "" TRuleVariation836 +type TItem991 = 'GItem TNonSpare1897 +type TContent145 = 'GContentTable '[ '(0, "Default"), '(1, "Plot or track from a fixed transponder")] +type TRuleContent145 = 'GContextFree TContent145 +type TVariation947 = 'GElement 6 1 TRuleContent145 +type TRuleVariation916 = 'GContextFree TVariation947 +type TNonSpare1665 = 'GNonSpare "RAB" "" TRuleVariation916 +type TItem825 = 'GItem TNonSpare1665 +type TContent161 = 'GContentTable '[ '(0, "Default"), '(1, "Test target indicator")] +type TRuleContent161 = 'GContextFree TContent161 +type TVariation37 = 'GElement 0 1 TRuleContent161 +type TRuleVariation37 = 'GContextFree TVariation37 +type TNonSpare2104 = 'GNonSpare "TST" "" TRuleVariation37 +type TItem1137 = 'GItem TNonSpare2104 +type TContent164 = 'GContentTable '[ '(0, "Default"), '(1, "Unlawful interference (code 7500)"), '(2, "Radio-communication failure (code 7600)"), '(3, "Emergency (code 7700)")] +type TRuleContent164 = 'GContextFree TContent164 +type TVariation483 = 'GElement 1 2 TRuleContent164 +type TRuleVariation471 = 'GContextFree TVariation483 +type TNonSpare971 = 'GNonSpare "DS1DS2" "Radar Detection in Last Antenna Scan" TRuleVariation471 +type TItem292 = 'GItem TNonSpare971 +type TContent121 = 'GContentTable '[ '(0, "Default"), '(1, "Military emergency")] +type TRuleContent121 = 'GContextFree TContent121 +type TVariation647 = 'GElement 3 1 TRuleContent121 +type TRuleVariation635 = 'GContextFree TVariation647 +type TNonSpare1372 = 'GNonSpare "ME" "" TRuleVariation635 +type TItem590 = 'GItem TNonSpare1372 +type TContent122 = 'GContentTable '[ '(0, "Default"), '(1, "Military identification")] +type TRuleContent122 = 'GContextFree TContent122 +type TVariation733 = 'GElement 4 1 TRuleContent122 +type TRuleVariation721 = 'GContextFree TVariation733 +type TNonSpare1391 = 'GNonSpare "MI" "" TRuleVariation721 +type TItem597 = 'GItem TNonSpare1391 +type TItem24 = 'GSpare 5 2 +type TVariation1462 = 'GExtended '[ 'Just TItem1159, 'Just TItem968, 'Just TItem1012, 'Just TItem77, 'Just TItem991, 'Just TItem825, 'Nothing, 'Just TItem1137, 'Just TItem292, 'Just TItem590, 'Just TItem597, 'Just TItem24, 'Nothing] +type TRuleVariation1378 = 'GContextFree TVariation1462 +type TNonSpare88 = 'GNonSpare "020" "Target Report Descriptor" TRuleVariation1378 +type TUapItem88 = 'GUapItem TNonSpare88 +type TContent798 = 'GContentQuantity 'GUnsigned ('GNumDiv ('GNumInt ('GZ 'GPlus 1)) ('GNumPow ('GZ 'GPlus 2) ('GZ 'GPlus 7))) "NM" +type TRuleContent795 = 'GContextFree TContent798 +type TVariation346 = 'GElement 0 16 TRuleContent795 +type TRuleVariation338 = 'GContextFree TVariation346 +type TNonSpare1724 = 'GNonSpare "RHO" "" TRuleVariation338 +type TItem875 = 'GItem TNonSpare1724 +type TContent824 = 'GContentQuantity 'GUnsigned ('GNumDiv ('GNumInt ('GZ 'GPlus 360)) ('GNumPow ('GZ 'GPlus 2) ('GZ 'GPlus 16))) "°" +type TRuleContent821 = 'GContextFree TContent824 +type TVariation357 = 'GElement 0 16 TRuleContent821 +type TRuleVariation349 = 'GContextFree TVariation357 +type TNonSpare2021 = 'GNonSpare "THETA" "" TRuleVariation349 +type TItem1077 = 'GItem TNonSpare2021 +type TVariation1238 = 'GGroup 0 '[ TItem875, TItem1077] +type TRuleVariation1184 = 'GContextFree TVariation1238 +type TNonSpare143 = 'GNonSpare "040" "Measured Position in Polar Co-ordinates" TRuleVariation1184 +type TUapItem143 = 'GUapItem TNonSpare143 +type TContent61 = 'GContentTable '[ '(0, "Code validated"), '(1, "Code not validated")] +type TRuleContent61 = 'GContextFree TContent61 +type TVariation16 = 'GElement 0 1 TRuleContent61 +type TRuleVariation16 = 'GContextFree TVariation16 +type TNonSpare2164 = 'GNonSpare "V" "" TRuleVariation16 +type TItem1191 = 'GItem TNonSpare2164 +type TContent102 = 'GContentTable '[ '(0, "Default"), '(1, "Garbled code")] +type TRuleContent102 = 'GContextFree TContent102 +type TVariation421 = 'GElement 1 1 TRuleContent102 +type TRuleVariation409 = 'GContextFree TVariation421 +type TNonSpare1084 = 'GNonSpare "G" "" TRuleVariation409 +type TItem377 = 'GItem TNonSpare1084 +type TContent304 = 'GContentTable '[ '(0, "Mode-3/A code derived from the reply of the transponder"), '(1, "Smoothed Mode-3/A code as provided by a local tracker")] +type TRuleContent302 = 'GContextFree TContent304 +type TVariation573 = 'GElement 2 1 TRuleContent302 +type TRuleVariation561 = 'GContextFree TVariation573 +type TNonSpare1223 = 'GNonSpare "L" "" TRuleVariation561 +type TItem479 = 'GItem TNonSpare1223 +type TItem16 = 'GSpare 3 1 +type TContent638 = 'GContentString 'GStringOctal +type TRuleContent636 = 'GContextFree TContent638 +type TVariation838 = 'GElement 4 12 TRuleContent636 +type TRuleVariation807 = 'GContextFree TVariation838 +type TNonSpare1418 = 'GNonSpare "MODE3A" "Mode-3/A Reply in Octal Representation" TRuleVariation807 +type TItem622 = 'GItem TNonSpare1418 +type TVariation1330 = 'GGroup 0 '[ TItem1191, TItem377, TItem479, TItem16, TItem622] +type TRuleVariation1254 = 'GContextFree TVariation1330 +type TNonSpare224 = 'GNonSpare "070" "Mode-3/A Code in Octal Representation" TRuleVariation1254 +type TUapItem224 = 'GUapItem TNonSpare224 +type TContent681 = 'GContentQuantity 'GSigned ('GNumDiv ('GNumInt ('GZ 'GPlus 1)) ('GNumPow ('GZ 'GPlus 2) ('GZ 'GPlus 2))) "FL" +type TRuleContent679 = 'GContextFree TContent681 +type TVariation628 = 'GElement 2 14 TRuleContent679 +type TRuleVariation616 = 'GContextFree TVariation628 +type TNonSpare1147 = 'GNonSpare "HGT" "Mode-C HEIGHT" TRuleVariation616 +type TItem417 = 'GItem TNonSpare1147 +type TVariation1322 = 'GGroup 0 '[ TItem1191, TItem377, TItem417] +type TRuleVariation1246 = 'GContextFree TVariation1322 +type TNonSpare267 = 'GNonSpare "090" "Mode-C Code in Binary Representation" TRuleVariation1246 +type TUapItem267 = 'GUapItem TNonSpare267 +type TVariation160 = 'GElement 0 7 TRuleContent0 +type TVariation1533 = 'GRepetitive 'GRepetitiveFx TVariation160 +type TRuleVariation1449 = 'GContextFree TVariation1533 +type TNonSpare331 = 'GNonSpare "130" "Radar Plot Characteristics" TRuleVariation1449 +type TUapItem331 = 'GUapItem TNonSpare331 +type TContent800 = 'GContentQuantity 'GUnsigned ('GNumDiv ('GNumInt ('GZ 'GPlus 1)) ('GNumPow ('GZ 'GPlus 2) ('GZ 'GPlus 7))) "s" +type TRuleContent797 = 'GContextFree TContent800 +type TVariation348 = 'GElement 0 16 TRuleContent797 +type TRuleVariation340 = 'GContextFree TVariation348 +type TNonSpare359 = 'GNonSpare "141" "Truncated Time of Day" TRuleVariation340 +type TUapItem359 = 'GUapItem TNonSpare359 +type TContent298 = 'GContentTable '[ '(0, "Mode-2 code as derived from the reply of the transponder"), '(1, "Smoothed Mode-2 code as provided by a local tracker")] +type TRuleContent296 = 'GContextFree TContent298 +type TVariation567 = 'GElement 2 1 TRuleContent296 +type TRuleVariation555 = 'GContextFree TVariation567 +type TNonSpare1217 = 'GNonSpare "L" "" TRuleVariation555 +type TItem473 = 'GItem TNonSpare1217 +type TNonSpare1412 = 'GNonSpare "MODE2" "Mode-2 Code in Octal Representation" TRuleVariation807 +type TItem616 = 'GItem TNonSpare1412 +type TVariation1325 = 'GGroup 0 '[ TItem1191, TItem377, TItem473, TItem16, TItem616] +type TRuleVariation1249 = 'GContextFree TVariation1325 +type TNonSpare182 = 'GNonSpare "050" "Mode-2 Code in Octal Representation" TRuleVariation1249 +type TUapItem182 = 'GUapItem TNonSpare182 +type TContent709 = 'GContentQuantity 'GSigned ('GNumDiv ('GNumInt ('GZ 'GPlus 1)) ('GNumPow ('GZ 'GPlus 2) ('GZ 'GPlus 8))) "NM/s" +type TRuleContent707 = 'GContextFree TContent709 +type TVariation232 = 'GElement 0 8 TRuleContent707 +type TRuleVariation224 = 'GContextFree TVariation232 +type TNonSpare318 = 'GNonSpare "120" "Measured Radial Doppler Speed" TRuleVariation224 +type TUapItem318 = 'GUapItem TNonSpare318 +type TContent652 = 'GContentQuantity 'GSigned ('GNumInt ('GZ 'GPlus 1)) "dBm" +type TRuleContent650 = 'GContextFree TContent652 +type TVariation222 = 'GElement 0 8 TRuleContent650 +type TRuleVariation214 = 'GContextFree TVariation222 +type TNonSpare336 = 'GNonSpare "131" "Received Power" TRuleVariation214 +type TUapItem336 = 'GUapItem TNonSpare336 +type TItem3 = 'GSpare 0 4 +type TContent233 = 'GContentTable '[ '(0, "High quality pulse A4"), '(1, "Low quality pulse A4")] +type TRuleContent233 = 'GContextFree TContent233 +type TVariation751 = 'GElement 4 1 TRuleContent233 +type TRuleVariation739 = 'GContextFree TVariation751 +type TNonSpare1623 = 'GNonSpare "QA4" "" TRuleVariation739 +type TItem786 = 'GItem TNonSpare1623 +type TContent232 = 'GContentTable '[ '(0, "High quality pulse A2"), '(1, "Low quality pulse A2")] +type TRuleContent232 = 'GContextFree TContent232 +type TVariation882 = 'GElement 5 1 TRuleContent232 +type TRuleVariation851 = 'GContextFree TVariation882 +type TNonSpare1618 = 'GNonSpare "QA2" "" TRuleVariation851 +type TItem781 = 'GItem TNonSpare1618 +type TContent231 = 'GContentTable '[ '(0, "High quality pulse A1"), '(1, "Low quality pulse A1")] +type TRuleContent231 = 'GContextFree TContent231 +type TVariation959 = 'GElement 6 1 TRuleContent231 +type TRuleVariation928 = 'GContextFree TVariation959 +type TNonSpare1615 = 'GNonSpare "QA1" "" TRuleVariation928 +type TItem778 = 'GItem TNonSpare1615 +type TContent236 = 'GContentTable '[ '(0, "High quality pulse B4"), '(1, "Low quality pulse B4")] +type TRuleContent236 = 'GContextFree TContent236 +type TVariation1013 = 'GElement 7 1 TRuleContent236 +type TRuleVariation982 = 'GContextFree TVariation1013 +type TNonSpare1634 = 'GNonSpare "QB4" "" TRuleVariation982 +type TItem797 = 'GItem TNonSpare1634 +type TContent235 = 'GContentTable '[ '(0, "High quality pulse B2"), '(1, "Low quality pulse B2")] +type TRuleContent235 = 'GContextFree TContent235 +type TVariation48 = 'GElement 0 1 TRuleContent235 +type TRuleVariation48 = 'GContextFree TVariation48 +type TNonSpare1629 = 'GNonSpare "QB2" "" TRuleVariation48 +type TItem792 = 'GItem TNonSpare1629 +type TContent234 = 'GContentTable '[ '(0, "High quality pulse B1"), '(1, "Low quality pulse B1")] +type TRuleContent234 = 'GContextFree TContent234 +type TVariation446 = 'GElement 1 1 TRuleContent234 +type TRuleVariation434 = 'GContextFree TVariation446 +type TNonSpare1625 = 'GNonSpare "QB1" "" TRuleVariation434 +type TItem788 = 'GItem TNonSpare1625 +type TContent239 = 'GContentTable '[ '(0, "High quality pulse C4"), '(1, "Low quality pulse C4")] +type TRuleContent239 = 'GContextFree TContent239 +type TVariation555 = 'GElement 2 1 TRuleContent239 +type TRuleVariation543 = 'GContextFree TVariation555 +type TNonSpare1642 = 'GNonSpare "QC4" "" TRuleVariation543 +type TItem805 = 'GItem TNonSpare1642 +type TContent238 = 'GContentTable '[ '(0, "High quality pulse C2"), '(1, "Low quality pulse C2")] +type TRuleContent238 = 'GContextFree TContent238 +type TVariation662 = 'GElement 3 1 TRuleContent238 +type TRuleVariation650 = 'GContextFree TVariation662 +type TNonSpare1638 = 'GNonSpare "QC2" "" TRuleVariation650 +type TItem801 = 'GItem TNonSpare1638 +type TContent237 = 'GContentTable '[ '(0, "High quality pulse C1"), '(1, "Low quality pulse C1")] +type TRuleContent237 = 'GContextFree TContent237 +type TVariation753 = 'GElement 4 1 TRuleContent237 +type TRuleVariation741 = 'GContextFree TVariation753 +type TNonSpare1636 = 'GNonSpare "QC1" "" TRuleVariation741 +type TItem799 = 'GItem TNonSpare1636 +type TContent242 = 'GContentTable '[ '(0, "High quality pulse D4"), '(1, "Low quality pulse D4")] +type TRuleContent242 = 'GContextFree TContent242 +type TVariation885 = 'GElement 5 1 TRuleContent242 +type TRuleVariation854 = 'GContextFree TVariation885 +type TNonSpare1650 = 'GNonSpare "QD4" "" TRuleVariation854 +type TItem813 = 'GItem TNonSpare1650 +type TContent241 = 'GContentTable '[ '(0, "High quality pulse D2"), '(1, "Low quality pulse D2")] +type TRuleContent241 = 'GContextFree TContent241 +type TVariation963 = 'GElement 6 1 TRuleContent241 +type TRuleVariation932 = 'GContextFree TVariation963 +type TNonSpare1648 = 'GNonSpare "QD2" "" TRuleVariation932 +type TItem811 = 'GItem TNonSpare1648 +type TContent240 = 'GContentTable '[ '(0, "High quality pulse D1"), '(1, "Low quality pulse D1")] +type TRuleContent240 = 'GContextFree TContent240 +type TVariation1014 = 'GElement 7 1 TRuleContent240 +type TRuleVariation983 = 'GContextFree TVariation1014 +type TNonSpare1645 = 'GNonSpare "QD1" "" TRuleVariation983 +type TItem808 = 'GItem TNonSpare1645 +type TVariation1073 = 'GGroup 0 '[ TItem3, TItem786, TItem781, TItem778, TItem797, TItem792, TItem788, TItem805, TItem801, TItem799, TItem813, TItem811, TItem808] +type TRuleVariation1040 = 'GContextFree TVariation1073 +type TNonSpare244 = 'GNonSpare "080" "Mode-3/A Code Confidence Indicator" TRuleVariation1040 +type TUapItem244 = 'GUapItem TNonSpare244 +type TItem12 = 'GSpare 2 2 +type TVariation837 = 'GElement 4 12 TRuleContent0 +type TRuleVariation806 = 'GContextFree TVariation837 +type TNonSpare1419 = 'GNonSpare "MODEC" "Mode-C Reply in Gray Notation" TRuleVariation806 +type TItem623 = 'GItem TNonSpare1419 +type TVariation881 = 'GElement 5 1 TRuleContent231 +type TRuleVariation850 = 'GContextFree TVariation881 +type TNonSpare1614 = 'GNonSpare "QA1" "" TRuleVariation850 +type TItem777 = 'GItem TNonSpare1614 +type TVariation962 = 'GElement 6 1 TRuleContent238 +type TRuleVariation931 = 'GContextFree TVariation962 +type TNonSpare1639 = 'GNonSpare "QC2" "" TRuleVariation931 +type TItem802 = 'GItem TNonSpare1639 +type TVariation1011 = 'GElement 7 1 TRuleContent232 +type TRuleVariation980 = 'GContextFree TVariation1011 +type TNonSpare1619 = 'GNonSpare "QA2" "" TRuleVariation980 +type TItem782 = 'GItem TNonSpare1619 +type TVariation49 = 'GElement 0 1 TRuleContent239 +type TRuleVariation49 = 'GContextFree TVariation49 +type TNonSpare1641 = 'GNonSpare "QC4" "" TRuleVariation49 +type TItem804 = 'GItem TNonSpare1641 +type TVariation445 = 'GElement 1 1 TRuleContent233 +type TRuleVariation433 = 'GContextFree TVariation445 +type TNonSpare1621 = 'GNonSpare "QA4" "" TRuleVariation433 +type TItem784 = 'GItem TNonSpare1621 +type TVariation554 = 'GElement 2 1 TRuleContent234 +type TRuleVariation542 = 'GContextFree TVariation554 +type TNonSpare1626 = 'GNonSpare "QB1" "" TRuleVariation542 +type TItem789 = 'GItem TNonSpare1626 +type TVariation663 = 'GElement 3 1 TRuleContent240 +type TRuleVariation651 = 'GContextFree TVariation663 +type TNonSpare1644 = 'GNonSpare "QD1" "" TRuleVariation651 +type TItem807 = 'GItem TNonSpare1644 +type TVariation752 = 'GElement 4 1 TRuleContent235 +type TRuleVariation740 = 'GContextFree TVariation752 +type TNonSpare1630 = 'GNonSpare "QB2" "" TRuleVariation740 +type TItem793 = 'GItem TNonSpare1630 +type TVariation884 = 'GElement 5 1 TRuleContent241 +type TRuleVariation853 = 'GContextFree TVariation884 +type TNonSpare1647 = 'GNonSpare "QD2" "" TRuleVariation853 +type TItem810 = 'GItem TNonSpare1647 +type TVariation961 = 'GElement 6 1 TRuleContent236 +type TRuleVariation930 = 'GContextFree TVariation961 +type TNonSpare1633 = 'GNonSpare "QB4" "" TRuleVariation930 +type TItem796 = 'GItem TNonSpare1633 +type TVariation1015 = 'GElement 7 1 TRuleContent242 +type TRuleVariation984 = 'GContextFree TVariation1015 +type TNonSpare1651 = 'GNonSpare "QD4" "" TRuleVariation984 +type TItem814 = 'GItem TNonSpare1651 +type TVariation1317 = 'GGroup 0 '[ TItem1191, TItem377, TItem12, TItem623, TItem3, TItem799, TItem777, TItem802, TItem782, TItem804, TItem784, TItem789, TItem807, TItem793, TItem810, TItem796, TItem814] +type TRuleVariation1241 = 'GContextFree TVariation1317 +type TNonSpare289 = 'GNonSpare "100" "Mode-C Code and Code Confidence Indicator" TRuleVariation1241 +type TUapItem289 = 'GUapItem TNonSpare289 +type TNonSpare197 = 'GNonSpare "060" "Mode-2 Code Confidence Indicator" TRuleVariation1040 +type TUapItem197 = 'GUapItem TNonSpare197 +type TContent395 = 'GContentTable '[ '(0, "No warning nor error condition"), '(1, "Garbled reply"), '(2, "Reflection"), '(3, "Sidelobe reply"), '(4, "Split plot"), '(5, "Second time around reply"), '(6, "Angels"), '(7, "Terrestrial vehicles"), '(64, "Possible wrong code in Mode-3/A"), '(65, "Possible wrong altitude information, transmitted when the Code C credibility check fails together with the Mode-C code in binary notation"), '(66, "Possible phantom MSSR plot"), '(80, "Fixed PSR plot"), '(81, "Slow PSR plot"), '(82, "Low quality PSR plot")] +type TRuleContent393 = 'GContextFree TContent395 +type TVariation162 = 'GElement 0 7 TRuleContent393 +type TVariation1534 = 'GRepetitive 'GRepetitiveFx TVariation162 +type TRuleVariation1450 = 'GContextFree TVariation1534 +type TNonSpare120 = 'GNonSpare "030" "Warning/Error Conditions" TRuleVariation1450 +type TUapItem120 = 'GUapItem TNonSpare120 +type TContent172 = 'GContentTable '[ '(0, "Default"), '(1, "X-pulse received in Mode-3/A reply")] +type TRuleContent172 = 'GContextFree TContent172 +type TVariation38 = 'GElement 0 1 TRuleContent172 +type TRuleVariation38 = 'GContextFree TVariation38 +type TNonSpare2302 = 'GNonSpare "XA" "" TRuleVariation38 +type TItem1318 = 'GItem TNonSpare2302 +type TItem7 = 'GSpare 1 1 +type TContent173 = 'GContentTable '[ '(0, "Default"), '(1, "X-pulse received in Mode-C reply")] +type TRuleContent173 = 'GContextFree TContent173 +type TVariation542 = 'GElement 2 1 TRuleContent173 +type TRuleVariation530 = 'GContextFree TVariation542 +type TNonSpare2303 = 'GNonSpare "XC" "" TRuleVariation530 +type TItem1319 = 'GItem TNonSpare2303 +type TItem17 = 'GSpare 3 2 +type TContent171 = 'GContentTable '[ '(0, "Default"), '(1, "X-pulse received in Mode-2 reply")] +type TRuleContent171 = 'GContextFree TContent171 +type TVariation871 = 'GElement 5 1 TRuleContent171 +type TRuleVariation840 = 'GContextFree TVariation871 +type TNonSpare2296 = 'GNonSpare "X2" "" TRuleVariation840 +type TItem1312 = 'GItem TNonSpare2296 +type TItem27 = 'GSpare 6 2 +type TVariation1384 = 'GGroup 0 '[ TItem1318, TItem7, TItem1319, TItem17, TItem1312, TItem27] +type TRuleVariation1303 = 'GContextFree TVariation1384 +type TNonSpare368 = 'GNonSpare "150" "Presence of X-Pulse" TRuleVariation1303 +type TUapItem368 = 'GUapItem TNonSpare368 +type TUapItem598 = 'GUapItemSpare +type TVariation1544 = 'GExplicit ('Just 'GSpecialPurpose) +type TRuleVariation1460 = 'GContextFree TVariation1544 +type TNonSpare1888 = 'GNonSpare "SP" "Special Purpose Field" TRuleVariation1460 +type TUapItem596 = 'GUapItem TNonSpare1888 +type TUapItem599 = 'GUapItemRFS +type TRecord20 = 'GRecord '[ TUapItem36, TUapItem88, TUapItem143, TUapItem224, TUapItem267, TUapItem331, TUapItem359, TUapItem182, TUapItem318, TUapItem336, TUapItem244, TUapItem289, TUapItem197, TUapItem120, TUapItem368, TUapItem598, TUapItem598, TUapItem598, TUapItem598, TUapItem596, TUapItem599] +type TVariation267 = 'GElement 0 16 TRuleContent0 +type TRuleVariation259 = 'GContextFree TVariation267 +type TNonSpare389 = 'GNonSpare "161" "Track Plot Number" TRuleVariation259 +type TUapItem389 = 'GUapItem TNonSpare389 +type TContent702 = 'GContentQuantity 'GSigned ('GNumDiv ('GNumInt ('GZ 'GPlus 1)) ('GNumPow ('GZ 'GPlus 2) ('GZ 'GPlus 6))) "NM" +type TRuleContent700 = 'GContextFree TContent702 +type TVariation298 = 'GElement 0 16 TRuleContent700 +type TRuleVariation290 = 'GContextFree TVariation298 +type TNonSpare2288 = 'GNonSpare "X" "X-Component" TRuleVariation290 +type TItem1304 = 'GItem TNonSpare2288 +type TNonSpare2343 = 'GNonSpare "Y" "Y-Component" TRuleVariation290 +type TItem1355 = 'GItem TNonSpare2343 +type TVariation1377 = 'GGroup 0 '[ TItem1304, TItem1355] +type TRuleVariation1299 = 'GContextFree TVariation1377 +type TNonSpare165 = 'GNonSpare "042" "Calculated Position in Cartesian Co-ordinates" TRuleVariation1299 +type TUapItem165 = 'GUapItem TNonSpare165 +type TContent808 = 'GContentQuantity 'GUnsigned ('GNumDiv ('GNumInt ('GZ 'GPlus 1)) ('GNumPow ('GZ 'GPlus 2) ('GZ 'GPlus 14))) "NM/s" +type TRuleContent805 = 'GContextFree TContent808 +type TVariation352 = 'GElement 0 16 TRuleContent805 +type TRuleVariation344 = 'GContextFree TVariation352 +type TNonSpare1119 = 'GNonSpare "GSP" "Calculated Groundspeed" TRuleVariation344 +type TItem397 = 'GItem TNonSpare1119 +type TNonSpare1139 = 'GNonSpare "HDG" "Calculated Heading" TRuleVariation349 +type TItem411 = 'GItem TNonSpare1139 +type TVariation1170 = 'GGroup 0 '[ TItem397, TItem411] +type TRuleVariation1123 = 'GContextFree TVariation1170 +type TNonSpare414 = 'GNonSpare "200" "Calculated Track Velocity in Polar Co-ordinates" TRuleVariation1123 +type TUapItem414 = 'GUapItem TNonSpare414 +type TContent66 = 'GContentTable '[ '(0, "Confirmed Track"), '(1, "Track in initialisation phase")] +type TRuleContent66 = 'GContextFree TContent66 +type TVariation18 = 'GElement 0 1 TRuleContent66 +type TRuleVariation18 = 'GContextFree TVariation18 +type TNonSpare859 = 'GNonSpare "CON" "" TRuleVariation18 +type TItem206 = 'GItem TNonSpare859 +type TContent454 = 'GContentTable '[ '(0, "Primary track"), '(1, "SSR/Combined track")] +type TRuleContent452 = 'GContextFree TContent454 +type TVariation464 = 'GElement 1 1 TRuleContent452 +type TRuleVariation452 = 'GContextFree TVariation464 +type TNonSpare1670 = 'GNonSpare "RAD" "" TRuleVariation452 +type TItem830 = 'GItem TNonSpare1670 +type TContent89 = 'GContentTable '[ '(0, "Default"), '(1, "Aircraft manoeuvring")] +type TRuleContent89 = 'GContextFree TContent89 +type TVariation532 = 'GElement 2 1 TRuleContent89 +type TRuleVariation520 = 'GContextFree TVariation532 +type TNonSpare1328 = 'GNonSpare "MAN" "" TRuleVariation520 +type TItem569 = 'GItem TNonSpare1328 +type TContent99 = 'GContentTable '[ '(0, "Default"), '(1, "Doubtful plot to track association")] +type TRuleContent99 = 'GContextFree TContent99 +type TVariation641 = 'GElement 3 1 TRuleContent99 +type TRuleVariation629 = 'GContextFree TVariation641 +type TNonSpare963 = 'GNonSpare "DOU" "" TRuleVariation629 +type TItem286 = 'GItem TNonSpare963 +type TContent456 = 'GContentTable '[ '(0, "RDP Chain 1"), '(1, "RDP Chain 2")] +type TRuleContent454 = 'GContextFree TContent456 +type TVariation773 = 'GElement 4 1 TRuleContent454 +type TRuleVariation761 = 'GContextFree TVariation773 +type TNonSpare1692 = 'GNonSpare "RDPC" "Radar Data Processing Chain" TRuleVariation761 +type TItem848 = 'GItem TNonSpare1692 +type TItem23 = 'GSpare 5 1 +type TContent104 = 'GContentTable '[ '(0, "Default"), '(1, "Ghost track")] +type TRuleContent104 = 'GContextFree TContent104 +type TVariation942 = 'GElement 6 1 TRuleContent104 +type TRuleVariation911 = 'GContextFree TVariation942 +type TNonSpare1114 = 'GNonSpare "GHO" "" TRuleVariation911 +type TItem393 = 'GItem TNonSpare1114 +type TContent117 = 'GContentTable '[ '(0, "Default"), '(1, "Last report for a track")] +type TRuleContent117 = 'GContextFree TContent117 +type TVariation32 = 'GElement 0 1 TRuleContent117 +type TRuleVariation32 = 'GContextFree TVariation32 +type TNonSpare2083 = 'GNonSpare "TRE" "" TRuleVariation32 +type TItem1120 = 'GItem TNonSpare2083 +type TItem9 = 'GSpare 1 6 +type TVariation1425 = 'GExtended '[ 'Just TItem206, 'Just TItem830, 'Just TItem569, 'Just TItem286, 'Just TItem848, 'Just TItem23, 'Just TItem393, 'Nothing, 'Just TItem1120, 'Just TItem9, 'Nothing] +type TRuleVariation1341 = 'GContextFree TVariation1425 +type TNonSpare402 = 'GNonSpare "170" "Track Status" TRuleVariation1341 +type TUapItem402 = 'GUapItem TNonSpare402 +type TNonSpare444 = 'GNonSpare "210" "Track Quality" TRuleVariation1449 +type TUapItem444 = 'GUapItem TNonSpare444 +type TRecord21 = 'GRecord '[ TUapItem36, TUapItem88, TUapItem389, TUapItem143, TUapItem165, TUapItem414, TUapItem224, TUapItem267, TUapItem359, TUapItem331, TUapItem336, TUapItem318, TUapItem402, TUapItem444, TUapItem182, TUapItem244, TUapItem289, TUapItem197, TUapItem120, TUapItem596, TUapItem599, TUapItem368] +type TUap56 = 'GUaps '[ '("plot", TRecord20), '("track", TRecord21)] ('Just ('GUapSelector '[ "020", "TYP"] '[ '( 0, "plot"), '( 1, "track")])) +type TAsterix0 = 'GAsterixBasic 1 ('GEdition 1 2) TUap56 +type TNonSpare37 = 'GNonSpare "010" "Data Source Identifier" TRuleVariation1196 +type TUapItem37 = 'GUapItem TNonSpare37 +type TRecord28 = 'GRecord '[ TUapItem37, TUapItem88, TUapItem143, TUapItem224, TUapItem267, TUapItem331, TUapItem359, TUapItem182, TUapItem318, TUapItem336, TUapItem244, TUapItem289, TUapItem197, TUapItem120, TUapItem368, TUapItem598, TUapItem598, TUapItem598, TUapItem598, TUapItem596, TUapItem599] +type TRecord29 = 'GRecord '[ TUapItem37, TUapItem88, TUapItem389, TUapItem143, TUapItem165, TUapItem414, TUapItem224, TUapItem267, TUapItem359, TUapItem331, TUapItem336, TUapItem318, TUapItem402, TUapItem444, TUapItem182, TUapItem244, TUapItem289, TUapItem197, TUapItem120, TUapItem596, TUapItem599, TUapItem368] +type TUap57 = 'GUaps '[ '("plot", TRecord28), '("track", TRecord29)] ('Just ('GUapSelector '[ "020", "TYP"] '[ '( 0, "plot"), '( 1, "track")])) +type TAsterix1 = 'GAsterixBasic 1 ('GEdition 1 3) TUap57 +type TAsterix2 = 'GAsterixBasic 1 ('GEdition 1 4) TUap57 +type TNonSpare47 = 'GNonSpare "010" "Data Source Identifier" TRuleVariation1196 +type TUapItem47 = 'GUapItem TNonSpare47 +type TContent617 = 'GContentTable '[ '(1, "North marker message"), '(2, "Sector crossing message"), '(3, "South marker message"), '(8, "Activation of blind zone filtering"), '(9, "Stop of blind zone filtering")] +type TRuleContent615 = 'GContextFree TContent617 +type TVariation204 = 'GElement 0 8 TRuleContent615 +type TRuleVariation196 = 'GContextFree TVariation204 +type TNonSpare7 = 'GNonSpare "000" "Message Type" TRuleVariation196 +type TUapItem7 = 'GUapItem TNonSpare7 +type TContent821 = 'GContentQuantity 'GUnsigned ('GNumDiv ('GNumInt ('GZ 'GPlus 360)) ('GNumPow ('GZ 'GPlus 2) ('GZ 'GPlus 8))) "°" +type TRuleContent818 = 'GContextFree TContent821 +type TVariation257 = 'GElement 0 8 TRuleContent818 +type TRuleVariation249 = 'GContextFree TVariation257 +type TNonSpare81 = 'GNonSpare "020" "Sector Number" TRuleVariation249 +type TUapItem81 = 'GUapItem TNonSpare81 +type TVariation384 = 'GElement 0 24 TRuleContent797 +type TRuleVariation376 = 'GContextFree TVariation384 +type TNonSpare112 = 'GNonSpare "030" "Time of Day" TRuleVariation376 +type TUapItem112 = 'GUapItem TNonSpare112 +type TNonSpare158 = 'GNonSpare "041" "Antenna Rotation Speed" TRuleVariation340 +type TUapItem158 = 'GUapItem TNonSpare158 +type TNonSpare188 = 'GNonSpare "050" "Station Configuration Status" TRuleVariation1449 +type TUapItem188 = 'GUapItem TNonSpare188 +type TNonSpare207 = 'GNonSpare "060" "Station Processing Mode" TRuleVariation1449 +type TUapItem207 = 'GUapItem TNonSpare207 +type TContent74 = 'GContentTable '[ '(0, "Counter for antenna 1"), '(1, "Counter for antenna 2")] +type TRuleContent74 = 'GContextFree TContent74 +type TVariation22 = 'GElement 0 1 TRuleContent74 +type TRuleVariation22 = 'GContextFree TVariation22 +type TNonSpare596 = 'GNonSpare "A" "Aerial Identification" TRuleVariation22 +type TItem34 = 'GItem TNonSpare596 +type TContent622 = 'GContentTable '[ '(1, "Sole primary plots"), '(2, "Sole SSR plots"), '(3, "Combined plots")] +type TRuleContent620 = 'GContextFree TContent622 +type TVariation508 = 'GElement 1 5 TRuleContent620 +type TRuleVariation496 = 'GContextFree TVariation508 +type TNonSpare1191 = 'GNonSpare "IDENT" "" TRuleVariation496 +type TItem452 = 'GItem TNonSpare1191 +type TContent640 = 'GContentInteger 'GUnsigned +type TRuleContent638 = 'GContextFree TContent640 +type TVariation1001 = 'GElement 6 10 TRuleContent638 +type TRuleVariation970 = 'GContextFree TVariation1001 +type TNonSpare869 = 'GNonSpare "COUNTER" "" TRuleVariation970 +type TItem216 = 'GItem TNonSpare869 +type TVariation1088 = 'GGroup 0 '[ TItem34, TItem452, TItem216] +type TVariation1484 = 'GRepetitive ('GRepetitiveRegular 1) TVariation1088 +type TRuleVariation1400 = 'GContextFree TVariation1484 +type TNonSpare227 = 'GNonSpare "070" "Plot Count Values" TRuleVariation1400 +type TUapItem227 = 'GUapItem TNonSpare227 +type TContent797 = 'GContentQuantity 'GUnsigned ('GNumDiv ('GNumInt ('GZ 'GPlus 1)) ('GNumPow ('GZ 'GPlus 2) ('GZ 'GPlus 7))) "NM" +type TRuleContent794 = 'GContextFree TContent797 +type TVariation345 = 'GElement 0 16 TRuleContent794 +type TRuleVariation337 = 'GContextFree TVariation345 +type TNonSpare1752 = 'GNonSpare "RS" "Rho Start" TRuleVariation337 +type TItem894 = 'GItem TNonSpare1752 +type TNonSpare1702 = 'GNonSpare "RE" "Rho End" TRuleVariation337 +type TItem854 = 'GItem TNonSpare1702 +type TNonSpare2096 = 'GNonSpare "TS" "Theta Start" TRuleVariation349 +type TItem1129 = 'GItem TNonSpare2096 +type TNonSpare2017 = 'GNonSpare "TE" "Theta End" TRuleVariation349 +type TItem1074 = 'GItem TNonSpare2017 +type TVariation1245 = 'GGroup 0 '[ TItem894, TItem854, TItem1129, TItem1074] +type TRuleVariation1190 = 'GContextFree TVariation1245 +type TNonSpare284 = 'GNonSpare "100" "Dynamic Window Type 1" TRuleVariation1190 +type TUapItem284 = 'GUapItem TNonSpare284 +type TContent705 = 'GContentQuantity 'GSigned ('GNumDiv ('GNumInt ('GZ 'GPlus 1)) ('GNumPow ('GZ 'GPlus 2) ('GZ 'GPlus 7))) "NM" +type TRuleContent703 = 'GContextFree TContent705 +type TVariation229 = 'GElement 0 8 TRuleContent703 +type TRuleVariation221 = 'GContextFree TVariation229 +type TNonSpare1698 = 'GNonSpare "RE" "Range Error" TRuleVariation221 +type TItem851 = 'GItem TNonSpare1698 +type TContent736 = 'GContentQuantity 'GSigned ('GNumDiv ('GNumInt ('GZ 'GPlus 360)) ('GNumPow ('GZ 'GPlus 2) ('GZ 'GPlus 14))) "°" +type TRuleContent734 = 'GContextFree TContent736 +type TVariation234 = 'GElement 0 8 TRuleContent734 +type TRuleVariation226 = 'GContextFree TVariation234 +type TNonSpare630 = 'GNonSpare "AE" "Azimuth Error" TRuleVariation226 +type TItem52 = 'GItem TNonSpare630 +type TVariation1231 = 'GGroup 0 '[ TItem851, TItem52] +type TRuleVariation1177 = 'GContextFree TVariation1231 +type TNonSpare257 = 'GNonSpare "090" "Collimation Error" TRuleVariation1177 +type TUapItem257 = 'GUapItem TNonSpare257 +type TNonSpare254 = 'GNonSpare "080" "Warning/Error Conditions" TRuleVariation1449 +type TUapItem254 = 'GUapItem TNonSpare254 +type TRecord54 = 'GRecord '[ TUapItem47, TUapItem7, TUapItem81, TUapItem112, TUapItem158, TUapItem188, TUapItem207, TUapItem227, TUapItem284, TUapItem257, TUapItem254, TUapItem598, TUapItem596, TUapItem599] +type TUap48 = 'GUap TRecord54 +type TAsterix3 = 'GAsterixBasic 2 ('GEdition 1 0) TUap48 +type TNonSpare38 = 'GNonSpare "010" "Data Source Identifier" TRuleVariation1196 +type TUapItem38 = 'GUapItem TNonSpare38 +type TRecord30 = 'GRecord '[ TUapItem38, TUapItem7, TUapItem81, TUapItem112, TUapItem158, TUapItem188, TUapItem207, TUapItem227, TUapItem284, TUapItem257, TUapItem254, TUapItem598, TUapItem596, TUapItem599] +type TUap26 = 'GUap TRecord30 +type TAsterix4 = 'GAsterixBasic 2 ('GEdition 1 1) TUap26 +type TAsterix5 = 'GAsterixBasic 2 ('GEdition 1 2) TUap26 +type TNonSpare34 = 'GNonSpare "010" "Data Source Identifier" TRuleVariation1196 +type TUapItem34 = 'GUapItem TNonSpare34 +type TContent603 = 'GContentTable '[ '(1, "Alive Message (AM)"), '(2, "Route Adherence Monitor Longitudinal Deviation (RAMLD)"), '(3, "Route Adherence Monitor Heading Deviation (RAMHD)"), '(4, "Minimum Safe Altitude Warning (MSAW)"), '(5, "Area Proximity Warning (APW)"), '(6, "Clearance Level Adherence Monitor (CLAM)"), '(7, "Short Term Conflict Alert (STCA)"), '(8, "Approach Path Monitor (APM)"), '(9, "RIMCAS Arrival / Landing Monitor (ALM)"), '(10, "RIMCAS Arrival / Departure Wrong Runway Alert (WRA)"), '(11, "RIMCAS Arrival / Departure Opposite Traffic Alert (OTA)"), '(12, "RIMCAS Departure Monitor (RDM)"), '(13, "RIMCAS Runway / Taxiway Crossing Monitor (RCM)"), '(14, "RIMCAS Taxiway Separation Monitor (TSM)"), '(15, "RIMCAS Unauthorized Taxiway Movement Monitor(UTMM)"), '(16, "RIMCAS Stop Bar Overrun Alert (SBOA)"), '(17, "End Of Conflict (EOC)"), '(18, "ACAS Resolution Advisory (ACASRA)"), '(19, "Near Term Conflict Alert (NTCA)"), '(20, "Downlinked Barometric Pressure Setting Monitor (DBPSM)"), '(21, "Speed Adherence Monitor (SAM)"), '(22, "Outside Controlled Airspace Tool (OCAT)"), '(23, "Vertical Conflict Detection (VCD)"), '(24, "Vertical Rate Adherence Monitor (VRAM)"), '(25, "Cleared Heading Adherence Monitor (CHAM)"), '(26, "Downlinked Selected Altitude Monitor (DSAM)"), '(27, "Holding Adherence Monitor (HAM)"), '(28, "Vertical Path Monitor (VPM)"), '(29, "RIMCAS Taxiway Traffic Alert (TTA)"), '(30, "RIMCAS Arrival/Departure Close Runway Alert (CRA)"), '(31, "RIMCAS Arrival/Departure Aircraft Separation Monitor (ASM)"), '(32, "RIMCAS ILS Area Violation Monitor (IAVM)"), '(33, "Final Target Distance Indicator (FTD)"), '(34, "Initial Target Distance Indicator (ITD)"), '(35, "Wake Vortex Indicator Infringement Alert (IIA)"), '(36, "Sequence Warning (SQW)"), '(37, "Catch Up Warning (CUW)"), '(38, "Conflicting ATC Clearances (CATC)"), '(39, "No ATC Clearance (NOCLR)"), '(40, "Aircraft Not Moving despite ATC Clearance (NOMOV)"), '(41, "Aircraft leaving/entering the aerodrome area without proper handover (NOH)"), '(42, "Wrong Runway or Taxiway Type (WRTY)"), '(43, "Stand Occupied (STOCC)"), '(44, "Ongoing Alert (ONGOING)"), '(97, "Lost Track Warning (LTW)"), '(98, "Holding Volume Infringement (HVI)"), '(99, "Airspace Infringement Warning (AIW)")] +type TRuleContent601 = 'GContextFree TContent603 +type TVariation194 = 'GElement 0 8 TRuleContent601 +type TRuleVariation186 = 'GContextFree TVariation194 +type TNonSpare3 = 'GNonSpare "000" "Message Type" TRuleVariation186 +type TUapItem3 = 'GUapItem TNonSpare3 +type TVariation1508 = 'GRepetitive ('GRepetitiveRegular 1) TVariation1253 +type TRuleVariation1424 = 'GContextFree TVariation1508 +type TNonSpare58 = 'GNonSpare "015" "SDPS Identifier" TRuleVariation1424 +type TUapItem58 = 'GUapItem TNonSpare58 +type TNonSpare95 = 'GNonSpare "020" "Time of Message" TRuleVariation376 +type TUapItem95 = 'GUapItem TNonSpare95 +type TNonSpare141 = 'GNonSpare "040" "Alert Identifier" TRuleVariation259 +type TUapItem141 = 'GUapItem TNonSpare141 +type TVariation801 = 'GElement 4 3 TRuleContent0 +type TRuleVariation789 = 'GContextFree TVariation801 +type TNonSpare1945 = 'GNonSpare "STAT" "Status of the Alert" TRuleVariation789 +type TItem1025 = 'GItem TNonSpare1945 +type TItem29 = 'GSpare 7 1 +type TVariation1074 = 'GGroup 0 '[ TItem3, TItem1025, TItem29] +type TRuleVariation1041 = 'GContextFree TVariation1074 +type TNonSpare170 = 'GNonSpare "045" "Alert Status" TRuleVariation1041 +type TUapItem170 = 'GUapItem TNonSpare170 +type TContent119 = 'GContentTable '[ '(0, "Default"), '(1, "MRVA function")] +type TRuleContent119 = 'GContextFree TContent119 +type TVariation33 = 'GElement 0 1 TRuleContent119 +type TRuleVariation33 = 'GContextFree TVariation33 +type TNonSpare1427 = 'GNonSpare "MRVA" "" TRuleVariation33 +type TItem631 = 'GItem TNonSpare1427 +type TContent147 = 'GContentTable '[ '(0, "Default"), '(1, "RAMLD function")] +type TRuleContent147 = 'GContextFree TContent147 +type TVariation430 = 'GElement 1 1 TRuleContent147 +type TRuleVariation418 = 'GContextFree TVariation430 +type TNonSpare1673 = 'GNonSpare "RAMLD" "" TRuleVariation418 +type TItem833 = 'GItem TNonSpare1673 +type TContent146 = 'GContentTable '[ '(0, "Default"), '(1, "RAMHD function")] +type TRuleContent146 = 'GContextFree TContent146 +type TVariation541 = 'GElement 2 1 TRuleContent146 +type TRuleVariation529 = 'GContextFree TVariation541 +type TNonSpare1672 = 'GNonSpare "RAMHD" "" TRuleVariation529 +type TItem832 = 'GItem TNonSpare1672 +type TContent120 = 'GContentTable '[ '(0, "Default"), '(1, "MSAW function")] +type TRuleContent120 = 'GContextFree TContent120 +type TVariation646 = 'GElement 3 1 TRuleContent120 +type TRuleVariation634 = 'GContextFree TVariation646 +type TNonSpare1434 = 'GNonSpare "MSAW" "" TRuleVariation634 +type TItem635 = 'GItem TNonSpare1434 +type TContent87 = 'GContentTable '[ '(0, "Default"), '(1, "APW function")] +type TRuleContent87 = 'GContextFree TContent87 +type TVariation730 = 'GElement 4 1 TRuleContent87 +type TRuleVariation718 = 'GContextFree TVariation730 +type TNonSpare672 = 'GNonSpare "APW" "" TRuleVariation718 +type TItem81 = 'GItem TNonSpare672 +type TContent92 = 'GContentTable '[ '(0, "Default"), '(1, "CLAM function")] +type TRuleContent92 = 'GContextFree TContent92 +type TVariation859 = 'GElement 5 1 TRuleContent92 +type TRuleVariation828 = 'GContextFree TVariation859 +type TNonSpare808 = 'GNonSpare "CLAM" "" TRuleVariation828 +type TItem175 = 'GItem TNonSpare808 +type TContent155 = 'GContentTable '[ '(0, "Default"), '(1, "STCA function")] +type TRuleContent155 = 'GContextFree TContent155 +type TVariation949 = 'GElement 6 1 TRuleContent155 +type TRuleVariation918 = 'GContextFree TVariation949 +type TNonSpare1949 = 'GNonSpare "STCA" "" TRuleVariation918 +type TItem1029 = 'GItem TNonSpare1949 +type TContent86 = 'GContentTable '[ '(0, "Default"), '(1, "APM function")] +type TRuleContent86 = 'GContextFree TContent86 +type TVariation25 = 'GElement 0 1 TRuleContent86 +type TRuleVariation25 = 'GContextFree TVariation25 +type TNonSpare671 = 'GNonSpare "APM" "" TRuleVariation25 +type TItem80 = 'GItem TNonSpare671 +type TContent148 = 'GContentTable '[ '(0, "Default"), '(1, "RIMCA function")] +type TRuleContent148 = 'GContextFree TContent148 +type TVariation431 = 'GElement 1 1 TRuleContent148 +type TRuleVariation419 = 'GContextFree TVariation431 +type TNonSpare1733 = 'GNonSpare "RIMCA" "" TRuleVariation419 +type TItem883 = 'GItem TNonSpare1733 +type TContent84 = 'GContentTable '[ '(0, "Default"), '(1, "ACAS RA function")] +type TRuleContent84 = 'GContextFree TContent84 +type TVariation531 = 'GElement 2 1 TRuleContent84 +type TRuleVariation519 = 'GContextFree TVariation531 +type TNonSpare609 = 'GNonSpare "ACASRA" "" TRuleVariation519 +type TItem42 = 'GItem TNonSpare609 +type TContent137 = 'GContentTable '[ '(0, "Default"), '(1, "NTCA function")] +type TRuleContent137 = 'GContextFree TContent137 +type TVariation651 = 'GElement 3 1 TRuleContent137 +type TRuleVariation639 = 'GContextFree TVariation651 +type TNonSpare1498 = 'GNonSpare "NTCA" "" TRuleVariation639 +type TItem693 = 'GItem TNonSpare1498 +type TContent158 = 'GContentTable '[ '(0, "Default"), '(1, "System degraded")] +type TRuleContent158 = 'GContextFree TContent158 +type TVariation736 = 'GElement 4 1 TRuleContent158 +type TRuleVariation724 = 'GContextFree TVariation736 +type TNonSpare952 = 'GNonSpare "DG" "" TRuleVariation724 +type TItem277 = 'GItem TNonSpare952 +type TContent141 = 'GContentTable '[ '(0, "Default"), '(1, "Overflow error")] +type TRuleContent141 = 'GContextFree TContent141 +type TVariation863 = 'GElement 5 1 TRuleContent141 +type TRuleVariation832 = 'GContextFree TVariation863 +type TNonSpare1513 = 'GNonSpare "OF" "" TRuleVariation832 +type TItem708 = 'GItem TNonSpare1513 +type TContent143 = 'GContentTable '[ '(0, "Default"), '(1, "Overload error")] +type TRuleContent143 = 'GContextFree TContent143 +type TVariation946 = 'GElement 6 1 TRuleContent143 +type TRuleVariation915 = 'GContextFree TVariation946 +type TNonSpare1514 = 'GNonSpare "OL" "" TRuleVariation915 +type TItem709 = 'GItem TNonSpare1514 +type TContent85 = 'GContentTable '[ '(0, "Default"), '(1, "AIW function")] +type TRuleContent85 = 'GContextFree TContent85 +type TVariation24 = 'GElement 0 1 TRuleContent85 +type TRuleVariation24 = 'GContextFree TVariation24 +type TNonSpare640 = 'GNonSpare "AIW" "" TRuleVariation24 +type TItem59 = 'GItem TNonSpare640 +type TContent144 = 'GContentTable '[ '(0, "Default"), '(1, "PAIW function")] +type TRuleContent144 = 'GContextFree TContent144 +type TVariation429 = 'GElement 1 1 TRuleContent144 +type TRuleVariation417 = 'GContextFree TVariation429 +type TNonSpare1538 = 'GNonSpare "PAIW" "" TRuleVariation417 +type TItem731 = 'GItem TNonSpare1538 +type TContent139 = 'GContentTable '[ '(0, "Default"), '(1, "OCAT function")] +type TRuleContent139 = 'GContextFree TContent139 +type TVariation539 = 'GElement 2 1 TRuleContent139 +type TRuleVariation527 = 'GContextFree TVariation539 +type TNonSpare1507 = 'GNonSpare "OCAT" "" TRuleVariation527 +type TItem702 = 'GItem TNonSpare1507 +type TContent153 = 'GContentTable '[ '(0, "Default"), '(1, "SAM function")] +type TRuleContent153 = 'GContextFree TContent153 +type TVariation652 = 'GElement 3 1 TRuleContent153 +type TRuleVariation640 = 'GContextFree TVariation652 +type TNonSpare1801 = 'GNonSpare "SAM" "" TRuleVariation640 +type TItem923 = 'GItem TNonSpare1801 +type TContent165 = 'GContentTable '[ '(0, "Default"), '(1, "VCD function")] +type TRuleContent165 = 'GContextFree TContent165 +type TVariation737 = 'GElement 4 1 TRuleContent165 +type TRuleVariation725 = 'GContextFree TVariation737 +type TNonSpare2215 = 'GNonSpare "VCD" "" TRuleVariation725 +type TItem1240 = 'GItem TNonSpare2215 +type TContent91 = 'GContentTable '[ '(0, "Default"), '(1, "CHAM function")] +type TRuleContent91 = 'GContextFree TContent91 +type TVariation858 = 'GElement 5 1 TRuleContent91 +type TRuleVariation827 = 'GContextFree TVariation858 +type TNonSpare798 = 'GNonSpare "CHAM" "" TRuleVariation827 +type TItem168 = 'GItem TNonSpare798 +type TContent98 = 'GContentTable '[ '(0, "Default"), '(1, "DSAM function")] +type TRuleContent98 = 'GContextFree TContent98 +type TVariation940 = 'GElement 6 1 TRuleContent98 +type TRuleVariation909 = 'GContextFree TVariation940 +type TNonSpare972 = 'GNonSpare "DSAM" "" TRuleVariation909 +type TItem293 = 'GItem TNonSpare972 +type TContent95 = 'GContentTable '[ '(0, "Default"), '(1, "DBPSM ARR sub-function")] +type TRuleContent95 = 'GContextFree TContent95 +type TVariation28 = 'GElement 0 1 TRuleContent95 +type TRuleVariation28 = 'GContextFree TVariation28 +type TNonSpare934 = 'GNonSpare "DBPSMARR" "" TRuleVariation28 +type TItem260 = 'GItem TNonSpare934 +type TContent96 = 'GContentTable '[ '(0, "Default"), '(1, "DBPSM DEP sub-function")] +type TRuleContent96 = 'GContextFree TContent96 +type TVariation420 = 'GElement 1 1 TRuleContent96 +type TRuleVariation408 = 'GContextFree TVariation420 +type TNonSpare936 = 'GNonSpare "DBPSMDEP" "" TRuleVariation408 +type TItem262 = 'GItem TNonSpare936 +type TContent97 = 'GContentTable '[ '(0, "Default"), '(1, "DBPSM TL sub-function")] +type TRuleContent97 = 'GContextFree TContent97 +type TVariation533 = 'GElement 2 1 TRuleContent97 +type TRuleVariation521 = 'GContextFree TVariation533 +type TNonSpare938 = 'GNonSpare "DBPSMTL" "" TRuleVariation521 +type TItem264 = 'GItem TNonSpare938 +type TContent167 = 'GContentTable '[ '(0, "Default"), '(1, "VRAM CRM sub-function")] +type TRuleContent167 = 'GContextFree TContent167 +type TVariation654 = 'GElement 3 1 TRuleContent167 +type TRuleVariation642 = 'GContextFree TVariation654 +type TNonSpare2229 = 'GNonSpare "VRAMCRM" "" TRuleVariation642 +type TItem1253 = 'GItem TNonSpare2229 +type TContent169 = 'GContentTable '[ '(0, "Default"), '(1, "VRAM VTM sub-function")] +type TRuleContent169 = 'GContextFree TContent169 +type TVariation739 = 'GElement 4 1 TRuleContent169 +type TRuleVariation727 = 'GContextFree TVariation739 +type TNonSpare2232 = 'GNonSpare "VRAMVTM" "" TRuleVariation727 +type TItem1256 = 'GItem TNonSpare2232 +type TContent168 = 'GContentTable '[ '(0, "Default"), '(1, "VRAM VRM sub-function")] +type TRuleContent168 = 'GContextFree TContent168 +type TVariation870 = 'GElement 5 1 TRuleContent168 +type TRuleVariation839 = 'GContextFree TVariation870 +type TNonSpare2231 = 'GNonSpare "VRAMVRM" "" TRuleVariation839 +type TItem1255 = 'GItem TNonSpare2231 +type TContent106 = 'GContentTable '[ '(0, "Default"), '(1, "HAM HD sub-function")] +type TRuleContent106 = 'GContextFree TContent106 +type TVariation943 = 'GElement 6 1 TRuleContent106 +type TRuleVariation912 = 'GContextFree TVariation943 +type TNonSpare1132 = 'GNonSpare "HAMHD" "" TRuleVariation912 +type TItem404 = 'GItem TNonSpare1132 +type TContent107 = 'GContentTable '[ '(0, "Default"), '(1, "HAM RD sub-function")] +type TRuleContent107 = 'GContextFree TContent107 +type TVariation30 = 'GElement 0 1 TRuleContent107 +type TRuleVariation30 = 'GContextFree TVariation30 +type TNonSpare1134 = 'GNonSpare "HAMRD" "" TRuleVariation30 +type TItem406 = 'GItem TNonSpare1134 +type TContent108 = 'GContentTable '[ '(0, "Default"), '(1, "HAM VD sub-function")] +type TRuleContent108 = 'GContextFree TContent108 +type TVariation423 = 'GElement 1 1 TRuleContent108 +type TRuleVariation411 = 'GContextFree TVariation423 +type TNonSpare1136 = 'GNonSpare "HAMVD" "" TRuleVariation411 +type TItem408 = 'GItem TNonSpare1136 +type TContent109 = 'GContentTable '[ '(0, "Default"), '(1, "HVI function")] +type TRuleContent109 = 'GContextFree TContent109 +type TVariation535 = 'GElement 2 1 TRuleContent109 +type TRuleVariation523 = 'GContextFree TVariation535 +type TNonSpare1163 = 'GNonSpare "HVI" "" TRuleVariation523 +type TItem429 = 'GItem TNonSpare1163 +type TContent116 = 'GContentTable '[ '(0, "Default"), '(1, "LTW function")] +type TRuleContent116 = 'GContextFree TContent116 +type TVariation645 = 'GElement 3 1 TRuleContent116 +type TRuleVariation633 = 'GContextFree TVariation645 +type TNonSpare1286 = 'GNonSpare "LTW" "" TRuleVariation633 +type TItem538 = 'GItem TNonSpare1286 +type TContent166 = 'GContentTable '[ '(0, "Default"), '(1, "VPM function")] +type TRuleContent166 = 'GContextFree TContent166 +type TVariation738 = 'GElement 4 1 TRuleContent166 +type TRuleVariation726 = 'GContextFree TVariation738 +type TNonSpare2226 = 'GNonSpare "VPM" "" TRuleVariation726 +type TItem1250 = 'GItem TNonSpare2226 +type TContent159 = 'GContentTable '[ '(0, "Default"), '(1, "TTA function")] +type TRuleContent159 = 'GContextFree TContent159 +type TVariation868 = 'GElement 5 1 TRuleContent159 +type TRuleVariation837 = 'GContextFree TVariation868 +type TNonSpare2117 = 'GNonSpare "TTA" "" TRuleVariation837 +type TItem1148 = 'GItem TNonSpare2117 +type TContent93 = 'GContentTable '[ '(0, "Default"), '(1, "CRA function")] +type TRuleContent93 = 'GContextFree TContent93 +type TVariation938 = 'GElement 6 1 TRuleContent93 +type TRuleVariation907 = 'GContextFree TVariation938 +type TNonSpare896 = 'GNonSpare "CRA" "" TRuleVariation907 +type TItem230 = 'GItem TNonSpare896 +type TContent88 = 'GContentTable '[ '(0, "Default"), '(1, "ASM sub-function")] +type TRuleContent88 = 'GContextFree TContent88 +type TVariation26 = 'GElement 0 1 TRuleContent88 +type TRuleVariation26 = 'GContextFree TVariation26 +type TNonSpare691 = 'GNonSpare "ASM" "" TRuleVariation26 +type TItem90 = 'GItem TNonSpare691 +type TContent111 = 'GContentTable '[ '(0, "Default"), '(1, "IAVM sub-function")] +type TRuleContent111 = 'GContextFree TContent111 +type TVariation424 = 'GElement 1 1 TRuleContent111 +type TRuleVariation412 = 'GContextFree TVariation424 +type TNonSpare1183 = 'GNonSpare "IAVM" "" TRuleVariation412 +type TItem445 = 'GItem TNonSpare1183 +type TContent101 = 'GContentTable '[ '(0, "Default"), '(1, "FTD Function")] +type TRuleContent101 = 'GContextFree TContent101 +type TVariation534 = 'GElement 2 1 TRuleContent101 +type TRuleVariation522 = 'GContextFree TVariation534 +type TNonSpare1080 = 'GNonSpare "FTD" "" TRuleVariation522 +type TItem373 = 'GItem TNonSpare1080 +type TContent113 = 'GContentTable '[ '(0, "Default"), '(1, "ITD function")] +type TRuleContent113 = 'GContextFree TContent113 +type TVariation643 = 'GElement 3 1 TRuleContent113 +type TRuleVariation631 = 'GContextFree TVariation643 +type TNonSpare1208 = 'GNonSpare "ITD" "" TRuleVariation631 +type TItem464 = 'GItem TNonSpare1208 +type TContent112 = 'GContentTable '[ '(0, "Default"), '(1, "IIA function")] +type TRuleContent112 = 'GContextFree TContent112 +type TVariation732 = 'GElement 4 1 TRuleContent112 +type TRuleVariation720 = 'GContextFree TVariation732 +type TNonSpare1198 = 'GNonSpare "IIA" "" TRuleVariation720 +type TItem456 = 'GItem TNonSpare1198 +type TContent154 = 'GContentTable '[ '(0, "Default"), '(1, "SQW function")] +type TRuleContent154 = 'GContextFree TContent154 +type TVariation865 = 'GElement 5 1 TRuleContent154 +type TRuleVariation834 = 'GContextFree TVariation865 +type TNonSpare1902 = 'GNonSpare "SQW" "" TRuleVariation834 +type TItem996 = 'GItem TNonSpare1902 +type TContent94 = 'GContentTable '[ '(0, "Default"), '(1, "CUW function")] +type TRuleContent94 = 'GContextFree TContent94 +type TVariation939 = 'GElement 6 1 TRuleContent94 +type TRuleVariation908 = 'GContextFree TVariation939 +type TNonSpare919 = 'GNonSpare "CUW" "" TRuleVariation908 +type TItem248 = 'GItem TNonSpare919 +type TContent90 = 'GContentTable '[ '(0, "Default"), '(1, "CATC function")] +type TRuleContent90 = 'GContextFree TContent90 +type TVariation27 = 'GElement 0 1 TRuleContent90 +type TRuleVariation27 = 'GContextFree TVariation27 +type TNonSpare769 = 'GNonSpare "CATC" "" TRuleVariation27 +type TItem147 = 'GItem TNonSpare769 +type TContent134 = 'GContentTable '[ '(0, "Default"), '(1, "NOCLR sub-function")] +type TRuleContent134 = 'GContextFree TContent134 +type TVariation428 = 'GElement 1 1 TRuleContent134 +type TRuleVariation416 = 'GContextFree TVariation428 +type TNonSpare1480 = 'GNonSpare "NOCLR" "" TRuleVariation416 +type TItem676 = 'GItem TNonSpare1480 +type TContent136 = 'GContentTable '[ '(0, "Default"), '(1, "NOMOV Function")] +type TRuleContent136 = 'GContextFree TContent136 +type TVariation538 = 'GElement 2 1 TRuleContent136 +type TRuleVariation526 = 'GContextFree TVariation538 +type TNonSpare1493 = 'GNonSpare "NOMOV" "" TRuleVariation526 +type TItem689 = 'GItem TNonSpare1493 +type TContent135 = 'GContentTable '[ '(0, "Default"), '(1, "NOH function")] +type TRuleContent135 = 'GContextFree TContent135 +type TVariation650 = 'GElement 3 1 TRuleContent135 +type TRuleVariation638 = 'GContextFree TVariation650 +type TNonSpare1488 = 'GNonSpare "NOH" "" TRuleVariation638 +type TItem684 = 'GItem TNonSpare1488 +type TContent170 = 'GContentTable '[ '(0, "Default"), '(1, "WRTY function")] +type TRuleContent170 = 'GContextFree TContent170 +type TVariation740 = 'GElement 4 1 TRuleContent170 +type TRuleVariation728 = 'GContextFree TVariation740 +type TNonSpare2253 = 'GNonSpare "WRTY" "" TRuleVariation728 +type TItem1272 = 'GItem TNonSpare2253 +type TContent156 = 'GContentTable '[ '(0, "Default"), '(1, "STOCC function")] +type TRuleContent156 = 'GContextFree TContent156 +type TVariation866 = 'GElement 5 1 TRuleContent156 +type TRuleVariation835 = 'GContextFree TVariation866 +type TNonSpare1956 = 'GNonSpare "STOCC" "" TRuleVariation835 +type TItem1035 = 'GItem TNonSpare1956 +type TContent140 = 'GContentTable '[ '(0, "Default"), '(1, "ONGOING function")] +type TRuleContent140 = 'GContextFree TContent140 +type TVariation945 = 'GElement 6 1 TRuleContent140 +type TRuleVariation914 = 'GContextFree TVariation945 +type TNonSpare1516 = 'GNonSpare "ONGOING" "" TRuleVariation914 +type TItem711 = 'GItem TNonSpare1516 +type TVariation1443 = 'GExtended '[ 'Just TItem631, 'Just TItem833, 'Just TItem832, 'Just TItem635, 'Just TItem81, 'Just TItem175, 'Just TItem1029, 'Nothing, 'Just TItem80, 'Just TItem883, 'Just TItem42, 'Just TItem693, 'Just TItem277, 'Just TItem708, 'Just TItem709, 'Nothing, 'Just TItem59, 'Just TItem731, 'Just TItem702, 'Just TItem923, 'Just TItem1240, 'Just TItem168, 'Just TItem293, 'Nothing, 'Just TItem260, 'Just TItem262, 'Just TItem264, 'Just TItem1253, 'Just TItem1256, 'Just TItem1255, 'Just TItem404, 'Nothing, 'Just TItem406, 'Just TItem408, 'Just TItem429, 'Just TItem538, 'Just TItem1250, 'Just TItem1148, 'Just TItem230, 'Nothing, 'Just TItem90, 'Just TItem445, 'Just TItem373, 'Just TItem464, 'Just TItem456, 'Just TItem996, 'Just TItem248, 'Nothing, 'Just TItem147, 'Just TItem676, 'Just TItem689, 'Just TItem684, 'Just TItem1272, 'Just TItem1035, 'Just TItem711, 'Nothing] +type TRuleVariation1359 = 'GContextFree TVariation1443 +type TNonSpare203 = 'GNonSpare "060" "Safety Net Function and System Status" TRuleVariation1359 +type TUapItem203 = 'GUapItem TNonSpare203 +type TNonSpare117 = 'GNonSpare "030" "Track Number 1" TRuleVariation259 +type TUapItem117 = 'GUapItem TNonSpare117 +type TContent636 = 'GContentString 'GStringAscii +type TRuleContent634 = 'GContextFree TContent636 +type TVariation407 = 'GElement 0 56 TRuleContent634 +type TRuleVariation398 = 'GContextFree TVariation407 +type TNonSpare637 = 'GNonSpare "AI1" "Aircraft Identifier (in 7 Characters) of Aircraft 1 Involved in the Conflict" TRuleVariation398 +type TNonSpare1416 = 'GNonSpare "MODE3A" "Mode-3/A Code (Converted Into Octal Representation) of Aircraft 1 Involved in the Conflict" TRuleVariation807 +type TItem620 = 'GItem TNonSpare1416 +type TVariation1067 = 'GGroup 0 '[ TItem3, TItem620] +type TRuleVariation1035 = 'GContextFree TVariation1067 +type TNonSpare1300 = 'GNonSpare "M31" "Mode 3/A Code Aircraft 1" TRuleVariation1035 +type TContent727 = 'GContentQuantity 'GSigned ('GNumDiv ('GNumInt ('GZ 'GPlus 180)) ('GNumPow ('GZ 'GPlus 2) ('GZ 'GPlus 25))) "°" +type TRuleContent725 = 'GContextFree TContent727 +type TVariation392 = 'GElement 0 32 TRuleContent725 +type TRuleVariation384 = 'GContextFree TVariation392 +type TNonSpare1240 = 'GNonSpare "LAT" "Latitude in WGS-84 in Two’s Complement" TRuleVariation384 +type TItem496 = 'GItem TNonSpare1240 +type TContent726 = 'GContentQuantity 'GSigned ('GNumDiv ('GNumInt ('GZ 'GPlus 180)) ('GNumPow ('GZ 'GPlus 2) ('GZ 'GPlus 25))) "°" +type TRuleContent724 = 'GContextFree TContent726 +type TVariation391 = 'GElement 0 32 TRuleContent724 +type TRuleVariation383 = 'GContextFree TVariation391 +type TNonSpare1273 = 'GNonSpare "LON" "Longitude in WGS-84 in Two’s Complement" TRuleVariation383 +type TItem527 = 'GItem TNonSpare1273 +type TContent661 = 'GContentQuantity 'GSigned ('GNumInt ('GZ 'GPlus 25)) "ft" +type TRuleContent659 = 'GContextFree TContent661 +type TVariation277 = 'GElement 0 16 TRuleContent659 +type TRuleVariation269 = 'GContextFree TVariation277 +type TNonSpare647 = 'GNonSpare "ALT" "Altitude of Predicted Conflict" TRuleVariation269 +type TItem66 = 'GItem TNonSpare647 +type TVariation1192 = 'GGroup 0 '[ TItem496, TItem527, TItem66] +type TRuleVariation1143 = 'GContextFree TVariation1192 +type TNonSpare892 = 'GNonSpare "CPW" "Predicted Conflict Position Target 1 in WGS-84 Coordinates" TRuleVariation1143 +type TContent666 = 'GContentQuantity 'GSigned ('GNumDiv ('GNumInt ('GZ 'GPlus 1)) ('GNumInt ('GZ 'GPlus 2))) "m" +type TRuleContent664 = 'GContextFree TContent666 +type TVariation366 = 'GElement 0 24 TRuleContent664 +type TRuleVariation358 = 'GContextFree TVariation366 +type TNonSpare2282 = 'GNonSpare "X" "Starting X-position of the Conflict" TRuleVariation358 +type TItem1298 = 'GItem TNonSpare2282 +type TNonSpare2336 = 'GNonSpare "Y" "Starting Y-position of the Conflict" TRuleVariation358 +type TItem1348 = 'GItem TNonSpare2336 +type TNonSpare2354 = 'GNonSpare "Z" "Starting Z-position of the Conflict" TRuleVariation269 +type TItem1366 = 'GItem TNonSpare2354 +type TVariation1371 = 'GGroup 0 '[ TItem1298, TItem1348, TItem1366] +type TRuleVariation1295 = 'GContextFree TVariation1371 +type TNonSpare887 = 'GNonSpare "CPC" "Predicted Conflict Position for the Aircraft 1 Involved in the Conflict" TRuleVariation1295 +type TNonSpare2115 = 'GNonSpare "TT1" "Time to Runway Threshold for First Approaching Aircraft in a RIMCA" TRuleVariation376 +type TContent762 = 'GContentQuantity 'GUnsigned ('GNumDiv ('GNumInt ('GZ 'GPlus 1)) ('GNumInt ('GZ 'GPlus 2))) "m" +type TRuleContent760 = 'GContextFree TContent762 +type TVariation325 = 'GElement 0 16 TRuleContent760 +type TRuleVariation317 = 'GContextFree TVariation325 +type TNonSpare974 = 'GNonSpare "DT1" "Distance to Runway Threshold for Aircraft 1 Involved in a RIMCA" TRuleVariation317 +type TContent574 = 'GContentTable '[ '(0, "Unknown"), '(1, "General Air Traffic"), '(2, "Operational Air Traffic"), '(3, "Not applicable")] +type TRuleContent572 = 'GContextFree TContent574 +type TVariation122 = 'GElement 0 2 TRuleContent572 +type TRuleVariation122 = 'GContextFree TVariation122 +type TNonSpare1103 = 'GNonSpare "GATOAT" "Identification of Conflict Categories Definition Table" TRuleVariation122 +type TItem386 = 'GItem TNonSpare1103 +type TContent252 = 'GContentTable '[ '(0, "Instrument Flight Rules"), '(1, "Visual Flight rules"), '(2, "Not applicable"), '(3, "Controlled Visual Flight Rules")] +type TRuleContent252 = 'GContextFree TContent252 +type TVariation610 = 'GElement 2 2 TRuleContent252 +type TRuleVariation598 = 'GContextFree TVariation610 +type TNonSpare1070 = 'GNonSpare "FR1FR2" "Flight Rules" TRuleVariation598 +type TItem366 = 'GItem TNonSpare1070 +type TContent567 = 'GContentTable '[ '(0, "Unknown"), '(1, "Approved"), '(2, "Exempt"), '(3, "Not Approved")] +type TRuleContent565 = 'GContextFree TContent567 +type TVariation796 = 'GElement 4 2 TRuleContent565 +type TRuleVariation784 = 'GContextFree TVariation796 +type TNonSpare1777 = 'GNonSpare "RVSM" "" TRuleVariation784 +type TItem906 = 'GItem TNonSpare1777 +type TContent403 = 'GContentTable '[ '(0, "Normal Priority Flight"), '(1, "High Priority Flight")] +type TRuleContent401 = 'GContextFree TContent403 +type TVariation974 = 'GElement 6 1 TRuleContent401 +type TRuleVariation943 = 'GContextFree TVariation974 +type TNonSpare1155 = 'GNonSpare "HPR" "" TRuleVariation943 +type TItem423 = 'GItem TNonSpare1155 +type TContent273 = 'GContentTable '[ '(0, "Maintaining"), '(1, "Climbing"), '(2, "Descending"), '(3, "Invalid")] +type TRuleContent271 = 'GContextFree TContent273 +type TVariation109 = 'GElement 0 2 TRuleContent271 +type TRuleVariation109 = 'GContextFree TVariation109 +type TNonSpare779 = 'GNonSpare "CDM" "Climbing/Descending Mode" TRuleVariation109 +type TItem153 = 'GItem TNonSpare779 +type TContent396 = 'GContentTable '[ '(0, "Non primary target"), '(1, "Primary target")] +type TRuleContent394 = 'GContextFree TContent396 +type TVariation583 = 'GElement 2 1 TRuleContent394 +type TRuleVariation571 = 'GContextFree TVariation583 +type TNonSpare1588 = 'GNonSpare "PRI" "" TRuleVariation571 +type TItem763 = 'GItem TNonSpare1588 +type TContent105 = 'GContentTable '[ '(0, "Default"), '(1, "Ground Vehicle")] +type TRuleContent105 = 'GContextFree TContent105 +type TVariation642 = 'GElement 3 1 TRuleContent105 +type TRuleVariation630 = 'GContextFree TVariation642 +type TNonSpare1124 = 'GNonSpare "GV" "" TRuleVariation630 +type TItem401 = 'GItem TNonSpare1124 +type TItem21 = 'GSpare 4 3 +type TVariation1433 = 'GExtended '[ 'Just TItem386, 'Just TItem366, 'Just TItem906, 'Just TItem423, 'Nothing, 'Just TItem153, 'Just TItem763, 'Just TItem401, 'Just TItem21, 'Nothing] +type TRuleVariation1349 = 'GContextFree TVariation1433 +type TNonSpare607 = 'GNonSpare "AC1" "Characteristics of Aircraft 1 Involved in the Conflict" TRuleVariation1349 +type TContent637 = 'GContentString 'GStringICAO +type TRuleContent635 = 'GContextFree TContent637 +type TVariation405 = 'GElement 0 48 TRuleContent635 +type TRuleVariation396 = 'GContextFree TVariation405 +type TNonSpare1432 = 'GNonSpare "MS1" "Aircraft Identification Downloaded from Aircraft 1 Involved in the Conflict If Equipped with a Mode-S Transponder" TRuleVariation396 +type TItem4 = 'GSpare 0 5 +type TContent738 = 'GContentQuantity 'GUnsigned ('GNumInt ('GZ 'GPlus 1)) "" +type TRuleContent736 = 'GContextFree TContent738 +type TVariation928 = 'GElement 5 27 TRuleContent736 +type TRuleVariation897 = 'GContextFree TVariation928 +type TNonSpare1469 = 'GNonSpare "NBR" "" TRuleVariation897 +type TItem665 = 'GItem TNonSpare1469 +type TVariation1080 = 'GGroup 0 '[ TItem4, TItem665] +type TRuleVariation1047 = 'GContextFree TVariation1080 +type TNonSpare1061 = 'GNonSpare "FP1" "Number of the Flight Plan Correlated to Aircraft 1 Involved in the Conflict" TRuleVariation1047 +type TContent782 = 'GContentQuantity 'GUnsigned ('GNumDiv ('GNumInt ('GZ 'GPlus 1)) ('GNumPow ('GZ 'GPlus 2) ('GZ 'GPlus 2))) "FL" +type TRuleContent779 = 'GContextFree TContent782 +type TVariation335 = 'GElement 0 16 TRuleContent779 +type TRuleVariation327 = 'GContextFree TVariation335 +type TNonSpare790 = 'GNonSpare "CF1" "Cleared Flight Level for Aircraft 1 Involved in the Conflict" TRuleVariation327 +type TVariation1551 = 'GCompound '[ 'Just TNonSpare637, 'Just TNonSpare1300, 'Just TNonSpare892, 'Just TNonSpare887, 'Just TNonSpare2115, 'Just TNonSpare974, 'Just TNonSpare607, 'Just TNonSpare1432, 'Just TNonSpare1061, 'Just TNonSpare790] +type TRuleVariation1467 = 'GContextFree TVariation1551 +type TNonSpare393 = 'GNonSpare "170" "Aircraft Identification and Characteristics 1" TRuleVariation1467 +type TUapItem393 = 'GUapItem TNonSpare393 +type TContent71 = 'GContentTable '[ '(0, "Conflict not predicted to occur in military airspace"), '(1, "Conflict predicted to occur in military airspace")] +type TRuleContent71 = 'GContextFree TContent71 +type TVariation21 = 'GElement 0 1 TRuleContent71 +type TRuleVariation21 = 'GContextFree TVariation21 +type TNonSpare1329 = 'GNonSpare "MAS" "Conflict Location in Military Airspace" TRuleVariation21 +type TItem570 = 'GItem TNonSpare1329 +type TContent70 = 'GContentTable '[ '(0, "Conflict not predicted to occur in civil airspace"), '(1, "Conflict predicted to occur in civil airspace")] +type TRuleContent70 = 'GContextFree TContent70 +type TVariation418 = 'GElement 1 1 TRuleContent70 +type TRuleVariation406 = 'GContextFree TVariation418 +type TNonSpare765 = 'GNonSpare "CAS" "Conflict Location in Civil Airspace" TRuleVariation406 +type TItem144 = 'GItem TNonSpare765 +type TContent29 = 'GContentTable '[ '(0, "Aircraft are not fast diverging laterally at current time"), '(1, "Aircraft are fast diverging laterally at current time")] +type TRuleContent29 = 'GContextFree TContent29 +type TVariation526 = 'GElement 2 1 TRuleContent29 +type TRuleVariation514 = 'GContextFree TVariation526 +type TNonSpare1051 = 'GNonSpare "FLD" "Fast Lateral Divergence" TRuleVariation514 +type TItem354 = 'GItem TNonSpare1051 +type TContent30 = 'GContentTable '[ '(0, "Aircraft are not fast diverging vertically at current time"), '(1, "Aircraft are fast diverging vertically at current time")] +type TRuleContent30 = 'GContextFree TContent30 +type TVariation636 = 'GElement 3 1 TRuleContent30 +type TRuleVariation624 = 'GContextFree TVariation636 +type TNonSpare1083 = 'GNonSpare "FVD" "Fast Vertical Divergence" TRuleVariation624 +type TItem376 = 'GItem TNonSpare1083 +type TContent280 = 'GContentTable '[ '(0, "Minor separation infringement"), '(1, "Major separation infringement")] +type TRuleContent278 = 'GContextFree TContent280 +type TVariation757 = 'GElement 4 1 TRuleContent278 +type TRuleVariation745 = 'GContextFree TVariation757 +type TNonSpare2148 = 'GNonSpare "TYPE" "Type of Separation Infringement" TRuleVariation745 +type TItem1177 = 'GItem TNonSpare2148 +type TContent32 = 'GContentTable '[ '(0, "Aircraft have not crossed at starting time of conflict"), '(1, "Aircraft have crossed at starting time of conflict")] +type TRuleContent32 = 'GContextFree TContent32 +type TVariation850 = 'GElement 5 1 TRuleContent32 +type TRuleVariation819 = 'GContextFree TVariation850 +type TNonSpare897 = 'GNonSpare "CROSS" "Crossing Test" TRuleVariation819 +type TItem231 = 'GItem TNonSpare897 +type TContent28 = 'GContentTable '[ '(0, "Aircraft are not diverging at starting time of conflict"), '(1, "Aircraft are diverging at starting time of conflict")] +type TRuleContent28 = 'GContextFree TContent28 +type TVariation932 = 'GElement 6 1 TRuleContent28 +type TRuleVariation901 = 'GContextFree TVariation932 +type TNonSpare955 = 'GNonSpare "DIV" "Divergence Test" TRuleVariation901 +type TItem280 = 'GItem TNonSpare955 +type TContent151 = 'GContentTable '[ '(0, "Default"), '(1, "Runway/Runway Crossing")] +type TRuleContent151 = 'GContextFree TContent151 +type TVariation36 = 'GElement 0 1 TRuleContent151 +type TRuleVariation36 = 'GContextFree TVariation36 +type TNonSpare1749 = 'GNonSpare "RRC" "Runway/Runway Crossing in RIMCAS" TRuleVariation36 +type TItem891 = 'GItem TNonSpare1749 +type TContent152 = 'GContentTable '[ '(0, "Default"), '(1, "Runway/Taxiway Crossing")] +type TRuleContent152 = 'GContextFree TContent152 +type TVariation432 = 'GElement 1 1 TRuleContent152 +type TRuleVariation420 = 'GContextFree TVariation432 +type TNonSpare1772 = 'GNonSpare "RTC" "Runway/Taxiway Crossing in RIMCAS" TRuleVariation420 +type TItem902 = 'GItem TNonSpare1772 +type TContent132 = 'GContentTable '[ '(0, "Default"), '(1, "Msg Type 4 (MSAW) indicates MRVA")] +type TRuleContent132 = 'GContextFree TContent132 +type TVariation537 = 'GElement 2 1 TRuleContent132 +type TRuleVariation525 = 'GContextFree TVariation537 +type TNonSpare1428 = 'GNonSpare "MRVA" "" TRuleVariation525 +type TItem632 = 'GItem TNonSpare1428 +type TContent126 = 'GContentTable '[ '(0, "Default"), '(1, "Msg Type 25 (VRAM) indicates CRM")] +type TRuleContent126 = 'GContextFree TContent126 +type TVariation649 = 'GElement 3 1 TRuleContent126 +type TRuleVariation637 = 'GContextFree TVariation649 +type TNonSpare2228 = 'GNonSpare "VRAMCRM" "" TRuleVariation637 +type TItem1252 = 'GItem TNonSpare2228 +type TContent127 = 'GContentTable '[ '(0, "Default"), '(1, "Msg Type 25 (VRAM) indicates VRM")] +type TRuleContent127 = 'GContextFree TContent127 +type TVariation735 = 'GElement 4 1 TRuleContent127 +type TRuleVariation723 = 'GContextFree TVariation735 +type TNonSpare2230 = 'GNonSpare "VRAMVRM" "" TRuleVariation723 +type TItem1254 = 'GItem TNonSpare2230 +type TContent128 = 'GContentTable '[ '(0, "Default"), '(1, "Msg Type 25 (VRAM) indicates VTM")] +type TRuleContent128 = 'GContextFree TContent128 +type TVariation861 = 'GElement 5 1 TRuleContent128 +type TRuleVariation830 = 'GContextFree TVariation861 +type TNonSpare2233 = 'GNonSpare "VRAMVTM" "" TRuleVariation830 +type TItem1257 = 'GItem TNonSpare2233 +type TContent129 = 'GContentTable '[ '(0, "Default"), '(1, "Msg Type 29 (HAM) indicates HD")] +type TRuleContent129 = 'GContextFree TContent129 +type TVariation944 = 'GElement 6 1 TRuleContent129 +type TRuleVariation913 = 'GContextFree TVariation944 +type TNonSpare1133 = 'GNonSpare "HAMHD" "" TRuleVariation913 +type TItem405 = 'GItem TNonSpare1133 +type TContent130 = 'GContentTable '[ '(0, "Default"), '(1, "Msg Type 29 (HAM) indicates RD")] +type TRuleContent130 = 'GContextFree TContent130 +type TVariation34 = 'GElement 0 1 TRuleContent130 +type TRuleVariation34 = 'GContextFree TVariation34 +type TNonSpare1135 = 'GNonSpare "HAMRD" "" TRuleVariation34 +type TItem407 = 'GItem TNonSpare1135 +type TContent131 = 'GContentTable '[ '(0, "Default"), '(1, "Msg Type 29 (HAM) indicates VD")] +type TRuleContent131 = 'GContextFree TContent131 +type TVariation427 = 'GElement 1 1 TRuleContent131 +type TRuleVariation415 = 'GContextFree TVariation427 +type TNonSpare1137 = 'GNonSpare "HAMVD" "" TRuleVariation415 +type TItem409 = 'GItem TNonSpare1137 +type TContent123 = 'GContentTable '[ '(0, "Default"), '(1, "Msg Type 20 (DBPSM) indicates ARR")] +type TRuleContent123 = 'GContextFree TContent123 +type TVariation536 = 'GElement 2 1 TRuleContent123 +type TRuleVariation524 = 'GContextFree TVariation536 +type TNonSpare935 = 'GNonSpare "DBPSMARR" "" TRuleVariation524 +type TItem261 = 'GItem TNonSpare935 +type TContent124 = 'GContentTable '[ '(0, "Default"), '(1, "Msg Type 20 (DBPSM) indicates DEP")] +type TRuleContent124 = 'GContextFree TContent124 +type TVariation648 = 'GElement 3 1 TRuleContent124 +type TRuleVariation636 = 'GContextFree TVariation648 +type TNonSpare937 = 'GNonSpare "DBPSMDEP" "" TRuleVariation636 +type TItem263 = 'GItem TNonSpare937 +type TContent125 = 'GContentTable '[ '(0, "Default"), '(1, "Msg Type 20 (DBPSM) indicates above TL")] +type TRuleContent125 = 'GContextFree TContent125 +type TVariation734 = 'GElement 4 1 TRuleContent125 +type TRuleVariation722 = 'GContextFree TVariation734 +type TNonSpare939 = 'GNonSpare "DBPSMTL" "" TRuleVariation722 +type TItem265 = 'GItem TNonSpare939 +type TContent133 = 'GContentTable '[ '(0, "Default"), '(1, "Msg Type 99 (AIW) indicates pAIW Alert")] +type TRuleContent133 = 'GContextFree TContent133 +type TVariation862 = 'GElement 5 1 TRuleContent133 +type TRuleVariation831 = 'GContextFree TVariation862 +type TNonSpare641 = 'GNonSpare "AIW" "" TRuleVariation831 +type TItem60 = 'GItem TNonSpare641 +type TItem26 = 'GSpare 6 1 +type TVariation1435 = 'GExtended '[ 'Just TItem570, 'Just TItem144, 'Just TItem354, 'Just TItem376, 'Just TItem1177, 'Just TItem231, 'Just TItem280, 'Nothing, 'Just TItem891, 'Just TItem902, 'Just TItem632, 'Just TItem1252, 'Just TItem1254, 'Just TItem1257, 'Just TItem405, 'Nothing, 'Just TItem407, 'Just TItem409, 'Just TItem261, 'Just TItem263, 'Just TItem265, 'Just TItem60, 'Just TItem26, 'Nothing] +type TRuleVariation1351 = 'GContextFree TVariation1435 +type TNonSpare813 = 'GNonSpare "CN" "Conflict Nature" TRuleVariation1351 +type TVariation140 = 'GElement 0 4 TRuleContent0 +type TRuleVariation140 = 'GContextFree TVariation140 +type TNonSpare2028 = 'GNonSpare "TID" "Identification of Conflict Categories Definition Table" TRuleVariation140 +type TItem1082 = 'GItem TNonSpare2028 +type TContent13 = 'GContentTable '[ '(0, "APW Low Severity"), '(1, "APW Medium Severity"), '(2, "APW High Severity")] +type TRuleContent13 = 'GContextFree TContent13 +type TVariation804 = 'GElement 4 3 TRuleContent13 +type TContent611 = 'GContentTable '[ '(1, "Major seperation infringement and not (crossed and diverging)"), '(2, "Minor seperation infringement and not (crossed and diverging)"), '(3, "Major seperation infringement and (crossed and diverging)"), '(4, "Minor seperation infringement and (crossed and diverging)")] +type TRuleContent609 = 'GContextFree TContent611 +type TVariation826 = 'GElement 4 3 TRuleContent609 +type TContent218 = 'GContentTable '[ '(0, "Filter not set"), '(1, "Filter set")] +type TRuleContent218 = 'GContextFree TContent218 +type TVariation749 = 'GElement 4 1 TRuleContent218 +type TRuleVariation737 = 'GContextFree TVariation749 +type TNonSpare1281 = 'GNonSpare "LPF" "Linear Prediction Filter" TRuleVariation737 +type TItem533 = 'GItem TNonSpare1281 +type TVariation880 = 'GElement 5 1 TRuleContent218 +type TRuleVariation849 = 'GContextFree TVariation880 +type TNonSpare888 = 'GNonSpare "CPF" "Current Proximity Filter" TRuleVariation849 +type TItem225 = 'GItem TNonSpare888 +type TVariation957 = 'GElement 6 1 TRuleContent218 +type TRuleVariation926 = 'GContextFree TVariation957 +type TNonSpare1387 = 'GNonSpare "MHF" "Manoeuvre Hazard Filter" TRuleVariation926 +type TItem596 = 'GItem TNonSpare1387 +type TVariation1406 = 'GGroup 4 '[ TItem533, TItem225, TItem596] +type TContent481 = 'GContentTable '[ '(0, "Stage One Alert"), '(1, "Stage Two Alert")] +type TRuleContent479 = 'GContextFree TContent481 +type TVariation778 = 'GElement 4 1 TRuleContent479 +type TRuleVariation766 = 'GContextFree TVariation778 +type TNonSpare1676 = 'GNonSpare "RAS" "RIMCAS Alert Stage" TRuleVariation766 +type TItem834 = 'GItem TNonSpare1676 +type TVariation1407 = 'GGroup 4 '[ TItem834, TItem24] +type TContent5 = 'GContentTable '[ '(0, "2 aircraft, same taxiway, opposite direction"), '(1, "Aircraft entering wrong direction"), '(2, "Aircraft entering wrong taxiway"), '(3, "Speed violation")] +type TRuleContent5 = 'GContextFree TContent5 +type TVariation803 = 'GElement 4 3 TRuleContent5 +type TContent583 = 'GContentTable '[ '(0, "VRM Slow Climb"), '(1, "VRM Slow Descent")] +type TRuleContent581 = 'GContextFree TContent583 +type TVariation823 = 'GElement 4 3 TRuleContent581 +type TContent584 = 'GContentTable '[ '(0, "VTM Fast Climb"), '(1, "VTM Fast Descent")] +type TRuleContent582 = 'GContextFree TContent584 +type TVariation824 = 'GElement 4 3 TRuleContent582 +type TContent590 = 'GContentTable '[ '(0, "Vertical manoeuvre deviation prior to reaching its expected level"), '(1, "Vertical manoeuvre deviation past its expected level")] +type TRuleContent588 = 'GContextFree TContent590 +type TVariation825 = 'GElement 4 3 TRuleContent588 +type TContent480 = 'GContentTable '[ '(0, "Slow Descent"), '(1, "Fast Descent"), '(2, "Slow Climb"), '(3, "Fast Climb")] +type TRuleContent478 = 'GContextFree TContent480 +type TVariation818 = 'GElement 4 3 TRuleContent478 +type TContent14 = 'GContentTable '[ '(0, "Above"), '(1, "Below")] +type TRuleContent14 = 'GContextFree TContent14 +type TVariation805 = 'GElement 4 3 TRuleContent14 +type TContent500 = 'GContentTable '[ '(0, "Table - Single RWY Operation"), '(1, "MRS - Single RWY Operation"), '(2, "ROT - Single RWY Operation"), '(3, "GAP - Single RWY Operation"), '(4, "Table - Parallel RWY Operation"), '(5, "MRS - Parallel RWY Operation"), '(6, "ROT - Parallel RWY Operation"), '(7, "GAP - Parallel RWY Operation")] +type TRuleContent498 = 'GContextFree TContent500 +type TVariation819 = 'GElement 4 3 TRuleContent498 +type TContent214 = 'GContentTable '[ '(0, "End of Alert"), '(1, "Planned Alert"), '(2, "Alert on TABLE Indicator"), '(3, "Alert on MRS Indicator"), '(4, "Alert on ROT Indicator"), '(5, "Alert on GAP Indicator")] +type TRuleContent214 = 'GContextFree TContent214 +type TVariation810 = 'GElement 4 3 TRuleContent214 +type TContent267 = 'GContentTable '[ '(0, "Line-Up vs. Line-Up"), '(1, "Line-Up vs. Cross or Enter"), '(2, "Line-Up vs. Take-Off"), '(3, "Line-Up vs. Landing")] +type TRuleContent265 = 'GContextFree TContent267 +type TVariation812 = 'GElement 4 3 TRuleContent265 +type TContent75 = 'GContentTable '[ '(0, "Cross or Enter vs. Line-Up"), '(1, "Cross or Enter vs. Cross or Enter"), '(2, "Cross or Enter vs. Take-Off"), '(3, "Cross or Enter vs. Landing")] +type TRuleContent75 = 'GContextFree TContent75 +type TVariation809 = 'GElement 4 3 TRuleContent75 +type TContent501 = 'GContentTable '[ '(0, "Take-Off vs. Line-Up"), '(1, "Take-Off vs. Cross or Enter"), '(2, "Take-Off vs. Take-Off"), '(3, "Take-Off vs. Landing")] +type TRuleContent499 = 'GContextFree TContent501 +type TVariation820 = 'GElement 4 3 TRuleContent499 +type TContent264 = 'GContentTable '[ '(0, "Landing vs. Line-Up"), '(1, "Landing vs. Cross or Enter"), '(2, "Landing vs. Take-Off"), '(3, "Landing vs. Landing")] +type TRuleContent262 = 'GContextFree TContent264 +type TVariation811 = 'GElement 4 3 TRuleContent262 +type TContent455 = 'GContentTable '[ '(0, "Push-Back vs. Push-Back"), '(1, "Push-Back vs. Taxi")] +type TRuleContent453 = 'GContextFree TContent455 +type TVariation817 = 'GElement 4 3 TRuleContent453 +type TContent509 = 'GContentTable '[ '(0, "Taxi vs. Push-Back"), '(1, "TAxi vs. Taxi")] +type TRuleContent507 = 'GContextFree TContent509 +type TVariation821 = 'GElement 4 3 TRuleContent507 +type TContent328 = 'GContentTable '[ '(0, "No Push-Back Clearance"), '(1, "No Taxi Clearance"), '(2, "No Line-Up Clearance"), '(3, "No Crossing Clearance"), '(4, "No Enter Clearance"), '(5, "No Take-Off Clearance"), '(6, "Landing Clearance")] +type TRuleContent326 = 'GContextFree TContent328 +type TVariation813 = 'GElement 4 3 TRuleContent326 +type TContent25 = 'GContentTable '[ '(0, "After Push-Back Clearance"), '(1, "After Taxi Clearance"), '(2, "After Line-Up Clearance"), '(3, "After Crossing Clearance"), '(4, "After Enter Clearance"), '(5, "After Take-Off Clearance"), '(6, "Stationary on Runway"), '(7, "Stationary on Taxiway")] +type TRuleContent25 = 'GContextFree TContent25 +type TVariation808 = 'GElement 4 3 TRuleContent25 +type TContent359 = 'GContentTable '[ '(0, "No contact (receiving ATSU)"), '(1, "No transfer (leaving ATSU)")] +type TRuleContent357 = 'GContextFree TContent359 +type TVariation814 = 'GElement 4 3 TRuleContent357 +type TRuleVariation1525 = 'GDependent '[ '[ "000"], '[ "120", "CC", "TID"]] TVariation801 '[ '( '[ 5, 1], TVariation804), '( '[ 7, 0], TVariation826), '( '[ 7, 1], TVariation1406), '( '[ 9, 2], TVariation1407), '( '[ 10, 2], TVariation1407), '( '[ 11, 2], TVariation1407), '( '[ 12, 2], TVariation1407), '( '[ 13, 2], TVariation1407), '( '[ 14, 2], TVariation1407), '( '[ 15, 2], TVariation1407), '( '[ 16, 2], TVariation1407), '( '[ 15, 1], TVariation803), '( '[ 24, 1], TVariation823), '( '[ 24, 2], TVariation824), '( '[ 26, 1], TVariation825), '( '[ 27, 1], TVariation818), '( '[ 27, 2], TVariation805), '( '[ 33, 1], TVariation819), '( '[ 34, 1], TVariation819), '( '[ 35, 1], TVariation810), '( '[ 38, 0], TVariation812), '( '[ 38, 1], TVariation809), '( '[ 38, 2], TVariation820), '( '[ 38, 3], TVariation811), '( '[ 38, 4], TVariation817), '( '[ 38, 5], TVariation821), '( '[ 39, 1], TVariation813), '( '[ 40, 1], TVariation808), '( '[ 41, 1], TVariation814)] +type TNonSpare885 = 'GNonSpare "CPC" "Conflict Properties Class" TRuleVariation1525 +type TItem223 = 'GItem TNonSpare885 +type TContent263 = 'GContentTable '[ '(0, "LOW"), '(1, "HIGH")] +type TRuleContent261 = 'GContextFree TContent263 +type TVariation1017 = 'GElement 7 1 TRuleContent261 +type TRuleVariation986 = 'GContextFree TVariation1017 +type TNonSpare902 = 'GNonSpare "CS" "Conflict Severity" TRuleVariation986 +type TItem235 = 'GItem TNonSpare902 +type TVariation1287 = 'GGroup 0 '[ TItem1082, TItem223, TItem235] +type TRuleVariation1222 = 'GContextFree TVariation1287 +type TNonSpare773 = 'GNonSpare "CC" "Conflict Classification" TRuleVariation1222 +type TContent761 = 'GContentQuantity 'GUnsigned ('GNumDiv ('GNumInt ('GZ 'GPlus 1)) ('GNumInt ('GZ 'GPlus 2))) "%" +type TRuleContent759 = 'GContextFree TContent761 +type TVariation240 = 'GElement 0 8 TRuleContent759 +type TRuleVariation232 = 'GContextFree TVariation240 +type TNonSpare883 = 'GNonSpare "CP" "Conflict Probability" TRuleVariation232 +type TNonSpare776 = 'GNonSpare "CD" "Conflict Duration" TRuleVariation376 +type TVariation1563 = 'GCompound '[ 'Just TNonSpare813, 'Just TNonSpare773, 'Just TNonSpare883, 'Just TNonSpare776] +type TRuleVariation1479 = 'GContextFree TVariation1563 +type TNonSpare315 = 'GNonSpare "120" "Conflict Characteristics" TRuleVariation1479 +type TUapItem315 = 'GUapItem TNonSpare315 +type TNonSpare1999 = 'GNonSpare "TC" "Time to Conflict" TRuleVariation376 +type TNonSpare2003 = 'GNonSpare "TCA" "Time to Closest Approach" TRuleVariation376 +type TVariation380 = 'GElement 0 24 TRuleContent760 +type TRuleVariation372 = 'GContextFree TVariation380 +type TNonSpare803 = 'GNonSpare "CHS" "Current Horizontal Separation" TRuleVariation372 +type TNonSpare1390 = 'GNonSpare "MHS" "Estimated Minimum Horizontal Separation" TRuleVariation317 +type TContent758 = 'GContentQuantity 'GUnsigned ('GNumInt ('GZ 'GPlus 25)) "ft" +type TRuleContent756 = 'GContextFree TContent758 +type TVariation324 = 'GElement 0 16 TRuleContent756 +type TRuleVariation316 = 'GContextFree TVariation324 +type TNonSpare921 = 'GNonSpare "CVS" "Current Vertical Separation" TRuleVariation316 +type TNonSpare1454 = 'GNonSpare "MVS" "Estimated Minimum Vertical Separation" TRuleVariation316 +type TVariation1602 = 'GCompound '[ 'Just TNonSpare1999, 'Just TNonSpare2003, 'Just TNonSpare803, 'Just TNonSpare1390, 'Just TNonSpare921, 'Just TNonSpare1454] +type TRuleVariation1518 = 'GContextFree TVariation1602 +type TNonSpare214 = 'GNonSpare "070" "Conflict Timing and Separation" TRuleVariation1518 +type TUapItem214 = 'GUapItem TNonSpare214 +type TContent660 = 'GContentQuantity 'GSigned ('GNumInt ('GZ 'GPlus 25)) "ft" +type TRuleContent658 = 'GContextFree TContent660 +type TVariation276 = 'GElement 0 16 TRuleContent658 +type TRuleVariation268 = 'GContextFree TVariation276 +type TNonSpare241 = 'GNonSpare "076" "Vertical Deviation" TRuleVariation268 +type TUapItem241 = 'GUapItem TNonSpare241 +type TContent665 = 'GContentQuantity 'GSigned ('GNumInt ('GZ 'GPlus 32)) "m" +type TRuleContent663 = 'GContextFree TContent665 +type TVariation278 = 'GElement 0 16 TRuleContent663 +type TRuleVariation270 = 'GContextFree TVariation278 +type TNonSpare236 = 'GNonSpare "074" "Longitudinal Deviation" TRuleVariation270 +type TUapItem236 = 'GUapItem TNonSpare236 +type TNonSpare239 = 'GNonSpare "075" "Transversal Distance Deviation" TRuleVariation358 +type TUapItem239 = 'GUapItem TNonSpare239 +type TNonSpare662 = 'GNonSpare "AN" "Area Name" TRuleVariation396 +type TNonSpare764 = 'GNonSpare "CAN" "Crossing Area Name" TRuleVariation398 +type TNonSpare1768 = 'GNonSpare "RT1" "Runway/Taxiway Designator 1" TRuleVariation398 +type TNonSpare1769 = 'GNonSpare "RT2" "Runway/Taxiway Designator 2" TRuleVariation398 +type TNonSpare1806 = 'GNonSpare "SB" "Stop Bar Designator" TRuleVariation398 +type TNonSpare1087 = 'GNonSpare "G" "Gate Designator" TRuleVariation398 +type TVariation1555 = 'GCompound '[ 'Just TNonSpare662, 'Just TNonSpare764, 'Just TNonSpare1768, 'Just TNonSpare1769, 'Just TNonSpare1806, 'Just TNonSpare1087] +type TRuleVariation1471 = 'GContextFree TVariation1555 +type TNonSpare282 = 'GNonSpare "100" "Area Definition" TRuleVariation1471 +type TUapItem282 = 'GUapItem TNonSpare282 +type TNonSpare134 = 'GNonSpare "035" "Track Number 2" TRuleVariation259 +type TUapItem134 = 'GUapItem TNonSpare134 +type TNonSpare638 = 'GNonSpare "AI2" "Aircraft Identifier (in 7 Characters) of Aircraft 2 Involved in the Conflict" TRuleVariation398 +type TNonSpare1417 = 'GNonSpare "MODE3A" "Mode-3/A Code (Converted Into Octal Representation) of Aircraft 2 Involved in the Conflict" TRuleVariation807 +type TItem621 = 'GItem TNonSpare1417 +type TVariation1068 = 'GGroup 0 '[ TItem3, TItem621] +type TRuleVariation1036 = 'GContextFree TVariation1068 +type TNonSpare1301 = 'GNonSpare "M32" "Mode 3/A Code Aircraft 2" TRuleVariation1036 +type TNonSpare893 = 'GNonSpare "CPW" "Predicted Conflict Position Target 2 in WGS-84 Coordinates" TRuleVariation1143 +type TNonSpare890 = 'GNonSpare "CPL" "Predicted Conflict Position for the Aircraft 2 Involved in the Conflict" TRuleVariation1295 +type TNonSpare2116 = 'GNonSpare "TT2" "Time to Runway Threshold for Second Approaching Aircraft in a RIMCA" TRuleVariation376 +type TNonSpare975 = 'GNonSpare "DT2" "Distance to Runway Threshold for Aircraft 2 Involved in a RIMCA" TRuleVariation317 +type TNonSpare608 = 'GNonSpare "AC2" "Characteristics of Aircraft 2 Involved in the Conflict" TRuleVariation1349 +type TNonSpare1433 = 'GNonSpare "MS2" "Aircraft Identification Downloaded From Aircraft 2 Involved in the Conflict If Eequipped With a Mode-S Transponder" TRuleVariation396 +type TNonSpare1062 = 'GNonSpare "FP2" "Number of the Flight Plan Correlated to Aircraft 2 Involved in the Conflict" TRuleVariation1047 +type TNonSpare791 = 'GNonSpare "CF2" "Cleared Flight Level for Aircraft 2 Involved in the Conflict" TRuleVariation327 +type TVariation1552 = 'GCompound '[ 'Just TNonSpare638, 'Just TNonSpare1301, 'Just TNonSpare893, 'Just TNonSpare890, 'Just TNonSpare2116, 'Just TNonSpare975, 'Just TNonSpare608, 'Just TNonSpare1433, 'Just TNonSpare1062, 'Just TNonSpare791] +type TRuleVariation1468 = 'GContextFree TVariation1552 +type TNonSpare406 = 'GNonSpare "171" "Aircraft Identification and Characteristics 2" TRuleVariation1468 +type TUapItem406 = 'GUapItem TNonSpare406 +type TNonSpare785 = 'GNonSpare "CEN" "" TRuleVariation171 +type TItem159 = 'GItem TNonSpare785 +type TNonSpare1564 = 'GNonSpare "POS" "" TRuleVariation171 +type TItem747 = 'GItem TNonSpare1564 +type TVariation1113 = 'GGroup 0 '[ TItem159, TItem747] +type TVariation1492 = 'GRepetitive ('GRepetitiveRegular 1) TVariation1113 +type TRuleVariation1408 = 'GContextFree TVariation1492 +type TNonSpare302 = 'GNonSpare "110" "FDPS Sector Control Identification" TRuleVariation1408 +type TUapItem302 = 'GUapItem TNonSpare302 +type TVariation1543 = 'GExplicit ('Just 'GReservedExpansion) +type TRuleVariation1459 = 'GContextFree TVariation1543 +type TNonSpare1701 = 'GNonSpare "RE" "Reserved Expansion Field" TRuleVariation1459 +type TUapItem594 = 'GUapItem TNonSpare1701 +type TRecord16 = 'GRecord '[ TUapItem34, TUapItem3, TUapItem58, TUapItem95, TUapItem141, TUapItem170, TUapItem203, TUapItem117, TUapItem393, TUapItem315, TUapItem214, TUapItem241, TUapItem236, TUapItem239, TUapItem282, TUapItem134, TUapItem406, TUapItem302, TUapItem598, TUapItem594, TUapItem596] +type TUap16 = 'GUap TRecord16 +type TAsterix6 = 'GAsterixBasic 4 ('GEdition 1 12) TUap16 +type TContent602 = 'GContentTable '[ '(1, "Alive Message (AM)"), '(2, "Route Adherence Monitor Longitudinal Deviation (RAMLD)"), '(3, "Route Adherence Monitor Heading Deviation (RAMHD)"), '(4, "Minimum Safe Altitude Warning (MSAW)"), '(5, "Area Proximity Warning (APW)"), '(6, "Clearance Level Adherence Monitor (CLAM)"), '(7, "Short Term Conflict Alert (STCA)"), '(8, "Approach Path Monitor (APM)"), '(9, "RIMCAS Arrival / Landing Monitor (ALM)"), '(10, "RIMCAS Arrival / Departure Wrong Runway Alert (WRA)"), '(11, "RIMCAS Arrival / Departure Opposite Traffic Alert (OTA)"), '(12, "RIMCAS Departure Monitor (RDM)"), '(13, "RIMCAS Runway / Taxiway Crossing Monitor (RCM)"), '(14, "RIMCAS Taxiway Separation Monitor (TSM)"), '(15, "RIMCAS Unauthorized Taxiway Movement Monitor(UTMM)"), '(16, "RIMCAS Stop Bar Overrun Alert (SBOA)"), '(17, "End Of Conflict (EOC)"), '(18, "ACAS Resolution Advisory (ACASRA)"), '(19, "Near Term Conflict Alert (NTCA)"), '(20, "Downlinked Barometric Pressure Setting Monitor (DBPSM)"), '(21, "Speed Adherence Monitor (SAM)"), '(22, "Outside Controlled Airspace Tool (OCAT)"), '(23, "Vertical Conflict Detection (VCD)"), '(24, "Vertical Rate Adherence Monitor (VRAM)"), '(25, "Cleared Heading Adherence Monitor (CHAM)"), '(26, "Downlinked Selected Altitude Monitor (DSAM)"), '(27, "Holding Adherence Monitor (HAM)"), '(28, "Vertical Path Monitor (VPM)"), '(29, "RIMCAS Taxiway Traffic Alert (TTA)"), '(30, "RIMCAS Arrival/Departure Close Runway Alert (CRA)"), '(31, "RIMCAS Arrival/Departure Aircraft Separation Monitor (ASM)"), '(32, "RIMCAS ILS Area Violation Monitor (IAVM)"), '(33, "Final Target Distance Indicator (FTD)"), '(34, "Initial Target Distance Indicator (ITD)"), '(35, "Wake Vortex Indicator Infringement Alert (IIA)"), '(36, "Sequence Warning (SQW)"), '(37, "Catch Up Warning (CUW)"), '(38, "Conflicting ATC Clearances (CATC)"), '(39, "No ATC Clearance (NOCLR)"), '(40, "Aircraft Not Moving despite ATC Clearance (NOMOV)"), '(41, "Aircraft leaving/entering the aerodrome area without proper handover (NOH)"), '(42, "Wrong Runway or Taxiway Type (WRTY)"), '(43, "Stand Occupied (STOCC)"), '(44, "Ongoing Alert (ONGOING)"), '(45, "Non-Transgression Zone Violation (NTZ)"), '(97, "Lost Track Warning (LTW)"), '(98, "Holding Volume Infringement (HVI)"), '(99, "Airspace Infringement Warning (AIW)")] +type TRuleContent600 = 'GContextFree TContent602 +type TVariation193 = 'GElement 0 8 TRuleContent600 +type TRuleVariation185 = 'GContextFree TVariation193 +type TNonSpare2 = 'GNonSpare "000" "Message Type" TRuleVariation185 +type TUapItem2 = 'GUapItem TNonSpare2 +type TNonSpare94 = 'GNonSpare "020" "Time of Message" TRuleVariation376 +type TUapItem94 = 'GUapItem TNonSpare94 +type TContent210 = 'GContentTable '[ '(0, "Element not populated"), '(1, "Element populated")] +type TRuleContent210 = 'GContextFree TContent210 +type TVariation44 = 'GElement 0 1 TRuleContent210 +type TRuleVariation44 = 'GContextFree TVariation44 +type TNonSpare1012 = 'GNonSpare "EP" "Element Populated Bit" TRuleVariation44 +type TItem320 = 'GItem TNonSpare1012 +type TContent249 = 'GContentTable '[ '(0, "Inactive"), '(1, "Active"), '(2, "Pre-active"), '(3, "Reserved for Future Use"), '(4, "Reserved for Future Use"), '(5, "Reserved for Future Use"), '(6, "Reserved for Future Use"), '(7, "Reserved for Future Use")] +type TRuleContent249 = 'GContextFree TContent249 +type TVariation499 = 'GElement 1 3 TRuleContent249 +type TRuleVariation487 = 'GContextFree TVariation499 +type TNonSpare2171 = 'GNonSpare "VAL" "Area Status Value" TRuleVariation487 +type TItem1196 = 'GItem TNonSpare2171 +type TVariation1144 = 'GGroup 0 '[ TItem320, TItem1196] +type TRuleVariation1097 = 'GContextFree TVariation1144 +type TNonSpare684 = 'GNonSpare "AREA" "Area Status" TRuleVariation1097 +type TItem87 = 'GItem TNonSpare684 +type TVariation1098 = 'GGroup 0 '[ TItem87, TItem1025, TItem29] +type TRuleVariation1064 = 'GContextFree TVariation1098 +type TNonSpare171 = 'GNonSpare "045" "Area and Alert Status" TRuleVariation1064 +type TUapItem171 = 'GUapItem TNonSpare171 +type TContent138 = 'GContentTable '[ '(0, "Default"), '(1, "Non-Transgression Zone Function")] +type TRuleContent138 = 'GContextFree TContent138 +type TVariation35 = 'GElement 0 1 TRuleContent138 +type TRuleVariation35 = 'GContextFree TVariation35 +type TNonSpare1499 = 'GNonSpare "NTZ" "" TRuleVariation35 +type TItem694 = 'GItem TNonSpare1499 +type TVariation1444 = 'GExtended '[ 'Just TItem631, 'Just TItem833, 'Just TItem832, 'Just TItem635, 'Just TItem81, 'Just TItem175, 'Just TItem1029, 'Nothing, 'Just TItem80, 'Just TItem883, 'Just TItem42, 'Just TItem693, 'Just TItem277, 'Just TItem708, 'Just TItem709, 'Nothing, 'Just TItem59, 'Just TItem731, 'Just TItem702, 'Just TItem923, 'Just TItem1240, 'Just TItem168, 'Just TItem293, 'Nothing, 'Just TItem260, 'Just TItem262, 'Just TItem264, 'Just TItem1253, 'Just TItem1256, 'Just TItem1255, 'Just TItem404, 'Nothing, 'Just TItem406, 'Just TItem408, 'Just TItem429, 'Just TItem538, 'Just TItem1250, 'Just TItem1148, 'Just TItem230, 'Nothing, 'Just TItem90, 'Just TItem445, 'Just TItem373, 'Just TItem464, 'Just TItem456, 'Just TItem996, 'Just TItem248, 'Nothing, 'Just TItem147, 'Just TItem676, 'Just TItem689, 'Just TItem684, 'Just TItem1272, 'Just TItem1035, 'Just TItem711, 'Nothing, 'Just TItem694, 'Just TItem9, 'Nothing] +type TRuleVariation1360 = 'GContextFree TVariation1444 +type TNonSpare204 = 'GNonSpare "060" "Safety Net Function and System Status" TRuleVariation1360 +type TUapItem204 = 'GUapItem TNonSpare204 +type TNonSpare1251 = 'GNonSpare "LFP" "Linear Prediction Filter" TRuleVariation737 +type TItem505 = 'GItem TNonSpare1251 +type TNonSpare1443 = 'GNonSpare "MSM" "Mode S Manoeuvre/Prediction Filter" TRuleVariation926 +type TItem644 = 'GItem TNonSpare1443 +type TVariation1405 = 'GGroup 4 '[ TItem505, TItem23, TItem644] +type TRuleVariation1526 = 'GDependent '[ '[ "000"], '[ "120", "CC", "TID"]] TVariation801 '[ '( '[ 5, 1], TVariation804), '( '[ 7, 0], TVariation826), '( '[ 7, 1], TVariation1406), '( '[ 9, 2], TVariation1407), '( '[ 10, 2], TVariation1407), '( '[ 11, 2], TVariation1407), '( '[ 12, 2], TVariation1407), '( '[ 13, 2], TVariation1407), '( '[ 14, 2], TVariation1407), '( '[ 15, 2], TVariation1407), '( '[ 16, 2], TVariation1407), '( '[ 15, 1], TVariation803), '( '[ 24, 1], TVariation823), '( '[ 24, 2], TVariation824), '( '[ 26, 1], TVariation825), '( '[ 27, 1], TVariation818), '( '[ 27, 2], TVariation805), '( '[ 33, 1], TVariation819), '( '[ 34, 1], TVariation819), '( '[ 35, 1], TVariation810), '( '[ 38, 0], TVariation812), '( '[ 38, 1], TVariation809), '( '[ 38, 2], TVariation820), '( '[ 38, 3], TVariation811), '( '[ 38, 4], TVariation817), '( '[ 38, 5], TVariation821), '( '[ 39, 1], TVariation813), '( '[ 40, 1], TVariation808), '( '[ 41, 1], TVariation814), '( '[ 45, 1], TVariation1405)] +type TNonSpare886 = 'GNonSpare "CPC" "Conflict Properties Class" TRuleVariation1526 +type TItem224 = 'GItem TNonSpare886 +type TVariation1288 = 'GGroup 0 '[ TItem1082, TItem224, TItem235] +type TRuleVariation1223 = 'GContextFree TVariation1288 +type TNonSpare774 = 'GNonSpare "CC" "Conflict Classification" TRuleVariation1223 +type TVariation1564 = 'GCompound '[ 'Just TNonSpare813, 'Just TNonSpare774, 'Just TNonSpare883, 'Just TNonSpare776] +type TRuleVariation1480 = 'GContextFree TVariation1564 +type TNonSpare316 = 'GNonSpare "120" "Conflict Characteristics" TRuleVariation1480 +type TUapItem316 = 'GUapItem TNonSpare316 +type TRecord15 = 'GRecord '[ TUapItem34, TUapItem2, TUapItem58, TUapItem94, TUapItem141, TUapItem171, TUapItem204, TUapItem117, TUapItem393, TUapItem316, TUapItem214, TUapItem241, TUapItem236, TUapItem239, TUapItem282, TUapItem134, TUapItem406, TUapItem302, TUapItem598, TUapItem594, TUapItem596] +type TUap15 = 'GUap TRecord15 +type TAsterix7 = 'GAsterixBasic 4 ('GEdition 1 13) TUap15 +type TNonSpare39 = 'GNonSpare "010" "Data Source Identifier" TRuleVariation1196 +type TUapItem39 = 'GUapItem TNonSpare39 +type TNonSpare103 = 'GNonSpare "025" "Data Destination Identifier" TRuleVariation1196 +type TUapItem103 = 'GUapItem TNonSpare103 +type TContent17 = 'GContentTable '[ '(0, "Acknowledge"), '(1, "Reject"), '(2, "Interrogation Finished"), '(3, "Interrogation Completed"), '(4, "Target Report"), '(5, "Interrogation Request Type A"), '(6, "Interrogation Request Type B"), '(7, "Interrogation Request Type C"), '(8, "Selective BDS-Register Request")] +type TRuleContent17 = 'GContextFree TContent17 +type TVariation179 = 'GElement 0 8 TRuleContent17 +type TRuleVariation172 = 'GContextFree TVariation179 +type TNonSpare545 = 'GNonSpare "410" "Directed Interrogation Message Type" TRuleVariation172 +type TUapItem543 = 'GUapItem TNonSpare545 +type TContent801 = 'GContentQuantity 'GUnsigned ('GNumDiv ('GNumInt ('GZ 'GPlus 1)) ('GNumPow ('GZ 'GPlus 2) ('GZ 'GPlus 7))) "s" +type TRuleContent798 = 'GContextFree TContent801 +type TVariation385 = 'GElement 0 24 TRuleContent798 +type TRuleVariation377 = 'GContextFree TVariation385 +type TNonSpare355 = 'GNonSpare "140" "Time of Day" TRuleVariation377 +type TUapItem355 = 'GUapItem TNonSpare355 +type TContent404 = 'GContentTable '[ '(0, "Normal Priority, surveillance function has priority"), '(1, "High Priority, Directed interrogation has priority over surveillance")] +type TRuleContent402 = 'GContextFree TContent404 +type TVariation69 = 'GElement 0 1 TRuleContent402 +type TRuleVariation69 = 'GContextFree TVariation69 +type TNonSpare1589 = 'GNonSpare "PRI" "Priority of Command" TRuleVariation69 +type TItem764 = 'GItem TNonSpare1589 +type TVariation516 = 'GElement 1 15 TRuleContent0 +type TRuleVariation504 = 'GContextFree TVariation516 +type TNonSpare1735 = 'GNonSpare "RN" "Request Number" TRuleVariation504 +type TItem885 = 'GItem TNonSpare1735 +type TVariation1223 = 'GGroup 0 '[ TItem764, TItem885] +type TRuleVariation1169 = 'GContextFree TVariation1223 +type TNonSpare540 = 'GNonSpare "400" "Directed Interrogation Request Number" TRuleVariation1169 +type TUapItem538 = 'GUapItem TNonSpare540 +type TContent361 = 'GContentTable '[ '(0, "No detection"), '(1, "Single PSR detection"), '(2, "Single SSR detection"), '(3, "SSR + PSR detection"), '(4, "Single ModeS All-Call"), '(5, "Single ModeS Roll-Call"), '(6, "ModeS All-Call + PSR"), '(7, "ModeS Roll-Call + PSR")] +type TRuleContent359 = 'GContextFree TContent361 +type TVariation134 = 'GElement 0 3 TRuleContent359 +type TRuleVariation134 = 'GContextFree TVariation134 +type TNonSpare2131 = 'GNonSpare "TYP" "" TRuleVariation134 +type TItem1161 = 'GItem TNonSpare2131 +type TContent23 = 'GContentTable '[ '(0, "Actual target report"), '(1, "Simulated target report")] +type TRuleContent23 = 'GContextFree TContent23 +type TVariation635 = 'GElement 3 1 TRuleContent23 +type TRuleVariation623 = 'GContextFree TVariation635 +type TNonSpare1871 = 'GNonSpare "SIM" "" TRuleVariation623 +type TItem969 = 'GItem TNonSpare1871 +type TContent462 = 'GContentTable '[ '(0, "Report from RDP Chain 1"), '(1, "Report from RDP Chain 2")] +type TRuleContent460 = 'GContextFree TContent462 +type TVariation775 = 'GElement 4 1 TRuleContent460 +type TRuleVariation763 = 'GContextFree TVariation775 +type TNonSpare1691 = 'GNonSpare "RDP" "" TRuleVariation763 +type TItem847 = 'GItem TNonSpare1691 +type TContent15 = 'GContentTable '[ '(0, "Absence of SPI"), '(1, "Special Position Identification")] +type TRuleContent15 = 'GContextFree TContent15 +type TVariation848 = 'GElement 5 1 TRuleContent15 +type TRuleVariation817 = 'GContextFree TVariation848 +type TNonSpare1896 = 'GNonSpare "SPI" "" TRuleVariation817 +type TItem990 = 'GItem TNonSpare1896 +type TContent463 = 'GContentTable '[ '(0, "Report from aircraft transponder"), '(1, "Report from field monitor (fixed transponder)")] +type TRuleContent461 = 'GContextFree TContent463 +type TVariation980 = 'GElement 6 1 TRuleContent461 +type TRuleVariation949 = 'GContextFree TVariation980 +type TNonSpare1666 = 'GNonSpare "RAB" "" TRuleVariation949 +type TItem826 = 'GItem TNonSpare1666 +type TContent460 = 'GContentTable '[ '(0, "Real target report"), '(1, "Test target report")] +type TRuleContent458 = 'GContextFree TContent460 +type TVariation76 = 'GElement 0 1 TRuleContent458 +type TRuleVariation76 = 'GContextFree TVariation76 +type TNonSpare2105 = 'GNonSpare "TST" "" TRuleVariation76 +type TItem1138 = 'GItem TNonSpare2105 +type TContent321 = 'GContentTable '[ '(0, "No Extended Range"), '(1, "Extended Range present")] +type TRuleContent319 = 'GContextFree TContent321 +type TVariation455 = 'GElement 1 1 TRuleContent319 +type TRuleVariation443 = 'GContextFree TVariation455 +type TNonSpare1031 = 'GNonSpare "ERR" "" TRuleVariation443 +type TItem338 = 'GItem TNonSpare1031 +type TContent332 = 'GContentTable '[ '(0, "No X-Pulse present"), '(1, "X-Pulse present")] +type TRuleContent330 = 'GContextFree TContent332 +type TVariation577 = 'GElement 2 1 TRuleContent330 +type TRuleVariation565 = 'GContextFree TVariation577 +type TNonSpare2311 = 'GNonSpare "XPP" "" TRuleVariation565 +type TItem1323 = 'GItem TNonSpare2311 +type TContent385 = 'GContentTable '[ '(0, "No military emergency"), '(1, "Military emergency")] +type TRuleContent383 = 'GContextFree TContent385 +type TVariation673 = 'GElement 3 1 TRuleContent383 +type TRuleVariation661 = 'GContextFree TVariation673 +type TNonSpare1374 = 'GNonSpare "ME" "" TRuleVariation661 +type TItem592 = 'GItem TNonSpare1374 +type TContent386 = 'GContentTable '[ '(0, "No military identification"), '(1, "Military identification")] +type TRuleContent384 = 'GContextFree TContent386 +type TVariation767 = 'GElement 4 1 TRuleContent384 +type TRuleVariation755 = 'GContextFree TVariation767 +type TNonSpare1393 = 'GNonSpare "MI" "" TRuleVariation755 +type TItem599 = 'GItem TNonSpare1393 +type TContent323 = 'GContentTable '[ '(0, "No Mode 4 interrogation"), '(1, "Friendly target"), '(2, "Unknown target"), '(3, "No reply")] +type TRuleContent321 = 'GContextFree TContent323 +type TVariation910 = 'GElement 5 2 TRuleContent321 +type TRuleVariation879 = 'GContextFree TVariation910 +type TNonSpare1055 = 'GNonSpare "FOEFRI" "" TRuleVariation879 +type TItem356 = 'GItem TNonSpare1055 +type TContent12 = 'GContentTable '[ '(0, "ADSB not populated"), '(1, "ADSB populated")] +type TRuleContent12 = 'GContextFree TContent12 +type TVariation3 = 'GElement 0 1 TRuleContent12 +type TRuleVariation3 = 'GContextFree TVariation3 +type TNonSpare1008 = 'GNonSpare "EP" "ADSB Element Populated Bit" TRuleVariation3 +type TItem316 = 'GItem TNonSpare1008 +type TContent412 = 'GContentTable '[ '(0, "Not available"), '(1, "Available")] +type TRuleContent410 = 'GContextFree TContent412 +type TVariation460 = 'GElement 1 1 TRuleContent410 +type TRuleVariation448 = 'GContextFree TVariation460 +type TNonSpare2177 = 'GNonSpare "VAL" "On-Site ADS-B Information" TRuleVariation448 +type TItem1202 = 'GItem TNonSpare2177 +type TVariation1142 = 'GGroup 0 '[ TItem316, TItem1202] +type TRuleVariation1095 = 'GContextFree TVariation1142 +type TNonSpare629 = 'GNonSpare "ADSB" "On-Site ADS-B Information" TRuleVariation1095 +type TItem51 = 'GItem TNonSpare629 +type TContent471 = 'GContentTable '[ '(0, "SCN not populated"), '(1, "SCN populated")] +type TRuleContent469 = 'GContextFree TContent471 +type TVariation593 = 'GElement 2 1 TRuleContent469 +type TRuleVariation581 = 'GContextFree TVariation593 +type TNonSpare1026 = 'GNonSpare "EP" "SCN Element Populated Bit" TRuleVariation581 +type TItem334 = 'GItem TNonSpare1026 +type TVariation678 = 'GElement 3 1 TRuleContent410 +type TRuleVariation666 = 'GContextFree TVariation678 +type TNonSpare2183 = 'GNonSpare "VAL" "Surveillance Cluster Network Information" TRuleVariation666 +type TItem1208 = 'GItem TNonSpare2183 +type TVariation1393 = 'GGroup 2 '[ TItem334, TItem1208] +type TRuleVariation1312 = 'GContextFree TVariation1393 +type TNonSpare1811 = 'GNonSpare "SCN" "Surveillance Cluster Network Information" TRuleVariation1312 +type TItem929 = 'GItem TNonSpare1811 +type TContent439 = 'GContentTable '[ '(0, "PAI not populated"), '(1, "PAI populated")] +type TRuleContent437 = 'GContextFree TContent439 +type TVariation771 = 'GElement 4 1 TRuleContent437 +type TRuleVariation759 = 'GContextFree TVariation771 +type TNonSpare1022 = 'GNonSpare "EP" "PAI Element Populated Bit" TRuleVariation759 +type TItem330 = 'GItem TNonSpare1022 +type TVariation895 = 'GElement 5 1 TRuleContent410 +type TRuleVariation864 = 'GContextFree TVariation895 +type TNonSpare2181 = 'GNonSpare "VAL" "Passive Acquisition Interface Information" TRuleVariation864 +type TItem1206 = 'GItem TNonSpare2181 +type TVariation1404 = 'GGroup 4 '[ TItem330, TItem1206] +type TRuleVariation1323 = 'GContextFree TVariation1404 +type TNonSpare1537 = 'GNonSpare "PAI" "Passive Acquisition Interface Information" TRuleVariation1323 +type TItem730 = 'GItem TNonSpare1537 +type TContent9 = 'GContentTable '[ '(0, "ACASVX not populated"), '(1, "ACASVX populated")] +type TRuleContent9 = 'GContextFree TContent9 +type TVariation1 = 'GElement 0 1 TRuleContent9 +type TRuleVariation1 = 'GContextFree TVariation1 +type TNonSpare1006 = 'GNonSpare "EP" "ACASVX Element Populated Bit" TRuleVariation1 +type TItem314 = 'GItem TNonSpare1006 +type TContent399 = 'GContentTable '[ '(0, "Non-Extended Version"), '(1, "ACAS Xa Version 1"), '(2, "ACAS Xu Version 1"), '(3, "Reserved for future versions"), '(4, "Reserved for future versions"), '(5, "Reserved for future versions"), '(6, "Reserved for future versions"), '(7, "Reserved for future versions"), '(8, "Reserved for future versions"), '(9, "Reserved for future versions"), '(10, "Reserved for future versions"), '(11, "Reserved for future versions"), '(12, "Reserved for future versions"), '(13, "Reserved for future versions"), '(14, "Reserved for future versions"), '(15, "Reserved for future versions")] +type TRuleContent397 = 'GContextFree TContent399 +type TVariation506 = 'GElement 1 4 TRuleContent397 +type TRuleVariation494 = 'GContextFree TVariation506 +type TNonSpare2170 = 'GNonSpare "VAL" "ACAS Extended Version Value" TRuleVariation494 +type TItem1195 = 'GItem TNonSpare2170 +type TVariation1140 = 'GGroup 0 '[ TItem314, TItem1195] +type TRuleVariation1093 = 'GContextFree TVariation1140 +type TNonSpare610 = 'GNonSpare "ACASVX" "ACAS Extended Version" TRuleVariation1093 +type TItem43 = 'GItem TNonSpare610 +type TContent444 = 'GContentTable '[ '(0, "POXPR not populated"), '(1, "POXPR populated")] +type TRuleContent442 = 'GContextFree TContent444 +type TVariation899 = 'GElement 5 1 TRuleContent442 +type TRuleVariation868 = 'GContextFree TVariation899 +type TNonSpare1024 = 'GNonSpare "EP" "POXPR Element Populated Bit" TRuleVariation868 +type TItem332 = 'GItem TNonSpare1024 +type TContent442 = 'GContentTable '[ '(0, "PO not supported (PPM only)"), '(1, "PO supported")] +type TRuleContent440 = 'GContextFree TContent442 +type TVariation977 = 'GElement 6 1 TRuleContent440 +type TRuleVariation946 = 'GContextFree TVariation977 +type TNonSpare2179 = 'GNonSpare "VAL" "PO Transponder Capability" TRuleVariation946 +type TItem1204 = 'GItem TNonSpare2179 +type TVariation1411 = 'GGroup 5 '[ TItem332, TItem1204] +type TRuleVariation1327 = 'GContextFree TVariation1411 +type TNonSpare1577 = 'GNonSpare "POXPR" "PO Transponder Capability" TRuleVariation1327 +type TItem752 = 'GItem TNonSpare1577 +type TContent443 = 'GContentTable '[ '(0, "POACT not populated"), '(1, "POACT populated")] +type TRuleContent441 = 'GContextFree TContent443 +type TVariation73 = 'GElement 0 1 TRuleContent441 +type TRuleVariation73 = 'GContextFree TVariation73 +type TNonSpare1023 = 'GNonSpare "EP" "POACT Element Populated Bit" TRuleVariation73 +type TItem331 = 'GItem TNonSpare1023 +type TContent441 = 'GContentTable '[ '(0, "PO not active"), '(1, "PO active")] +type TRuleContent439 = 'GContextFree TContent441 +type TVariation463 = 'GElement 1 1 TRuleContent439 +type TRuleVariation451 = 'GContextFree TVariation463 +type TNonSpare2178 = 'GNonSpare "VAL" "PO Active for Current Plot" TRuleVariation451 +type TItem1203 = 'GItem TNonSpare2178 +type TVariation1156 = 'GGroup 0 '[ TItem331, TItem1203] +type TRuleVariation1109 = 'GContextFree TVariation1156 +type TNonSpare1561 = 'GNonSpare "POACT" "PO Active for Current Plot" TRuleVariation1109 +type TItem744 = 'GItem TNonSpare1561 +type TContent80 = 'GContentTable '[ '(0, "DTFXPR not populated"), '(1, "DTFXPR populated")] +type TRuleContent80 = 'GContextFree TContent80 +type TVariation530 = 'GElement 2 1 TRuleContent80 +type TRuleVariation518 = 'GContextFree TVariation530 +type TNonSpare1010 = 'GNonSpare "EP" "DTFXPR Element Populated Bit" TRuleVariation518 +type TItem318 = 'GItem TNonSpare1010 +type TContent51 = 'GContentTable '[ '(0, "Basic Dataflash not supported"), '(1, "Basic Dataflash supported")] +type TRuleContent51 = 'GContextFree TContent51 +type TVariation639 = 'GElement 3 1 TRuleContent51 +type TRuleVariation627 = 'GContextFree TVariation639 +type TNonSpare2172 = 'GNonSpare "VAL" "Basic Dataflash Transponder Capability" TRuleVariation627 +type TItem1197 = 'GItem TNonSpare2172 +type TVariation1387 = 'GGroup 2 '[ TItem318, TItem1197] +type TRuleVariation1306 = 'GContextFree TVariation1387 +type TNonSpare977 = 'GNonSpare "DTFXPR" "Basic Dataflash Transponder Capability" TRuleVariation1306 +type TItem295 = 'GItem TNonSpare977 +type TContent79 = 'GContentTable '[ '(0, "DTFACT not populated"), '(1, "DTFACT populated")] +type TRuleContent79 = 'GContextFree TContent79 +type TVariation729 = 'GElement 4 1 TRuleContent79 +type TRuleVariation717 = 'GContextFree TVariation729 +type TNonSpare1009 = 'GNonSpare "EP" "DTFACT Element Populated Bit" TRuleVariation717 +type TItem317 = 'GItem TNonSpare1009 +type TContent50 = 'GContentTable '[ '(0, "Basic Dataflash not active"), '(1, "Basic Dataflash active")] +type TRuleContent50 = 'GContextFree TContent50 +type TVariation853 = 'GElement 5 1 TRuleContent50 +type TRuleVariation822 = 'GContextFree TVariation853 +type TNonSpare2173 = 'GNonSpare "VAL" "Basic Dataflash in Current Plot" TRuleVariation822 +type TItem1198 = 'GItem TNonSpare2173 +type TVariation1401 = 'GGroup 4 '[ TItem317, TItem1198] +type TRuleVariation1320 = 'GContextFree TVariation1401 +type TNonSpare976 = 'GNonSpare "DTFACT" "Basic Dataflash Active for Current Plot" TRuleVariation1320 +type TItem294 = 'GItem TNonSpare976 +type TContent246 = 'GContentTable '[ '(0, "IRMXPR not populated"), '(1, "IRMXPR populated")] +type TRuleContent246 = 'GContextFree TContent246 +type TVariation50 = 'GElement 0 1 TRuleContent246 +type TRuleVariation50 = 'GContextFree TVariation50 +type TNonSpare1020 = 'GNonSpare "EP" "IRMXPR Element Populated Bit" TRuleVariation50 +type TItem328 = 'GItem TNonSpare1020 +type TContent551 = 'GContentTable '[ '(0, "Transponder not IRM capable"), '(1, "Transponder IRM capable")] +type TRuleContent549 = 'GContextFree TContent551 +type TVariation478 = 'GElement 1 1 TRuleContent549 +type TRuleVariation466 = 'GContextFree TVariation478 +type TNonSpare2185 = 'GNonSpare "VAL" "Transponder IRM Capability" TRuleVariation466 +type TItem1210 = 'GItem TNonSpare2185 +type TVariation1155 = 'GGroup 0 '[ TItem328, TItem1210] +type TRuleVariation1108 = 'GContextFree TVariation1155 +type TNonSpare1206 = 'GNonSpare "IRMXPR" "IRM Transponder Capability" TRuleVariation1108 +type TItem463 = 'GItem TNonSpare1206 +type TContent245 = 'GContentTable '[ '(0, "IRMACT not populated"), '(1, "IRMACT populated")] +type TRuleContent245 = 'GContextFree TContent245 +type TVariation556 = 'GElement 2 1 TRuleContent245 +type TRuleVariation544 = 'GContextFree TVariation556 +type TNonSpare1019 = 'GNonSpare "EP" "IRMACT Element Populated Bit" TRuleVariation544 +type TItem327 = 'GItem TNonSpare1019 +type TContent244 = 'GContentTable '[ '(0, "IRM not active"), '(1, "IRM active")] +type TRuleContent244 = 'GContextFree TContent244 +type TVariation664 = 'GElement 3 1 TRuleContent244 +type TRuleVariation652 = 'GContextFree TVariation664 +type TNonSpare2174 = 'GNonSpare "VAL" "IRM Active for Current Plot" TRuleVariation652 +type TItem1199 = 'GItem TNonSpare2174 +type TVariation1392 = 'GGroup 2 '[ TItem327, TItem1199] +type TRuleVariation1311 = 'GContextFree TVariation1392 +type TNonSpare1205 = 'GNonSpare "IRMACT" "IRM Active for Current Plot" TRuleVariation1311 +type TItem462 = 'GItem TNonSpare1205 +type TVariation1463 = 'GExtended '[ 'Just TItem1161, 'Just TItem969, 'Just TItem847, 'Just TItem990, 'Just TItem826, 'Nothing, 'Just TItem1138, 'Just TItem338, 'Just TItem1323, 'Just TItem592, 'Just TItem599, 'Just TItem356, 'Nothing, 'Just TItem51, 'Just TItem929, 'Just TItem730, 'Just TItem26, 'Nothing, 'Just TItem43, 'Just TItem752, 'Nothing, 'Just TItem744, 'Just TItem295, 'Just TItem294, 'Just TItem26, 'Nothing, 'Just TItem463, 'Just TItem462, 'Just TItem21, 'Nothing] +type TRuleVariation1379 = 'GContextFree TVariation1463 +type TNonSpare96 = 'GNonSpare "020" "Type and Properties of the Target Report and Target Capabilities" TRuleVariation1379 +type TUapItem96 = 'GUapItem TNonSpare96 +type TContent803 = 'GContentQuantity 'GUnsigned ('GNumDiv ('GNumInt ('GZ 'GPlus 1)) ('GNumPow ('GZ 'GPlus 2) ('GZ 'GPlus 8))) "NM" +type TRuleContent800 = 'GContextFree TContent803 +type TVariation349 = 'GElement 0 16 TRuleContent800 +type TRuleVariation341 = 'GContextFree TVariation349 +type TNonSpare1725 = 'GNonSpare "RHO" "" TRuleVariation341 +type TItem876 = 'GItem TNonSpare1725 +type TVariation1239 = 'GGroup 0 '[ TItem876, TItem1077] +type TRuleVariation1185 = 'GContextFree TVariation1239 +type TNonSpare144 = 'GNonSpare "040" "Measured Position in Polar Co-ordinates" TRuleVariation1185 +type TUapItem144 = 'GUapItem TNonSpare144 +type TContent302 = 'GContentTable '[ '(0, "Mode-3/A code derived from the reply of the transponder"), '(1, "Mode-3/A code not extracted during the last scan")] +type TRuleContent300 = 'GContextFree TContent302 +type TVariation571 = 'GElement 2 1 TRuleContent300 +type TRuleVariation559 = 'GContextFree TVariation571 +type TNonSpare1221 = 'GNonSpare "L" "" TRuleVariation559 +type TItem477 = 'GItem TNonSpare1221 +type TVariation1329 = 'GGroup 0 '[ TItem1191, TItem377, TItem477, TItem16, TItem622] +type TRuleVariation1253 = 'GContextFree TVariation1329 +type TNonSpare222 = 'GNonSpare "070" "Mode-3/A Code in Octal Representation" TRuleVariation1253 +type TUapItem222 = 'GUapItem TNonSpare222 +type TNonSpare1049 = 'GNonSpare "FL" "Flight Level" TRuleVariation616 +type TItem353 = 'GItem TNonSpare1049 +type TVariation1321 = 'GGroup 0 '[ TItem1191, TItem377, TItem353] +type TRuleVariation1245 = 'GContextFree TVariation1321 +type TNonSpare263 = 'GNonSpare "090" "Flight Level in Binary Representation" TRuleVariation1245 +type TUapItem263 = 'GUapItem TNonSpare263 +type TContent823 = 'GContentQuantity 'GUnsigned ('GNumDiv ('GNumInt ('GZ 'GPlus 360)) ('GNumPow ('GZ 'GPlus 2) ('GZ 'GPlus 13))) "°" +type TRuleContent820 = 'GContextFree TContent823 +type TVariation259 = 'GElement 0 8 TRuleContent820 +type TRuleVariation251 = 'GContextFree TVariation259 +type TNonSpare1913 = 'GNonSpare "SRL" "Subfield #1: SSR Plot Runlength" TRuleVariation251 +type TVariation219 = 'GElement 0 8 TRuleContent638 +type TRuleVariation211 = 'GContextFree TVariation219 +type TNonSpare1915 = 'GNonSpare "SRR" "Subfield #2: Number of Received Replies for (M)SSR" TRuleVariation211 +type TNonSpare1803 = 'GNonSpare "SAM" "Subfield #3: Amplitude of Received Replies for (M)SSR" TRuleVariation214 +type TNonSpare1593 = 'GNonSpare "PRL" "Subfield #4: PSR Plot Runlength" TRuleVariation251 +type TNonSpare1540 = 'GNonSpare "PAM" "Subfield #5: PSR Amplitude" TRuleVariation214 +type TContent708 = 'GContentQuantity 'GSigned ('GNumDiv ('GNumInt ('GZ 'GPlus 1)) ('GNumPow ('GZ 'GPlus 2) ('GZ 'GPlus 8))) "NM" +type TRuleContent706 = 'GContextFree TContent708 +type TVariation231 = 'GElement 0 8 TRuleContent706 +type TRuleVariation223 = 'GContextFree TVariation231 +type TNonSpare1743 = 'GNonSpare "RPD" "Subfield #6: Difference in Range Between PSR and SSR Plot" TRuleVariation223 +type TNonSpare670 = 'GNonSpare "APD" "Subfield #7: Difference in Azimuth Between PSR and SSR Plot" TRuleVariation226 +type TVariation1594 = 'GCompound '[ 'Just TNonSpare1913, 'Just TNonSpare1915, 'Just TNonSpare1803, 'Just TNonSpare1593, 'Just TNonSpare1540, 'Just TNonSpare1743, 'Just TNonSpare670] +type TRuleVariation1510 = 'GContextFree TVariation1594 +type TNonSpare333 = 'GNonSpare "130" "Radar Plot Characteristics" TRuleVariation1510 +type TUapItem333 = 'GUapItem TNonSpare333 +type TVariation363 = 'GElement 0 24 TRuleContent0 +type TRuleVariation355 = 'GContextFree TVariation363 +type TNonSpare447 = 'GNonSpare "220" "Aircraft Address" TRuleVariation355 +type TUapItem447 = 'GUapItem TNonSpare447 +type TNonSpare467 = 'GNonSpare "240" "Aircraft Identification" TRuleVariation396 +type TUapItem467 = 'GUapItem TNonSpare467 +type TVariation406 = 'GElement 0 56 TRuleContent0 +type TRuleVariation397 = 'GContextFree TVariation406 +type TNonSpare1338 = 'GNonSpare "MBDATA" "Mode S Comm B Message Data" TRuleVariation397 +type TItem575 = 'GItem TNonSpare1338 +type TNonSpare730 = 'GNonSpare "BDS1" "Comm B Data Buffer Store 1 Address" TRuleVariation140 +type TItem120 = 'GItem TNonSpare730 +type TVariation827 = 'GElement 4 4 TRuleContent0 +type TRuleVariation796 = 'GContextFree TVariation827 +type TNonSpare733 = 'GNonSpare "BDS2" "Comm B Data Buffer Store 2 Address" TRuleVariation796 +type TItem123 = 'GItem TNonSpare733 +type TVariation1202 = 'GGroup 0 '[ TItem575, TItem120, TItem123] +type TVariation1502 = 'GRepetitive ('GRepetitiveRegular 1) TVariation1202 +type TRuleVariation1418 = 'GContextFree TVariation1502 +type TNonSpare483 = 'GNonSpare "250" "Mode S MB Data" TRuleVariation1418 +type TUapItem483 = 'GUapItem TNonSpare483 +type TNonSpare2043 = 'GNonSpare "TN" "Track Number" TRuleVariation806 +type TItem1090 = 'GItem TNonSpare2043 +type TVariation1075 = 'GGroup 0 '[ TItem3, TItem1090] +type TRuleVariation1042 = 'GContextFree TVariation1075 +type TNonSpare384 = 'GNonSpare "161" "Track Number" TRuleVariation1042 +type TUapItem384 = 'GUapItem TNonSpare384 +type TContent706 = 'GContentQuantity 'GSigned ('GNumDiv ('GNumInt ('GZ 'GPlus 1)) ('GNumPow ('GZ 'GPlus 2) ('GZ 'GPlus 7))) "NM" +type TRuleContent704 = 'GContextFree TContent706 +type TVariation301 = 'GElement 0 16 TRuleContent704 +type TRuleVariation293 = 'GContextFree TVariation301 +type TNonSpare2289 = 'GNonSpare "X" "X-Component" TRuleVariation293 +type TItem1305 = 'GItem TNonSpare2289 +type TNonSpare2344 = 'GNonSpare "Y" "Y-Component" TRuleVariation293 +type TItem1356 = 'GItem TNonSpare2344 +type TVariation1379 = 'GGroup 0 '[ TItem1305, TItem1356] +type TRuleVariation1301 = 'GContextFree TVariation1379 +type TNonSpare167 = 'GNonSpare "042" "Calculated Position in Cartesian Co-ordinates" TRuleVariation1301 +type TUapItem167 = 'GUapItem TNonSpare167 +type TNonSpare415 = 'GNonSpare "200" "Calculated Track Velocity in Polar Co-ordinates" TRuleVariation1123 +type TUapItem415 = 'GUapItem TNonSpare415 +type TContent65 = 'GContentTable '[ '(0, "Confirmed Track"), '(1, "Tentative Track")] +type TRuleContent65 = 'GContextFree TContent65 +type TVariation17 = 'GElement 0 1 TRuleContent65 +type TRuleVariation17 = 'GContextFree TVariation17 +type TNonSpare817 = 'GNonSpare "CNF" "Confirmed Vs. Tentative Track" TRuleVariation17 +type TItem183 = 'GItem TNonSpare817 +type TContent63 = 'GContentTable '[ '(0, "Combined Track"), '(1, "PSR Track"), '(2, "SSR/Mode S Track"), '(3, "Invalid")] +type TRuleContent63 = 'GContextFree TContent63 +type TVariation482 = 'GElement 1 2 TRuleContent63 +type TRuleVariation470 = 'GContextFree TVariation482 +type TNonSpare1671 = 'GNonSpare "RAD" "Type of Sensor(s) Maintaining Track" TRuleVariation470 +type TItem831 = 'GItem TNonSpare1671 +type TContent405 = 'GContentTable '[ '(0, "Normal confidence"), '(1, "Low confidence in plot to track association")] +type TRuleContent403 = 'GContextFree TContent405 +type TVariation677 = 'GElement 3 1 TRuleContent403 +type TRuleVariation665 = 'GContextFree TVariation677 +type TNonSpare964 = 'GNonSpare "DOU" "Signals Level of Confidence in Plot to Track Association Process" TRuleVariation665 +type TItem287 = 'GItem TNonSpare964 +type TContent379 = 'GContentTable '[ '(0, "No horizontal manoeuvre sensed"), '(1, "Horizontal manoeuvre sensed")] +type TRuleContent377 = 'GContextFree TContent379 +type TVariation765 = 'GElement 4 1 TRuleContent377 +type TRuleVariation753 = 'GContextFree TVariation765 +type TNonSpare1325 = 'GNonSpare "MAH" "Manoeuvre Detection in Horizontal Sense" TRuleVariation753 +type TItem567 = 'GItem TNonSpare1325 +type TContent274 = 'GContentTable '[ '(0, "Maintaining"), '(1, "Climbing"), '(2, "Descending"), '(3, "Unknown")] +type TRuleContent272 = 'GContextFree TContent274 +type TVariation908 = 'GElement 5 2 TRuleContent272 +type TRuleVariation877 = 'GContextFree TVariation908 +type TNonSpare780 = 'GNonSpare "CDM" "Climbing/Descending Mode" TRuleVariation877 +type TItem154 = 'GItem TNonSpare780 +type TContent538 = 'GContentTable '[ '(0, "Track still alive"), '(1, "End of track lifetime (last report for this track)")] +type TRuleContent536 = 'GContextFree TContent538 +type TVariation94 = 'GElement 0 1 TRuleContent536 +type TRuleVariation94 = 'GContextFree TVariation94 +type TNonSpare2085 = 'GNonSpare "TRE" "Signal for End_of_Track" TRuleVariation94 +type TItem1122 = 'GItem TNonSpare2085 +type TContent553 = 'GContentTable '[ '(0, "True target track"), '(1, "Ghost target track")] +type TRuleContent551 = 'GContextFree TContent553 +type TVariation479 = 'GElement 1 1 TRuleContent551 +type TRuleVariation467 = 'GContextFree TVariation479 +type TNonSpare1115 = 'GNonSpare "GHO" "Ghost Vs. True Target" TRuleVariation467 +type TItem394 = 'GItem TNonSpare1115 +type TContent316 = 'GContentTable '[ '(0, "No"), '(1, "Yes")] +type TRuleContent314 = 'GContextFree TContent316 +type TVariation576 = 'GElement 2 1 TRuleContent314 +type TRuleVariation564 = 'GContextFree TVariation576 +type TNonSpare1975 = 'GNonSpare "SUP" "Track Maintained with Track Information from Neighbouring Node B on the Cluster, or Network" TRuleVariation564 +type TItem1045 = 'GItem TNonSpare1975 +type TContent541 = 'GContentTable '[ '(0, "Tracking performed in so-called 'Radar Plane', i.e. neither slant range correction nor stereographical projection was applied"), '(1, "Slant range correction and a suitable projection technique are used to track in a 2D reference plane, tangential to the earth model at the Radar Site co-ordinates")] +type TRuleContent539 = 'GContextFree TContent541 +type TVariation688 = 'GElement 3 1 TRuleContent539 +type TRuleVariation676 = 'GContextFree TVariation688 +type TNonSpare2005 = 'GNonSpare "TCC" "Type of Plot Coordinate Transformation Mechanism" TRuleVariation676 +type TItem1062 = 'GItem TNonSpare2005 +type TVariation1424 = 'GExtended '[ 'Just TItem183, 'Just TItem831, 'Just TItem287, 'Just TItem567, 'Just TItem154, 'Nothing, 'Just TItem1122, 'Just TItem394, 'Just TItem1045, 'Just TItem1062, 'Just TItem21, 'Nothing] +type TRuleVariation1340 = 'GContextFree TVariation1424 +type TNonSpare401 = 'GNonSpare "170" "Track Status" TRuleVariation1340 +type TUapItem401 = 'GUapItem TNonSpare401 +type TContent796 = 'GContentQuantity 'GUnsigned ('GNumDiv ('GNumInt ('GZ 'GPlus 1)) ('GNumPow ('GZ 'GPlus 2) ('GZ 'GPlus 7))) "NM" +type TRuleContent793 = 'GContextFree TContent796 +type TVariation251 = 'GElement 0 8 TRuleContent793 +type TRuleVariation243 = 'GContextFree TVariation251 +type TNonSpare1862 = 'GNonSpare "SIGX" "Standard Deviation on the Horizontal Axis of the Local Grid System" TRuleVariation243 +type TItem960 = 'GItem TNonSpare1862 +type TNonSpare1864 = 'GNonSpare "SIGY" "Standard Deviation on the Vertical Axis of the Local Grid System" TRuleVariation243 +type TItem962 = 'GItem TNonSpare1864 +type TVariation254 = 'GElement 0 8 TRuleContent805 +type TRuleVariation246 = 'GContextFree TVariation254 +type TNonSpare1860 = 'GNonSpare "SIGV" "Standard Deviation on the Groundspeed Within the Local Grid System" TRuleVariation246 +type TItem958 = 'GItem TNonSpare1860 +type TContent822 = 'GContentQuantity 'GUnsigned ('GNumDiv ('GNumInt ('GZ 'GPlus 360)) ('GNumPow ('GZ 'GPlus 2) ('GZ 'GPlus 12))) "°" +type TRuleContent819 = 'GContextFree TContent822 +type TVariation258 = 'GElement 0 8 TRuleContent819 +type TRuleVariation250 = 'GContextFree TVariation258 +type TNonSpare1858 = 'GNonSpare "SIGH" "Standard Deviation on the Heading Within the Local Grid System" TRuleVariation250 +type TItem956 = 'GItem TNonSpare1858 +type TVariation1273 = 'GGroup 0 '[ TItem960, TItem962, TItem958, TItem956] +type TRuleVariation1212 = 'GContextFree TVariation1273 +type TNonSpare443 = 'GNonSpare "210" "Track Quality" TRuleVariation1212 +type TUapItem443 = 'GUapItem TNonSpare443 +type TContent418 = 'GContentTable '[ '(0, "Not defined; never used"), '(1, "Multipath Reply (Reflection)"), '(2, "Reply due to sidelobe interrogation/reception"), '(3, "Split plot"), '(4, "Second time around reply"), '(5, "Angel"), '(6, "Slow moving target correlated with road infrastructure (terrestrial vehicle)"), '(7, "Fixed PSR plot"), '(8, "Slow PSR target"), '(9, "Low quality PSR plot"), '(10, "Phantom SSR plot"), '(11, "Non-Matching Mode-3/A Code"), '(12, "Mode C code/Mode S altitude code abnormal value compared to the track"), '(13, "Target in Clutter Area"), '(14, "Maximum Doppler Response in Zero Filter"), '(15, "Transponder anomaly detected"), '(16, "Duplicated or Illegal Mode S Aircraft Address"), '(17, "Mode S error correction applied"), '(18, "Undecodable Mode C code/Mode S altitude code"), '(19, "Birds"), '(20, "Flock of Birds"), '(21, "Mode 1 was present in original reply"), '(22, "Mode 2 was present in original reply"), '(23, "Plot potentially caused by Wind Turbine"), '(24, "Helicopter"), '(25, "Maximum number of re-interrogations reached (surveillance information)"), '(26, "Maximum number of re-interrogations reached (BDS Extractions)"), '(27, "BDS Overlay Incoherence"), '(28, "Potential BDS Swap Detected"), '(29, "Track Update in the Zenithal Gap"), '(30, "Mode S Track re-acquired"), '(31, "Duplicated Mode 5 Pair NO/PIN detected"), '(32, "Wrong DF reply format detected"), '(33, "Transponder anomaly (MS XPD replies with Mode A/C to Mode A/C-only all-call)"), '(34, "Transponder anomaly (SI capability report wrong)"), '(35, "Potential IC Conflict"), '(36, "IC Conflict detection possible - no conflict currently detected"), '(37, "Duplicate Mode 5 PIN (refer to the Mode 5 items in the REF)"), '(64, "Ambiguous acknowledge, overlapping interrogation windows"), '(65, "Ambiguous acknowledge, duplicated request for same Mode S address"), '(66, "Ambiguous acknowledge, duplicated request for same track number"), '(67, "Reject, unable to process"), '(68, "Reject, too many parallel requests (exceeds system parameter for maximum number of requests per scan)"), '(69, "Reject, duplicated request")] +type TRuleContent416 = 'GContextFree TContent418 +type TVariation167 = 'GElement 0 7 TRuleContent416 +type TVariation1539 = 'GRepetitive 'GRepetitiveFx TVariation167 +type TRuleVariation1455 = 'GContextFree TVariation1539 +type TNonSpare121 = 'GNonSpare "030" "Warning/Error Conditions" TRuleVariation1455 +type TUapItem121 = 'GUapItem TNonSpare121 +type TNonSpare288 = 'GNonSpare "100" "Mode-C Code and Code Confidence Indicator" TRuleVariation1241 +type TUapItem288 = 'GUapItem TNonSpare288 +type TItem1 = 'GSpare 0 2 +type TVariation624 = 'GElement 2 14 TRuleContent658 +type TRuleVariation612 = 'GContextFree TVariation624 +type TNonSpare537 = 'GNonSpare "3DH" "3D-Height" TRuleVariation612 +type TItem33 = 'GItem TNonSpare537 +type TVariation1041 = 'GGroup 0 '[ TItem1, TItem33] +type TRuleVariation1010 = 'GContextFree TVariation1041 +type TNonSpare304 = 'GNonSpare "110" "Height Measured by a 3D Radar" TRuleVariation1010 +type TUapItem304 = 'GUapItem TNonSpare304 +type TContent206 = 'GContentTable '[ '(0, "Doppler speed is valid"), '(1, "Doppler speed is doubtful")] +type TRuleContent206 = 'GContextFree TContent206 +type TVariation42 = 'GElement 0 1 TRuleContent206 +type TRuleVariation42 = 'GContextFree TVariation42 +type TNonSpare922 = 'GNonSpare "D" "" TRuleVariation42 +type TItem250 = 'GItem TNonSpare922 +type TItem8 = 'GSpare 1 5 +type TContent656 = 'GContentQuantity 'GSigned ('GNumInt ('GZ 'GPlus 1)) "m/s" +type TRuleContent654 = 'GContextFree TContent656 +type TVariation1002 = 'GElement 6 10 TRuleContent654 +type TRuleVariation971 = 'GContextFree TVariation1002 +type TNonSpare760 = 'GNonSpare "CAL" "Calculated Doppler Speed" TRuleVariation971 +type TItem142 = 'GItem TNonSpare760 +type TVariation1132 = 'GGroup 0 '[ TItem250, TItem8, TItem142] +type TRuleVariation1087 = 'GContextFree TVariation1132 +type TNonSpare763 = 'GNonSpare "CAL" "Subfield #1: Calculated Doppler Speed" TRuleVariation1087 +type TContent750 = 'GContentQuantity 'GUnsigned ('GNumInt ('GZ 'GPlus 1)) "m/s" +type TRuleContent748 = 'GContextFree TContent750 +type TVariation320 = 'GElement 0 16 TRuleContent748 +type TRuleVariation312 = 'GContextFree TVariation320 +type TNonSpare961 = 'GNonSpare "DOP" "Doppler Speed" TRuleVariation312 +type TItem284 = 'GItem TNonSpare961 +type TNonSpare660 = 'GNonSpare "AMB" "Ambiguity Range" TRuleVariation312 +type TItem75 = 'GItem TNonSpare660 +type TContent740 = 'GContentQuantity 'GUnsigned ('GNumInt ('GZ 'GPlus 1)) "MHz" +type TRuleContent738 = 'GContextFree TContent740 +type TVariation314 = 'GElement 0 16 TRuleContent738 +type TRuleVariation306 = 'GContextFree TVariation314 +type TNonSpare1072 = 'GNonSpare "FRQ" "Transmitter Frequency" TRuleVariation306 +type TItem368 = 'GItem TNonSpare1072 +type TVariation1136 = 'GGroup 0 '[ TItem284, TItem75, TItem368] +type TVariation1496 = 'GRepetitive ('GRepetitiveRegular 1) TVariation1136 +type TRuleVariation1412 = 'GContextFree TVariation1496 +type TNonSpare1697 = 'GNonSpare "RDS" "Subfield #2: Raw Doppler Speed" TRuleVariation1412 +type TVariation1562 = 'GCompound '[ 'Just TNonSpare763, 'Just TNonSpare1697] +type TRuleVariation1478 = 'GContextFree TVariation1562 +type TNonSpare321 = 'GNonSpare "120" "Radial Doppler Speed" TRuleVariation1478 +type TUapItem321 = 'GUapItem TNonSpare321 +type TContent354 = 'GContentTable '[ '(0, "No communications capability (surveillance only)"), '(1, "Comm. A and Comm. B capability"), '(2, "Comm. A, Comm. B and Uplink ELM"), '(3, "Comm. A, Comm. B, Uplink ELM and Downlink ELM"), '(4, "Level 5 Transponder capability"), '(5, "Not Assigned"), '(6, "Not Assigned"), '(7, "Not Assigned")] +type TRuleContent352 = 'GContextFree TContent354 +type TVariation131 = 'GElement 0 3 TRuleContent352 +type TRuleVariation131 = 'GContextFree TVariation131 +type TNonSpare852 = 'GNonSpare "COM" "Communications Capability of the Transponder" TRuleVariation131 +type TItem203 = 'GItem TNonSpare852 +type TContent336 = 'GContentTable '[ '(0, "No alert, no SPI, aircraft airborne"), '(1, "No alert, no SPI, aircraft on ground"), '(2, "Alert, no SPI, aircraft airborne"), '(3, "Alert, no SPI, aircraft on ground"), '(4, "Alert, SPI, aircraft airborne or on ground"), '(5, "No alert, SPI, aircraft airborne or on ground"), '(6, "Not Assigned"), '(7, "Unknown")] +type TRuleContent334 = 'GContextFree TContent336 +type TVariation709 = 'GElement 3 3 TRuleContent334 +type TRuleVariation697 = 'GContextFree TVariation709 +type TNonSpare1937 = 'GNonSpare "STAT" "Flight Status" TRuleVariation697 +type TItem1017 = 'GItem TNonSpare1937 +type TContent472 = 'GContentTable '[ '(0, "SI-Code Capable"), '(1, "II-Code Capable")] +type TRuleContent470 = 'GContextFree TContent472 +type TVariation982 = 'GElement 6 1 TRuleContent470 +type TRuleVariation951 = 'GContextFree TVariation982 +type TNonSpare1848 = 'GNonSpare "SI" "SI/II Transponder Capability" TRuleVariation951 +type TItem948 = 'GItem TNonSpare1848 +type TVariation58 = 'GElement 0 1 TRuleContent314 +type TRuleVariation58 = 'GContextFree TVariation58 +type TNonSpare1445 = 'GNonSpare "MSSC" "Mode-S Specific Service Capability" TRuleVariation58 +type TItem646 = 'GItem TNonSpare1445 +type TContent4 = 'GContentTable '[ '(0, "100 ft resolution"), '(1, "25 ft resolution")] +type TRuleContent4 = 'GContextFree TContent4 +type TVariation415 = 'GElement 1 1 TRuleContent4 +type TRuleVariation403 = 'GContextFree TVariation415 +type TNonSpare679 = 'GNonSpare "ARC" "Altitude Reporting Capability" TRuleVariation403 +type TItem84 = 'GItem TNonSpare679 +type TNonSpare639 = 'GNonSpare "AIC" "Aircraft Identification Capability" TRuleVariation564 +type TItem58 = 'GItem TNonSpare639 +type TVariation634 = 'GElement 3 1 TRuleContent0 +type TRuleVariation622 = 'GContextFree TVariation634 +type TNonSpare722 = 'GNonSpare "B1A" "BDS 1,0 Bit 16" TRuleVariation622 +type TItem112 = 'GItem TNonSpare722 +type TNonSpare724 = 'GNonSpare "B1B" "BDS 1,0 Bits 37/40" TRuleVariation796 +type TItem114 = 'GItem TNonSpare724 +type TVariation1124 = 'GGroup 0 '[ TItem203, TItem1017, TItem948, TItem29, TItem646, TItem84, TItem58, TItem112, TItem114] +type TRuleVariation1079 = 'GContextFree TVariation1124 +type TNonSpare459 = 'GNonSpare "230" "Communications/ACAS Capability and Flight Status" TRuleVariation1079 +type TUapItem459 = 'GUapItem TNonSpare459 +type TNonSpare490 = 'GNonSpare "260" "ACAS Resolution Advisory Report" TRuleVariation397 +type TUapItem490 = 'GUapItem TNonSpare490 +type TContent294 = 'GContentTable '[ '(0, "Mode-1 code as derived from the reply of the transponder"), '(1, "Smoothed Mode-1 code as provided by a local tracker")] +type TRuleContent292 = 'GContextFree TContent294 +type TVariation563 = 'GElement 2 1 TRuleContent292 +type TRuleVariation551 = 'GContextFree TVariation563 +type TNonSpare1213 = 'GNonSpare "L" "" TRuleVariation551 +type TItem469 = 'GItem TNonSpare1213 +type TVariation720 = 'GElement 3 5 TRuleContent0 +type TRuleVariation708 = 'GContextFree TVariation720 +type TNonSpare1409 = 'GNonSpare "MODE1" "Mode-1 Code" TRuleVariation708 +type TItem613 = 'GItem TNonSpare1409 +type TVariation1323 = 'GGroup 0 '[ TItem1191, TItem377, TItem469, TItem613] +type TRuleVariation1247 = 'GContextFree TVariation1323 +type TNonSpare194 = 'GNonSpare "055" "Mode-1 Code in Octal Representation" TRuleVariation1247 +type TUapItem194 = 'GUapItem TNonSpare194 +type TNonSpare179 = 'GNonSpare "050" "Mode-2 Code in Octal Representation" TRuleVariation1249 +type TUapItem179 = 'GUapItem TNonSpare179 +type TItem2 = 'GSpare 0 3 +type TVariation661 = 'GElement 3 1 TRuleContent233 +type TRuleVariation649 = 'GContextFree TVariation661 +type TNonSpare1622 = 'GNonSpare "QA4" "" TRuleVariation649 +type TItem785 = 'GItem TNonSpare1622 +type TVariation750 = 'GElement 4 1 TRuleContent232 +type TRuleVariation738 = 'GContextFree TVariation750 +type TNonSpare1617 = 'GNonSpare "QA2" "" TRuleVariation738 +type TItem780 = 'GItem TNonSpare1617 +type TVariation960 = 'GElement 6 1 TRuleContent235 +type TRuleVariation929 = 'GContextFree TVariation960 +type TNonSpare1631 = 'GNonSpare "QB2" "" TRuleVariation929 +type TItem794 = 'GItem TNonSpare1631 +type TVariation1012 = 'GElement 7 1 TRuleContent234 +type TRuleVariation981 = 'GContextFree TVariation1012 +type TNonSpare1627 = 'GNonSpare "QB1" "" TRuleVariation981 +type TItem790 = 'GItem TNonSpare1627 +type TVariation1055 = 'GGroup 0 '[ TItem2, TItem785, TItem780, TItem777, TItem794, TItem790] +type TRuleVariation1024 = 'GContextFree TVariation1055 +type TNonSpare213 = 'GNonSpare "065" "Mode-1 Code Confidence Indicator" TRuleVariation1024 +type TUapItem213 = 'GUapItem TNonSpare213 +type TNonSpare196 = 'GNonSpare "060" "Mode-2 Code Confidence Indicator" TRuleVariation1040 +type TUapItem196 = 'GUapItem TNonSpare196 +type TVariation724 = 'GElement 4 1 TRuleContent0 +type TRuleVariation712 = 'GContextFree TVariation724 +type TNonSpare1456 = 'GNonSpare "N" "Interrogation Was Not Executed" TRuleVariation712 +type TItem654 = 'GItem TNonSpare1456 +type TVariation846 = 'GElement 5 1 TRuleContent0 +type TRuleVariation815 = 'GContextFree TVariation846 +type TNonSpare1979 = 'GNonSpare "T" "Interrogation Scheduler Has Truncated the All Call Request" TRuleVariation815 +type TItem1049 = 'GItem TNonSpare1979 +type TVariation929 = 'GElement 6 1 TRuleContent0 +type TRuleVariation898 = 'GContextFree TVariation929 +type TNonSpare597 = 'GNonSpare "A" "Interrogation Scheduler Has Activated the Request At Least Once" TRuleVariation898 +type TItem35 = 'GItem TNonSpare597 +type TVariation1006 = 'GElement 7 1 TRuleContent0 +type TRuleVariation975 = 'GContextFree TVariation1006 +type TNonSpare758 = 'GNonSpare "C" "Interrogation Scheduler Has Activated the Request During All Its Validity" TRuleVariation975 +type TItem140 = 'GItem TNonSpare758 +type TVariation1070 = 'GGroup 0 '[ TItem3, TItem654, TItem1049, TItem35, TItem140] +type TRuleVariation1038 = 'GContextFree TVariation1070 +type TNonSpare2068 = 'GNonSpare "TR" "Subfield #1: Truncation" TRuleVariation1038 +type TNonSpare1308 = 'GNonSpare "M4" "Subfield #2: Mode 4 Interrogations" TRuleVariation171 +type TNonSpare1314 = 'GNonSpare "M5" "Subfield #3: Mode 5 Interrogations" TRuleVariation171 +type TItem5 = 'GSpare 0 6 +type TContent322 = 'GContentTable '[ '(0, "No Lockout used by Interrogation Scheduler"), '(1, "Lockout used by Interrogation Scheduler"), '(2, "Lockout-Override applied")] +type TRuleContent320 = 'GContextFree TContent322 +type TVariation994 = 'GElement 6 2 TRuleContent320 +type TRuleVariation963 = 'GContextFree TVariation994 +type TNonSpare1256 = 'GNonSpare "LO" "Lockout" TRuleVariation963 +type TItem510 = 'GItem TNonSpare1256 +type TNonSpare1466 = 'GNonSpare "NB" "Number of Mode S All Calls Performed for the Request" TRuleVariation171 +type TItem662 = 'GItem TNonSpare1466 +type TVariation1083 = 'GGroup 0 '[ TItem5, TItem510, TItem662] +type TRuleVariation1050 = 'GContextFree TVariation1083 +type TNonSpare1431 = 'GNonSpare "MS" "Subfield #4: Mode S All Call Interrogations" TRuleVariation1050 +type TNonSpare1455 = 'GNonSpare "MX" "Subfield #5: Mark X Interrogations" TRuleVariation171 +type TNonSpare1884 = 'GNonSpare "SMS" "Subfield #6: Selective Mode S Interrogations" TRuleVariation171 +type TVariation1604 = 'GCompound '[ 'Just TNonSpare2068, 'Just TNonSpare1308, 'Just TNonSpare1314, 'Just TNonSpare1431, 'Just TNonSpare1455, 'Just TNonSpare1884] +type TRuleVariation1520 = 'GContextFree TVariation1604 +type TNonSpare558 = 'GNonSpare "450" "Directed Interrogation Result" TRuleVariation1520 +type TUapItem556 = 'GUapItem TNonSpare558 +type TContent327 = 'GContentTable '[ '(0, "No Mode 5 interrogation"), '(1, "Mode 5 interrogation")] +type TRuleContent325 = 'GContextFree TContent327 +type TVariation59 = 'GElement 0 1 TRuleContent325 +type TRuleVariation59 = 'GContextFree TVariation59 +type TNonSpare1312 = 'GNonSpare "M5" "" TRuleVariation59 +type TItem558 = 'GItem TNonSpare1312 +type TContent343 = 'GContentTable '[ '(0, "No authenticated Mode 5 ID reply"), '(1, "Authenticated Mode 5 ID reply")] +type TRuleContent341 = 'GContextFree TContent343 +type TVariation456 = 'GElement 1 1 TRuleContent341 +type TRuleVariation444 = 'GContextFree TVariation456 +type TNonSpare1187 = 'GNonSpare "ID" "" TRuleVariation444 +type TItem449 = 'GItem TNonSpare1187 +type TContent341 = 'GContentTable '[ '(0, "No authenticated Mode 5 Data reply or Report"), '(1, "Authenticated Mode 5 Data reply or Report (i.e any valid Mode 5 reply type other than ID)")] +type TRuleContent339 = 'GContextFree TContent341 +type TVariation578 = 'GElement 2 1 TRuleContent339 +type TRuleVariation566 = 'GContextFree TVariation578 +type TNonSpare925 = 'GNonSpare "DA" "" TRuleVariation566 +type TItem253 = 'GItem TNonSpare925 +type TContent283 = 'GContentTable '[ '(0, "Mode 1 code not present or not from Mode 5 reply"), '(1, "Mode 1 code from Mode 5 reply")] +type TRuleContent281 = 'GContextFree TContent283 +type TVariation666 = 'GElement 3 1 TRuleContent281 +type TRuleVariation654 = 'GContextFree TVariation666 +type TNonSpare1290 = 'GNonSpare "M1" "" TRuleVariation654 +type TItem542 = 'GItem TNonSpare1290 +type TContent285 = 'GContentTable '[ '(0, "Mode 2 code not present or not from Mode 5 reply"), '(1, "Mode 2 code from Mode 5 reply")] +type TRuleContent283 = 'GContextFree TContent285 +type TVariation758 = 'GElement 4 1 TRuleContent283 +type TRuleVariation746 = 'GContextFree TVariation758 +type TNonSpare1293 = 'GNonSpare "M2" "" TRuleVariation746 +type TItem545 = 'GItem TNonSpare1293 +type TContent287 = 'GContentTable '[ '(0, "Mode 3 code not present or not from Mode 5 reply"), '(1, "Mode 3 code from Mode 5 reply")] +type TRuleContent285 = 'GContextFree TContent287 +type TVariation890 = 'GElement 5 1 TRuleContent285 +type TRuleVariation859 = 'GContextFree TVariation890 +type TNonSpare1298 = 'GNonSpare "M3" "" TRuleVariation859 +type TItem549 = 'GItem TNonSpare1298 +type TContent291 = 'GContentTable '[ '(0, "Mode C altitude not present or not from Mode 5 reply"), '(1, "Mode C altitude from Mode 5 reply")] +type TRuleContent289 = 'GContextFree TContent291 +type TVariation970 = 'GElement 6 1 TRuleContent289 +type TRuleVariation939 = 'GContextFree TVariation970 +type TNonSpare1341 = 'GNonSpare "MC" "" TRuleVariation939 +type TItem578 = 'GItem TNonSpare1341 +type TVariation1197 = 'GGroup 0 '[ TItem558, TItem449, TItem253, TItem542, TItem545, TItem549, TItem578, TItem29] +type TRuleVariation1148 = 'GContextFree TVariation1197 +type TNonSpare1974 = 'GNonSpare "SUM" "Subfield #1: Mode 5 Summary" TRuleVariation1148 +type TVariation622 = 'GElement 2 14 TRuleContent0 +type TRuleVariation610 = 'GContextFree TVariation622 +type TNonSpare1550 = 'GNonSpare "PIN" "PIN Code" TRuleVariation610 +type TItem739 = 'GItem TNonSpare1550 +type TNonSpare1458 = 'GNonSpare "NAT" "National Origin" TRuleVariation708 +type TItem656 = 'GItem TNonSpare1458 +type TVariation620 = 'GElement 2 6 TRuleContent0 +type TRuleVariation608 = 'GContextFree TVariation620 +type TNonSpare1399 = 'GNonSpare "MIS" "Mission Code" TRuleVariation608 +type TItem604 = 'GItem TNonSpare1399 +type TVariation1044 = 'GGroup 0 '[ TItem1, TItem739, TItem2, TItem656, TItem1, TItem604] +type TRuleVariation1013 = 'GContextFree TVariation1044 +type TNonSpare1556 = 'GNonSpare "PMN" "Subfield #2: Mode 5 PIN/National Origin/Mission Code" TRuleVariation1013 +type TContent723 = 'GContentQuantity 'GSigned ('GNumDiv ('GNumInt ('GZ 'GPlus 180)) ('GNumPow ('GZ 'GPlus 2) ('GZ 'GPlus 23))) "°" +type TRuleContent721 = 'GContextFree TContent723 +type TVariation374 = 'GElement 0 24 TRuleContent721 +type TRuleVariation366 = 'GContextFree TVariation374 +type TNonSpare1236 = 'GNonSpare "LAT" "Latitude in WGS 84" TRuleVariation366 +type TItem492 = 'GItem TNonSpare1236 +type TContent721 = 'GContentQuantity 'GSigned ('GNumDiv ('GNumInt ('GZ 'GPlus 180)) ('GNumPow ('GZ 'GPlus 2) ('GZ 'GPlus 23))) "°" +type TRuleContent719 = 'GContextFree TContent721 +type TVariation372 = 'GElement 0 24 TRuleContent719 +type TRuleVariation364 = 'GContextFree TVariation372 +type TNonSpare1269 = 'GNonSpare "LON" "Longitude in WGS 84" TRuleVariation364 +type TItem523 = 'GItem TNonSpare1269 +type TVariation1188 = 'GGroup 0 '[ TItem492, TItem523] +type TRuleVariation1139 = 'GContextFree TVariation1188 +type TNonSpare1573 = 'GNonSpare "POS" "Subfield #3: Mode 5 Reported Position" TRuleVariation1139 +type TItem0 = 'GSpare 0 1 +type TContent225 = 'GContentTable '[ '(0, "GA reported in 100 ft increments"), '(1, "GA reported in 25 ft increments")] +type TRuleContent225 = 'GContextFree TContent225 +type TVariation441 = 'GElement 1 1 TRuleContent225 +type TRuleVariation429 = 'GContextFree TVariation441 +type TNonSpare1720 = 'GNonSpare "RES" "Resolution with which the GNSS-derived Altitude (GA) is Reported" TRuleVariation429 +type TItem871 = 'GItem TNonSpare1720 +type TContent664 = 'GContentQuantity 'GSigned ('GNumInt ('GZ 'GPlus 25)) "ft" +type TRuleContent662 = 'GContextFree TContent664 +type TVariation625 = 'GElement 2 14 TRuleContent662 +type TRuleVariation613 = 'GContextFree TVariation625 +type TNonSpare1090 = 'GNonSpare "GA" "GNSS-derived Altitude of Target, Expressed as Height Above WGS 84 Ellipsoid" TRuleVariation613 +type TItem382 = 'GItem TNonSpare1090 +type TVariation1037 = 'GGroup 0 '[ TItem0, TItem871, TItem382] +type TRuleVariation1006 = 'GContextFree TVariation1037 +type TNonSpare1094 = 'GNonSpare "GA" "Subfield #4: Mode 5 GNSS-derived Altitude" TRuleVariation1006 +type TContent60 = 'GContentTable '[ '(0, "Code not validated"), '(1, "Code validated")] +type TRuleContent60 = 'GContextFree TContent60 +type TVariation15 = 'GElement 0 1 TRuleContent60 +type TRuleVariation15 = 'GContextFree TVariation15 +type TNonSpare2163 = 'GNonSpare "V" "" TRuleVariation15 +type TItem1190 = 'GItem TNonSpare2163 +type TContent295 = 'GContentTable '[ '(0, "Mode-1 code derived from the reply of the transponder"), '(1, "Mode-1 code not extracted during the last scan")] +type TRuleContent293 = 'GContextFree TContent295 +type TVariation564 = 'GElement 2 1 TRuleContent293 +type TRuleVariation552 = 'GContextFree TVariation564 +type TNonSpare1214 = 'GNonSpare "L" "" TRuleVariation552 +type TItem470 = 'GItem TNonSpare1214 +type TNonSpare993 = 'GNonSpare "EM1" "Extended Mode 1 Code in Octal Representation" TRuleVariation807 +type TItem307 = 'GItem TNonSpare993 +type TVariation1314 = 'GGroup 0 '[ TItem1190, TItem377, TItem470, TItem16, TItem307] +type TRuleVariation1238 = 'GContextFree TVariation1314 +type TNonSpare998 = 'GNonSpare "EM1" "Subfield #5: Extended Mode 1 Code in Octal Representation" TRuleVariation1238 +type TContent707 = 'GContentQuantity 'GSigned ('GNumDiv ('GNumInt ('GZ 'GPlus 1)) ('GNumPow ('GZ 'GPlus 2) ('GZ 'GPlus 7))) "s" +type TRuleContent705 = 'GContextFree TContent707 +type TVariation230 = 'GElement 0 8 TRuleContent705 +type TRuleVariation222 = 'GContextFree TVariation230 +type TNonSpare2053 = 'GNonSpare "TOS" "Subfield #6: Time Offset for POS and GA" TRuleVariation222 +type TContent597 = 'GContentTable '[ '(0, "X-pulse set to zero or no authenticated Data reply or Report received"), '(1, "X-pulse set to one (present)")] +type TRuleContent595 = 'GContextFree TContent597 +type TVariation696 = 'GElement 3 1 TRuleContent595 +type TRuleVariation684 = 'GContextFree TVariation696 +type TNonSpare2301 = 'GNonSpare "X5" "X-pulse from Mode 5 Data Reply or Report" TRuleVariation684 +type TItem1317 = 'GItem TNonSpare2301 +type TContent595 = 'GContentTable '[ '(0, "X-pulse set to zero or no Mode C reply"), '(1, "X-pulse set to one (present)")] +type TRuleContent593 = 'GContextFree TContent595 +type TVariation789 = 'GElement 4 1 TRuleContent593 +type TRuleVariation777 = 'GContextFree TVariation789 +type TNonSpare2304 = 'GNonSpare "XC" "X-pulse from Mode C Reply" TRuleVariation777 +type TItem1320 = 'GItem TNonSpare2304 +type TContent594 = 'GContentTable '[ '(0, "X-pulse set to zero or no Mode 3/A reply"), '(1, "X-pulse set to one (present)")] +type TRuleContent592 = 'GContextFree TContent594 +type TVariation906 = 'GElement 5 1 TRuleContent592 +type TRuleVariation875 = 'GContextFree TVariation906 +type TNonSpare2300 = 'GNonSpare "X3" "X-pulse from Mode 3/A Reply" TRuleVariation875 +type TItem1316 = 'GItem TNonSpare2300 +type TContent593 = 'GContentTable '[ '(0, "X-pulse set to zero or no Mode 2 reply"), '(1, "X-pulse set to one (present)")] +type TRuleContent591 = 'GContextFree TContent593 +type TVariation991 = 'GElement 6 1 TRuleContent591 +type TRuleVariation960 = 'GContextFree TVariation991 +type TNonSpare2298 = 'GNonSpare "X2" "X-pulse from Mode 2 Reply" TRuleVariation960 +type TItem1314 = 'GItem TNonSpare2298 +type TContent592 = 'GContentTable '[ '(0, "X-pulse set to zero or no Mode 1 reply"), '(1, "X-pulse set to one (present)")] +type TRuleContent590 = 'GContextFree TContent592 +type TVariation1026 = 'GElement 7 1 TRuleContent590 +type TRuleVariation995 = 'GContextFree TVariation1026 +type TNonSpare2294 = 'GNonSpare "X1" "X-pulse from Mode 1 Reply" TRuleVariation995 +type TItem1310 = 'GItem TNonSpare2294 +type TVariation1058 = 'GGroup 0 '[ TItem2, TItem1317, TItem1320, TItem1316, TItem1314, TItem1310] +type TRuleVariation1027 = 'GContextFree TVariation1058 +type TNonSpare2305 = 'GNonSpare "XP" "Subfield #7: X Pulse Presence" TRuleVariation1027 +type TVariation1599 = 'GCompound '[ 'Just TNonSpare1974, 'Just TNonSpare1556, 'Just TNonSpare1573, 'Just TNonSpare1094, 'Just TNonSpare998, 'Just TNonSpare2053, 'Just TNonSpare2305] +type TRuleVariation1515 = 'GContextFree TVariation1599 +type TNonSpare256 = 'GNonSpare "085" "Mode 5, Extended Mode 1 and X-Pulse" TRuleVariation1515 +type TUapItem256 = 'GUapItem TNonSpare256 +type TNonSpare1892 = 'GNonSpare "SPF" "Special Purpose Field" TRuleVariation1460 +type TUapItem597 = 'GUapItem TNonSpare1892 +type TNonSpare1711 = 'GNonSpare "REF" "Reserved Expansion Field" TRuleVariation1459 +type TUapItem595 = 'GUapItem TNonSpare1711 +type TRecord31 = 'GRecord '[ TUapItem39, TUapItem103, TUapItem543, TUapItem355, TUapItem538, TUapItem96, TUapItem144, TUapItem222, TUapItem263, TUapItem333, TUapItem447, TUapItem467, TUapItem483, TUapItem384, TUapItem167, TUapItem415, TUapItem401, TUapItem443, TUapItem121, TUapItem244, TUapItem288, TUapItem304, TUapItem321, TUapItem459, TUapItem490, TUapItem194, TUapItem179, TUapItem213, TUapItem196, TUapItem556, TUapItem256, TUapItem598, TUapItem598, TUapItem597, TUapItem595] +type TItem6 = 'GSpare 0 7 +type TContent384 = 'GContentTable '[ '(0, "No lockout override"), '(1, "Lockout override")] +type TRuleContent382 = 'GContextFree TContent384 +type TVariation1018 = 'GElement 7 1 TRuleContent382 +type TRuleVariation987 = 'GContextFree TVariation1018 +type TNonSpare1257 = 'GNonSpare "LO" "Lockout Override" TRuleVariation987 +type TItem511 = 'GItem TNonSpare1257 +type TContent3 = 'GContentTable '[ '(0, "1"), '(1, "1/2"), '(2, "1/4"), '(3, "1/8"), '(4, "1/16")] +type TRuleContent3 = 'GContextFree TContent3 +type TVariation128 = 'GElement 0 3 TRuleContent3 +type TRuleVariation128 = 'GContextFree TVariation128 +type TNonSpare1444 = 'GNonSpare "MSPROB" "Probability of Reply If Mode S UF11 or Combined Modes Are Used" TRuleVariation128 +type TItem645 = 'GItem TNonSpare1444 +type TNonSpare1315 = 'GNonSpare "M5FORMAT" "Mode 5 Format" TRuleVariation708 +type TItem560 = 'GItem TNonSpare1315 +type TContent59 = 'GContentTable '[ '(0, "Code A"), '(1, "Code B"), '(2, "Defined by sensor")] +type TRuleContent59 = 'GContextFree TContent59 +type TVariation104 = 'GElement 0 2 TRuleContent59 +type TRuleVariation104 = 'GContextFree TVariation104 +type TNonSpare1309 = 'GNonSpare "M4CS" "Mode 4 Code Selection" TRuleVariation104 +type TItem556 = 'GItem TNonSpare1309 +type TVariation524 = 'GElement 2 1 TRuleContent0 +type TRuleVariation512 = 'GContextFree TVariation524 +type TNonSpare1318 = 'GNonSpare "M5S" "M5_SUPERMODE_S" TRuleVariation512 +type TItem562 = 'GItem TNonSpare1318 +type TNonSpare1882 = 'GNonSpare "SM5S" "M5_SUPERMODE_S" TRuleVariation622 +type TItem980 = 'GItem TNonSpare1882 +type TNonSpare1880 = 'GNonSpare "SM54" "M5_SUPERMODE_4" TRuleVariation712 +type TItem978 = 'GItem TNonSpare1880 +type TNonSpare1881 = 'GNonSpare "SM5C" "M5_SUPERMODE_C" TRuleVariation815 +type TItem979 = 'GItem TNonSpare1881 +type TNonSpare1879 = 'GNonSpare "SM53" "M5_SUPERMODE_3A" TRuleVariation898 +type TItem977 = 'GItem TNonSpare1879 +type TNonSpare1878 = 'GNonSpare "SM52" "M5_SUPERMODE_2" TRuleVariation975 +type TItem976 = 'GItem TNonSpare1878 +type TVariation0 = 'GElement 0 1 TRuleContent0 +type TRuleVariation0 = 'GContextFree TVariation0 +type TNonSpare1877 = 'GNonSpare "SM51" "M5_SUPERMODE_1" TRuleVariation0 +type TItem975 = 'GItem TNonSpare1877 +type TNonSpare1313 = 'GNonSpare "M5" "MODE_5" TRuleVariation512 +type TItem559 = 'GItem TNonSpare1313 +type TNonSpare1684 = 'GNonSpare "RCMA" "MODE S ROLL_CALL" TRuleVariation622 +type TItem842 = 'GItem TNonSpare1684 +type TNonSpare1685 = 'GNonSpare "RCMC" "MODE S ROLL_CALL" TRuleVariation712 +type TItem843 = 'GItem TNonSpare1685 +type TNonSpare812 = 'GNonSpare "CMC" "COMBINED_C" TRuleVariation815 +type TItem179 = 'GItem TNonSpare812 +type TNonSpare811 = 'GNonSpare "CM3A" "COMBINED_3A" TRuleVariation898 +type TItem178 = 'GItem TNonSpare811 +type TNonSpare1430 = 'GNonSpare "MS" "MODE_S" TRuleVariation975 +type TItem634 = 'GItem TNonSpare1430 +type TNonSpare1311 = 'GNonSpare "M4S" "M4_SUPERMODE_" TRuleVariation0 +type TItem557 = 'GItem TNonSpare1311 +type TVariation414 = 'GElement 1 1 TRuleContent0 +type TRuleVariation402 = 'GContextFree TVariation414 +type TNonSpare1883 = 'GNonSpare "SMC" "SUPERMODE_C" TRuleVariation402 +type TItem981 = 'GItem TNonSpare1883 +type TNonSpare1876 = 'GNonSpare "SM3A" "SUPERMODE_3A" TRuleVariation512 +type TItem974 = 'GItem TNonSpare1876 +type TNonSpare1875 = 'GNonSpare "SM2" "SUPERMODE_2" TRuleVariation622 +type TItem973 = 'GItem TNonSpare1875 +type TNonSpare1874 = 'GNonSpare "SM1" "SUPERMODE_1" TRuleVariation712 +type TItem972 = 'GItem TNonSpare1874 +type TNonSpare1344 = 'GNonSpare "MCO" "MODE_C_ONLY" TRuleVariation815 +type TItem581 = 'GItem TNonSpare1344 +type TNonSpare1305 = 'GNonSpare "M3O" "MODE_3A_ONLY" TRuleVariation898 +type TItem553 = 'GItem TNonSpare1305 +type TNonSpare1345 = 'GNonSpare "MCS" "MODE_C_S" TRuleVariation975 +type TItem582 = 'GItem TNonSpare1345 +type TNonSpare1306 = 'GNonSpare "M3S" "MODE_3A_S" TRuleVariation0 +type TItem554 = 'GItem TNonSpare1306 +type TNonSpare1346 = 'GNonSpare "MD" "MODE_D" TRuleVariation402 +type TItem583 = 'GItem TNonSpare1346 +type TNonSpare1343 = 'GNonSpare "MC" "MODE_C" TRuleVariation512 +type TItem580 = 'GItem TNonSpare1343 +type TNonSpare1333 = 'GNonSpare "MB" "MODE_B" TRuleVariation622 +type TItem571 = 'GItem TNonSpare1333 +type TNonSpare1307 = 'GNonSpare "M4" "MODE_4" TRuleVariation712 +type TItem555 = 'GItem TNonSpare1307 +type TNonSpare1303 = 'GNonSpare "M3A" "MODE_3A" TRuleVariation815 +type TItem552 = 'GItem TNonSpare1303 +type TNonSpare1296 = 'GNonSpare "M2" "MODE_2" TRuleVariation898 +type TItem548 = 'GItem TNonSpare1296 +type TNonSpare1292 = 'GNonSpare "M1" "MODE_1" TRuleVariation975 +type TItem544 = 'GItem TNonSpare1292 +type TVariation1085 = 'GGroup 0 '[ TItem6, TItem511, TItem645, TItem560, TItem556, TItem562, TItem980, TItem978, TItem979, TItem977, TItem976, TItem975, TItem7, TItem559, TItem842, TItem843, TItem179, TItem178, TItem634, TItem557, TItem981, TItem974, TItem973, TItem972, TItem581, TItem553, TItem582, TItem554, TItem583, TItem580, TItem571, TItem555, TItem552, TItem548, TItem544] +type TRuleVariation1052 = 'GContextFree TVariation1085 +type TNonSpare1732 = 'GNonSpare "RIM" "Subfield #1: Required Interrogation Modes" TRuleVariation1052 +type TNonSpare1398 = 'GNonSpare "MIPT" "Subfield #2: MIP Table" TRuleVariation171 +type TVariation1545 = 'GCompound '[ 'Nothing, 'Nothing, 'Nothing, 'Nothing, 'Nothing, 'Just TNonSpare1732, 'Just TNonSpare1398] +type TRuleVariation1461 = 'GContextFree TVariation1545 +type TNonSpare548 = 'GNonSpare "415" "Required Interrogation Modes" TRuleVariation1461 +type TUapItem546 = 'GUapItem TNonSpare548 +type TNonSpare1753 = 'GNonSpare "RS" "Rho-Start" TRuleVariation341 +type TItem895 = 'GItem TNonSpare1753 +type TNonSpare1703 = 'GNonSpare "RE" "Rho-End" TRuleVariation341 +type TItem855 = 'GItem TNonSpare1703 +type TNonSpare2097 = 'GNonSpare "TS" "Theta-Start" TRuleVariation349 +type TItem1130 = 'GItem TNonSpare2097 +type TNonSpare2018 = 'GNonSpare "TE" "Theta-End" TRuleVariation349 +type TItem1075 = 'GItem TNonSpare2018 +type TVariation1246 = 'GGroup 0 '[ TItem895, TItem855, TItem1130, TItem1075] +type TRuleVariation1191 = 'GContextFree TVariation1246 +type TNonSpare549 = 'GNonSpare "420" "Directed Interrogation Window" TRuleVariation1191 +type TUapItem547 = 'GUapItem TNonSpare549 +type TVariation1104 = 'GGroup 0 '[ TItem120, TItem123] +type TVariation1486 = 'GRepetitive ('GRepetitiveRegular 1) TVariation1104 +type TRuleVariation1402 = 'GContextFree TVariation1486 +type TNonSpare556 = 'GNonSpare "440" "Directed Interrogation BDS Register Request" TRuleVariation1402 +type TUapItem554 = 'GUapItem TNonSpare556 +type TRecord32 = 'GRecord '[ TUapItem39, TUapItem103, TUapItem543, TUapItem355, TUapItem538, TUapItem144, TUapItem447, TUapItem384, TUapItem167, TUapItem415, TUapItem546, TUapItem547, TUapItem554, TUapItem598, TUapItem598, TUapItem598, TUapItem598, TUapItem598, TUapItem598, TUapItem597, TUapItem595] +type TUap55 = 'GUaps '[ '("downlink", TRecord31), '("uplink", TRecord32)] ('Just ('GUapSelector '[ "410"] '[ '( 0, "downlink"), '( 1, "downlink"), '( 2, "downlink"), '( 3, "downlink"), '( 4, "downlink"), '( 5, "uplink"), '( 6, "uplink"), '( 7, "uplink"), '( 8, "uplink")])) +type TAsterix8 = 'GAsterixBasic 7 ('GEdition 1 12) TUap55 +type TContent619 = 'GContentTable '[ '(1, "Polar vector"), '(2, "Cartesian vector of start point/length"), '(3, "Contour record"), '(4, "Cartesian start point and end point vector"), '(254, "SOP message"), '(255, "EOP message")] +type TRuleContent617 = 'GContextFree TContent619 +type TVariation206 = 'GElement 0 8 TRuleContent617 +type TRuleVariation198 = 'GContextFree TVariation206 +type TNonSpare8 = 'GNonSpare "000" "Message Type" TRuleVariation198 +type TUapItem8 = 'GUapItem TNonSpare8 +type TContent269 = 'GContentTable '[ '(0, "Local Coordinates"), '(1, "System Coordinates")] +type TRuleContent267 = 'GContextFree TContent269 +type TVariation54 = 'GElement 0 1 TRuleContent267 +type TRuleVariation54 = 'GContextFree TVariation54 +type TNonSpare1519 = 'GNonSpare "ORG" "" TRuleVariation54 +type TItem714 = 'GItem TNonSpare1519 +type TVariation504 = 'GElement 1 3 TRuleContent638 +type TRuleVariation492 = 'GContextFree TVariation504 +type TNonSpare1165 = 'GNonSpare "I" "Intensity Level" TRuleVariation492 +type TItem431 = 'GItem TNonSpare1165 +type TContent2 = 'GContentTable '[ '(0, "0°"), '(1, "22.5°"), '(2, "45°"), '(3, "67.5°"), '(4, "90°"), '(5, "112.5°"), '(6, "135°"), '(7, "157.5°")] +type TRuleContent2 = 'GContextFree TContent2 +type TVariation802 = 'GElement 4 3 TRuleContent2 +type TRuleVariation790 = 'GContextFree TVariation802 +type TNonSpare1787 = 'GNonSpare "S" "Shading Orientation with Respect to North" TRuleVariation790 +type TItem914 = 'GItem TNonSpare1787 +type TContent162 = 'GContentTable '[ '(0, "Default"), '(1, "Test vector")] +type TRuleContent162 = 'GContextFree TContent162 +type TVariation869 = 'GElement 5 1 TRuleContent162 +type TRuleVariation838 = 'GContextFree TVariation869 +type TNonSpare2107 = 'GNonSpare "TST" "" TRuleVariation838 +type TItem1140 = 'GItem TNonSpare2107 +type TContent100 = 'GContentTable '[ '(0, "Default"), '(1, "Error condition encountered")] +type TRuleContent100 = 'GContextFree TContent100 +type TVariation941 = 'GElement 6 1 TRuleContent100 +type TRuleVariation910 = 'GContextFree TVariation941 +type TNonSpare1029 = 'GNonSpare "ER" "" TRuleVariation910 +type TItem337 = 'GItem TNonSpare1029 +type TVariation1452 = 'GExtended '[ 'Just TItem714, 'Just TItem431, 'Just TItem914, 'Nothing, 'Just TItem4, 'Just TItem1140, 'Just TItem337, 'Nothing] +type TRuleVariation1368 = 'GContextFree TVariation1452 +type TNonSpare98 = 'GNonSpare "020" "Vector Qualifier" TRuleVariation1368 +type TUapItem98 = 'GUapItem TNonSpare98 +type TContent639 = 'GContentInteger 'GSigned +type TRuleContent637 = 'GContextFree TContent639 +type TVariation218 = 'GElement 0 8 TRuleContent637 +type TRuleVariation210 = 'GContextFree TVariation218 +type TNonSpare2286 = 'GNonSpare "X" "X-Component" TRuleVariation210 +type TItem1302 = 'GItem TNonSpare2286 +type TNonSpare2341 = 'GNonSpare "Y" "Y-Component" TRuleVariation210 +type TItem1353 = 'GItem TNonSpare2341 +type TNonSpare1250 = 'GNonSpare "LENGTH" "Length" TRuleVariation211 +type TItem504 = 'GItem TNonSpare1250 +type TVariation1375 = 'GGroup 0 '[ TItem1302, TItem1353, TItem504] +type TVariation1529 = 'GRepetitive ('GRepetitiveRegular 1) TVariation1375 +type TRuleVariation1445 = 'GContextFree TVariation1529 +type TNonSpare138 = 'GNonSpare "036" "Sequence of Cartesian Vectors in SPF Notation" TRuleVariation1445 +type TUapItem138 = 'GUapItem TNonSpare138 +type TNonSpare1959 = 'GNonSpare "STR" "Start Range" TRuleVariation211 +type TItem1038 = 'GItem TNonSpare1959 +type TNonSpare1005 = 'GNonSpare "ENDR" "End Range" TRuleVariation211 +type TItem313 = 'GItem TNonSpare1005 +type TNonSpare716 = 'GNonSpare "AZ" "Azimuth" TRuleVariation349 +type TItem109 = 'GItem TNonSpare716 +type TVariation1281 = 'GGroup 0 '[ TItem1038, TItem313, TItem109] +type TVariation1513 = 'GRepetitive ('GRepetitiveRegular 1) TVariation1281 +type TRuleVariation1429 = 'GContextFree TVariation1513 +type TNonSpare132 = 'GNonSpare "034" "Sequence of Polar Vectors in SPF Notation" TRuleVariation1429 +type TUapItem132 = 'GUapItem TNonSpare132 +type TVariation498 = 'GElement 1 3 TRuleContent0 +type TRuleVariation486 = 'GContextFree TVariation498 +type TNonSpare1164 = 'GNonSpare "I" "Intensity Level" TRuleVariation486 +type TItem430 = 'GItem TNonSpare1164 +type TItem20 = 'GSpare 4 2 +type TContent253 = 'GContentTable '[ '(0, "Intermediate record of a contour"), '(1, "Last record of a contour of at least two records"), '(2, "First record of a contour of at least two records"), '(3, "First and only record, fully defining a contour")] +type TRuleContent253 = 'GContextFree TContent253 +type TVariation993 = 'GElement 6 2 TRuleContent253 +type TRuleVariation962 = 'GContextFree TVariation993 +type TNonSpare1079 = 'GNonSpare "FSTLST" "" TRuleVariation962 +type TItem372 = 'GItem TNonSpare1079 +type TNonSpare904 = 'GNonSpare "CSN" "Contour Serial Number" TRuleVariation171 +type TItem236 = 'GItem TNonSpare904 +type TVariation1215 = 'GGroup 0 '[ TItem714, TItem430, TItem20, TItem372, TItem236] +type TRuleVariation1163 = 'GContextFree TVariation1215 +type TNonSpare142 = 'GNonSpare "040" "Contour Identifier" TRuleVariation1163 +type TUapItem142 = 'GUapItem TNonSpare142 +type TNonSpare2293 = 'GNonSpare "X1" "" TRuleVariation210 +type TItem1309 = 'GItem TNonSpare2293 +type TNonSpare2348 = 'GNonSpare "Y1" "" TRuleVariation210 +type TItem1360 = 'GItem TNonSpare2348 +type TVariation1382 = 'GGroup 0 '[ TItem1309, TItem1360] +type TVariation1531 = 'GRepetitive ('GRepetitiveRegular 1) TVariation1382 +type TRuleVariation1447 = 'GContextFree TVariation1531 +type TNonSpare186 = 'GNonSpare "050" "Sequence of Contour Points in SPF Notation" TRuleVariation1447 +type TUapItem186 = 'GUapItem TNonSpare186 +type TNonSpare274 = 'GNonSpare "090" "Time of Day" TRuleVariation376 +type TUapItem274 = 'GUapItem TNonSpare274 +type TVariation155 = 'GElement 0 5 TRuleContent637 +type TRuleVariation155 = 'GContextFree TVariation155 +type TNonSpare1042 = 'GNonSpare "F" "Scaling Factor" TRuleVariation155 +type TItem347 = 'GItem TNonSpare1042 +type TVariation919 = 'GElement 5 3 TRuleContent0 +type TRuleVariation888 = 'GContextFree TVariation919 +type TNonSpare1657 = 'GNonSpare "R" "Current Reduction Stage in Use" TRuleVariation888 +type TItem819 = 'GItem TNonSpare1657 +type TVariation265 = 'GElement 0 15 TRuleContent0 +type TRuleVariation257 = 'GContextFree TVariation265 +type TNonSpare1613 = 'GNonSpare "Q" "Processing Parameters" TRuleVariation257 +type TItem776 = 'GItem TNonSpare1613 +type TVariation1430 = 'GExtended '[ 'Just TItem347, 'Just TItem819, 'Just TItem776, 'Nothing] +type TRuleVariation1346 = 'GContextFree TVariation1430 +type TNonSpare290 = 'GNonSpare "100" "Processing Status" TRuleVariation1346 +type TUapItem290 = 'GUapItem TNonSpare290 +type TNonSpare308 = 'GNonSpare "110" "Station Configuration Status" TRuleVariation1449 +type TUapItem308 = 'GUapItem TNonSpare308 +type TVariation270 = 'GElement 0 16 TRuleContent638 +type TRuleVariation262 = 'GContextFree TVariation270 +type TNonSpare323 = 'GNonSpare "120" "Total Number of Items Constituting One Weather Picture" TRuleVariation262 +type TUapItem323 = 'GUapItem TNonSpare323 +type TNonSpare2295 = 'GNonSpare "X1" "X1-Component" TRuleVariation210 +type TItem1311 = 'GItem TNonSpare2295 +type TNonSpare2349 = 'GNonSpare "Y1" "Y1-Component" TRuleVariation210 +type TItem1361 = 'GItem TNonSpare2349 +type TNonSpare2299 = 'GNonSpare "X2" "X2-Component" TRuleVariation210 +type TItem1315 = 'GItem TNonSpare2299 +type TNonSpare2351 = 'GNonSpare "Y2" "Y2-Component" TRuleVariation210 +type TItem1363 = 'GItem TNonSpare2351 +type TVariation1383 = 'GGroup 0 '[ TItem1311, TItem1361, TItem1315, TItem1363] +type TVariation1532 = 'GRepetitive ('GRepetitiveRegular 1) TVariation1383 +type TRuleVariation1448 = 'GContextFree TVariation1532 +type TNonSpare140 = 'GNonSpare "038" "Sequence of Weather Vectors in SPF Notation" TRuleVariation1448 +type TUapItem140 = 'GUapItem TNonSpare140 +type TRecord22 = 'GRecord '[ TUapItem37, TUapItem8, TUapItem98, TUapItem138, TUapItem132, TUapItem142, TUapItem186, TUapItem274, TUapItem290, TUapItem308, TUapItem323, TUapItem140, TUapItem596, TUapItem599] +type TUap20 = 'GUap TRecord22 +type TAsterix9 = 'GAsterixBasic 8 ('GEdition 1 2) TUap20 +type TAsterix10 = 'GAsterixBasic 8 ('GEdition 1 3) TUap20 +type TContent632 = 'GContentTable '[ '(2, "Cartesian vector"), '(253, "Intermediate-update-step message"), '(254, "Start-of-picture message"), '(255, "End-of-picture message")] +type TRuleContent630 = 'GContextFree TContent632 +type TVariation215 = 'GElement 0 8 TRuleContent630 +type TRuleVariation207 = 'GContextFree TVariation215 +type TNonSpare16 = 'GNonSpare "000" "Message Type" TRuleVariation207 +type TUapItem16 = 'GUapItem TNonSpare16 +type TVariation1451 = 'GExtended '[ 'Just TItem714, 'Just TItem431, 'Just TItem914, 'Nothing] +type TRuleVariation1367 = 'GContextFree TVariation1451 +type TNonSpare97 = 'GNonSpare "020" "Vector Qualifier" TRuleVariation1367 +type TUapItem97 = 'GUapItem TNonSpare97 +type TVariation269 = 'GElement 0 16 TRuleContent637 +type TRuleVariation261 = 'GContextFree TVariation269 +type TNonSpare2290 = 'GNonSpare "X" "X-coordinate" TRuleVariation261 +type TItem1306 = 'GItem TNonSpare2290 +type TNonSpare2345 = 'GNonSpare "Y" "Y-coordinate" TRuleVariation261 +type TItem1357 = 'GItem TNonSpare2345 +type TNonSpare1225 = 'GNonSpare "L" "Vector Length" TRuleVariation262 +type TItem481 = 'GItem TNonSpare1225 +type TVariation1380 = 'GGroup 0 '[ TItem1306, TItem1357, TItem481] +type TVariation1530 = 'GRepetitive ('GRepetitiveRegular 1) TVariation1380 +type TRuleVariation1446 = 'GContextFree TVariation1530 +type TNonSpare110 = 'GNonSpare "030" "Sequence of Cartesian Vectors" TRuleVariation1446 +type TUapItem110 = 'GUapItem TNonSpare110 +type TVariation159 = 'GElement 0 6 TRuleContent638 +type TRuleVariation159 = 'GContextFree TVariation159 +type TNonSpare1885 = 'GNonSpare "SN" "Step Number" TRuleVariation159 +type TItem982 = 'GItem TNonSpare1885 +type TVariation1455 = 'GExtended '[ 'Just TItem982, 'Just TItem26, 'Nothing] +type TRuleVariation1371 = 'GContextFree TVariation1455 +type TNonSpare208 = 'GNonSpare "060" "Synchronisation/Control Signal" TRuleVariation1371 +type TUapItem208 = 'GUapItem TNonSpare208 +type TNonSpare232 = 'GNonSpare "070" "Time of Day" TRuleVariation376 +type TUapItem232 = 'GUapItem TNonSpare232 +type TNonSpare245 = 'GNonSpare "080" "Processing Status" TRuleVariation1346 +type TUapItem245 = 'GUapItem TNonSpare245 +type TNonSpare1794 = 'GNonSpare "SAC" "SAC of Radar Concerned" TRuleVariation171 +type TItem919 = 'GItem TNonSpare1794 +type TNonSpare1850 = 'GNonSpare "SIC" "SIC of Radar Concerned" TRuleVariation171 +type TItem950 = 'GItem TNonSpare1850 +type TNonSpare882 = 'GNonSpare "CP" "Circular Polarisation" TRuleVariation622 +type TItem222 = 'GItem TNonSpare882 +type TNonSpare2252 = 'GNonSpare "WO" "Weather Channel Overload" TRuleVariation712 +type TItem1271 = 'GItem TNonSpare2252 +type TNonSpare1659 = 'GNonSpare "R" "Reduction Step in Use By Radar Concerned" TRuleVariation888 +type TItem820 = 'GItem TNonSpare1659 +type TVariation1252 = 'GGroup 0 '[ TItem919, TItem950, TItem2, TItem222, TItem1271, TItem820] +type TVariation1507 = 'GRepetitive ('GRepetitiveRegular 1) TVariation1252 +type TRuleVariation1423 = 'GContextFree TVariation1507 +type TNonSpare272 = 'GNonSpare "090" "Radar Configuration and Status" TRuleVariation1423 +type TUapItem272 = 'GUapItem TNonSpare272 +type TNonSpare294 = 'GNonSpare "100" "Vector Count" TRuleVariation262 +type TUapItem294 = 'GUapItem TNonSpare294 +type TRecord23 = 'GRecord '[ TUapItem37, TUapItem16, TUapItem97, TUapItem110, TUapItem208, TUapItem232, TUapItem245, TUapItem272, TUapItem294] +type TUap21 = 'GUap TRecord23 +type TAsterix11 = 'GAsterixBasic 9 ('GEdition 2 1) TUap21 +type TNonSpare43 = 'GNonSpare "010" "Data Source Identifier" TRuleVariation1196 +type TUapItem43 = 'GUapItem TNonSpare43 +type TContent626 = 'GContentTable '[ '(1, "Target Report"), '(2, "Start of Update Cycle"), '(3, "Periodic Status Message"), '(4, "Event-triggered Status Message")] +type TRuleContent624 = 'GContextFree TContent626 +type TVariation212 = 'GElement 0 8 TRuleContent624 +type TRuleVariation204 = 'GContextFree TVariation212 +type TNonSpare13 = 'GNonSpare "000" "Message Type" TRuleVariation204 +type TUapItem13 = 'GUapItem TNonSpare13 +type TContent474 = 'GContentTable '[ '(0, "SSR multilateration"), '(1, "Mode S multilateration"), '(2, "ADS-B"), '(3, "PSR"), '(4, "Magnetic Loop System"), '(5, "HF multilateration"), '(6, "Not defined"), '(7, "Other types")] +type TRuleContent472 = 'GContextFree TContent474 +type TVariation139 = 'GElement 0 3 TRuleContent472 +type TRuleVariation139 = 'GContextFree TVariation139 +type TNonSpare2133 = 'GNonSpare "TYP" "" TRuleVariation139 +type TItem1163 = 'GItem TNonSpare2133 +type TContent368 = 'GContentTable '[ '(0, "No differential correction (ADS-B)"), '(1, "Differential correction (ADS-B)")] +type TRuleContent366 = 'GContextFree TContent368 +type TVariation672 = 'GElement 3 1 TRuleContent366 +type TRuleVariation660 = 'GContextFree TVariation672 +type TNonSpare944 = 'GNonSpare "DCR" "" TRuleVariation660 +type TItem270 = 'GItem TNonSpare944 +type TContent57 = 'GContentTable '[ '(0, "Chain 1"), '(1, "Chain 2")] +type TRuleContent57 = 'GContextFree TContent57 +type TVariation728 = 'GElement 4 1 TRuleContent57 +type TRuleVariation716 = 'GContextFree TVariation728 +type TNonSpare800 = 'GNonSpare "CHN" "" TRuleVariation716 +type TItem170 = 'GItem TNonSpare800 +type TContent547 = 'GContentTable '[ '(0, "Transponder Ground bit not set"), '(1, "Transponder Ground bit set")] +type TRuleContent545 = 'GContextFree TContent547 +type TVariation905 = 'GElement 5 1 TRuleContent545 +type TRuleVariation874 = 'GContextFree TVariation905 +type TNonSpare1106 = 'GNonSpare "GBS" "" TRuleVariation874 +type TItem389 = 'GItem TNonSpare1106 +type TContent318 = 'GContentTable '[ '(0, "No Corrupted reply in multilateration"), '(1, "Corrupted replies in multilateration")] +type TRuleContent316 = 'GContextFree TContent318 +type TVariation972 = 'GElement 6 1 TRuleContent316 +type TRuleVariation941 = 'GContextFree TVariation972 +type TNonSpare899 = 'GNonSpare "CRT" "" TRuleVariation941 +type TItem233 = 'GItem TNonSpare899 +type TVariation6 = 'GElement 0 1 TRuleContent23 +type TRuleVariation6 = 'GContextFree TVariation6 +type TNonSpare1868 = 'GNonSpare "SIM" "" TRuleVariation6 +type TItem966 = 'GItem TNonSpare1868 +type TContent160 = 'GContentTable '[ '(0, "Default"), '(1, "Test Target")] +type TRuleContent160 = 'GContextFree TContent160 +type TVariation433 = 'GElement 1 1 TRuleContent160 +type TRuleVariation421 = 'GContextFree TVariation433 +type TNonSpare2106 = 'GNonSpare "TST" "" TRuleVariation421 +type TItem1139 = 'GItem TNonSpare2106 +type TContent465 = 'GContentTable '[ '(0, "Report from target transponder"), '(1, "Report from field monitor (fixed transponder)")] +type TRuleContent463 = 'GContextFree TContent465 +type TVariation592 = 'GElement 2 1 TRuleContent463 +type TRuleVariation580 = 'GContextFree TVariation592 +type TNonSpare1663 = 'GNonSpare "RAB" "" TRuleVariation580 +type TItem823 = 'GItem TNonSpare1663 +type TContent559 = 'GContentTable '[ '(0, "Undetermined"), '(1, "Loop start"), '(2, "Loop finish")] +type TRuleContent557 = 'GContextFree TContent559 +type TVariation705 = 'GElement 3 2 TRuleContent557 +type TRuleVariation693 = 'GContextFree TVariation705 +type TNonSpare1278 = 'GNonSpare "LOP" "" TRuleVariation693 +type TItem532 = 'GItem TNonSpare1278 +type TContent558 = 'GContentTable '[ '(0, "Undetermined"), '(1, "Aircraft"), '(2, "Ground vehicle"), '(3, "Helicopter")] +type TRuleContent556 = 'GContextFree TContent558 +type TVariation917 = 'GElement 5 2 TRuleContent556 +type TRuleVariation886 = 'GContextFree TVariation917 +type TNonSpare2056 = 'GNonSpare "TOT" "" TRuleVariation886 +type TItem1096 = 'GItem TNonSpare2056 +type TVariation4 = 'GElement 0 1 TRuleContent15 +type TRuleVariation4 = 'GContextFree TVariation4 +type TNonSpare1893 = 'GNonSpare "SPI" "" TRuleVariation4 +type TItem987 = 'GItem TNonSpare1893 +type TVariation1467 = 'GExtended '[ 'Just TItem1163, 'Just TItem270, 'Just TItem170, 'Just TItem389, 'Just TItem233, 'Nothing, 'Just TItem966, 'Just TItem1139, 'Just TItem823, 'Just TItem532, 'Just TItem1096, 'Nothing, 'Just TItem987, 'Just TItem9, 'Nothing] +type TRuleVariation1383 = 'GContextFree TVariation1467 +type TNonSpare92 = 'GNonSpare "020" "Target Report Descriptor" TRuleVariation1383 +type TUapItem92 = 'GUapItem TNonSpare92 +type TNonSpare353 = 'GNonSpare "140" "Time of Day" TRuleVariation376 +type TUapItem353 = 'GUapItem TNonSpare353 +type TContent733 = 'GContentQuantity 'GSigned ('GNumDiv ('GNumInt ('GZ 'GPlus 180)) ('GNumPow ('GZ 'GPlus 2) ('GZ 'GPlus 31))) "°" +type TRuleContent731 = 'GContextFree TContent733 +type TVariation397 = 'GElement 0 32 TRuleContent731 +type TRuleVariation389 = 'GContextFree TVariation397 +type TNonSpare1234 = 'GNonSpare "LAT" "Latitude" TRuleVariation389 +type TItem490 = 'GItem TNonSpare1234 +type TContent731 = 'GContentQuantity 'GSigned ('GNumDiv ('GNumInt ('GZ 'GPlus 180)) ('GNumPow ('GZ 'GPlus 2) ('GZ 'GPlus 31))) "°" +type TRuleContent729 = 'GContextFree TContent731 +type TVariation395 = 'GElement 0 32 TRuleContent729 +type TRuleVariation387 = 'GContextFree TVariation395 +type TNonSpare1267 = 'GNonSpare "LON" "Longitude" TRuleVariation387 +type TItem521 = 'GItem TNonSpare1267 +type TVariation1186 = 'GGroup 0 '[ TItem490, TItem521] +type TRuleVariation1137 = 'GContextFree TVariation1186 +type TNonSpare161 = 'GNonSpare "041" "Position in WGS-84 Co-ordinates" TRuleVariation1137 +type TUapItem161 = 'GUapItem TNonSpare161 +type TContent749 = 'GContentQuantity 'GUnsigned ('GNumInt ('GZ 'GPlus 1)) "m" +type TRuleContent747 = 'GContextFree TContent749 +type TVariation319 = 'GElement 0 16 TRuleContent747 +type TRuleVariation311 = 'GContextFree TVariation319 +type TNonSpare1727 = 'GNonSpare "RHO" "RHO" TRuleVariation311 +type TItem878 = 'GItem TNonSpare1727 +type TNonSpare2020 = 'GNonSpare "TH" "Theta" TRuleVariation349 +type TItem1076 = 'GItem TNonSpare2020 +type TVariation1241 = 'GGroup 0 '[ TItem878, TItem1076] +type TRuleVariation1187 = 'GContextFree TVariation1241 +type TNonSpare146 = 'GNonSpare "040" "Measured Position in Polar Co-ordinates" TRuleVariation1187 +type TUapItem146 = 'GUapItem TNonSpare146 +type TContent654 = 'GContentQuantity 'GSigned ('GNumInt ('GZ 'GPlus 1)) "m" +type TRuleContent652 = 'GContextFree TContent654 +type TVariation273 = 'GElement 0 16 TRuleContent652 +type TRuleVariation265 = 'GContextFree TVariation273 +type TNonSpare2284 = 'GNonSpare "X" "X Coordinate" TRuleVariation265 +type TItem1300 = 'GItem TNonSpare2284 +type TNonSpare2339 = 'GNonSpare "Y" "Y Coordinate" TRuleVariation265 +type TItem1351 = 'GItem TNonSpare2339 +type TVariation1373 = 'GGroup 0 '[ TItem1300, TItem1351] +type TRuleVariation1296 = 'GContextFree TVariation1373 +type TNonSpare168 = 'GNonSpare "042" "Position in Cartesian Co-ordinates" TRuleVariation1296 +type TUapItem168 = 'GUapItem TNonSpare168 +type TContent810 = 'GContentQuantity 'GUnsigned ('GNumDiv ('GNumInt ('GZ 'GPlus 1)) ('GNumPow ('GZ 'GPlus 2) ('GZ 'GPlus 14))) "NM/s" +type TRuleContent807 = 'GContextFree TContent810 +type TVariation353 = 'GElement 0 16 TRuleContent807 +type TRuleVariation345 = 'GContextFree TVariation353 +type TNonSpare1120 = 'GNonSpare "GSP" "Ground Speed" TRuleVariation345 +type TItem398 = 'GItem TNonSpare1120 +type TNonSpare2070 = 'GNonSpare "TRA" "Track Angle" TRuleVariation349 +type TItem1109 = 'GItem TNonSpare2070 +type TVariation1171 = 'GGroup 0 '[ TItem398, TItem1109] +type TRuleVariation1124 = 'GContextFree TVariation1171 +type TNonSpare416 = 'GNonSpare "200" "Calculated Track Velocity in Polar Co-ordinates" TRuleVariation1124 +type TUapItem416 = 'GUapItem TNonSpare416 +type TContent697 = 'GContentQuantity 'GSigned ('GNumDiv ('GNumInt ('GZ 'GPlus 1)) ('GNumPow ('GZ 'GPlus 2) ('GZ 'GPlus 4))) "m/s" +type TRuleContent695 = 'GContextFree TContent697 +type TVariation296 = 'GElement 0 16 TRuleContent695 +type TRuleVariation288 = 'GContextFree TVariation296 +type TNonSpare2241 = 'GNonSpare "VX" "X Velocity" TRuleVariation288 +type TItem1262 = 'GItem TNonSpare2241 +type TNonSpare2246 = 'GNonSpare "VY" "Y Velocity" TRuleVariation288 +type TItem1267 = 'GItem TNonSpare2246 +type TVariation1347 = 'GGroup 0 '[ TItem1262, TItem1267] +type TRuleVariation1271 = 'GContextFree TVariation1347 +type TNonSpare430 = 'GNonSpare "202" "Calculated Track Velocity in Cartesian Co-ordinates" TRuleVariation1271 +type TUapItem430 = 'GUapItem TNonSpare430 +type TNonSpare2089 = 'GNonSpare "TRK" "Track Number" TRuleVariation806 +type TItem1124 = 'GItem TNonSpare2089 +type TVariation1076 = 'GGroup 0 '[ TItem3, TItem1124] +type TRuleVariation1043 = 'GContextFree TVariation1076 +type TNonSpare385 = 'GNonSpare "161" "Track Number" TRuleVariation1043 +type TUapItem385 = 'GUapItem TNonSpare385 +type TContent68 = 'GContentTable '[ '(0, "Confirmed track"), '(1, "Track in initialisation phase")] +type TRuleContent68 = 'GContextFree TContent68 +type TVariation19 = 'GElement 0 1 TRuleContent68 +type TRuleVariation19 = 'GContextFree TVariation19 +type TNonSpare814 = 'GNonSpare "CNF" "" TRuleVariation19 +type TItem180 = 'GItem TNonSpare814 +type TVariation425 = 'GElement 1 1 TRuleContent117 +type TRuleVariation413 = 'GContextFree TVariation425 +type TNonSpare2084 = 'GNonSpare "TRE" "" TRuleVariation413 +type TItem1121 = 'GItem TNonSpare2084 +type TContent377 = 'GContentTable '[ '(0, "No extrapolation"), '(1, "Predictable extrapolation due to sensor refresh period (see NOTE)"), '(2, "Predictable extrapolation in masked area"), '(3, "Extrapolation due to unpredictable absence of detection")] +type TRuleContent375 = 'GContextFree TContent377 +type TVariation612 = 'GElement 2 2 TRuleContent375 +type TRuleVariation600 = 'GContextFree TVariation612 +type TNonSpare910 = 'GNonSpare "CST" "" TRuleVariation600 +type TItem241 = 'GItem TNonSpare910 +type TContent110 = 'GContentTable '[ '(0, "Default"), '(1, "Horizontal manoeuvre")] +type TRuleContent110 = 'GContextFree TContent110 +type TVariation731 = 'GElement 4 1 TRuleContent110 +type TRuleVariation719 = 'GContextFree TVariation731 +type TNonSpare1322 = 'GNonSpare "MAH" "" TRuleVariation719 +type TItem564 = 'GItem TNonSpare1322 +type TContent540 = 'GContentTable '[ '(0, "Tracking performed in 'Sensor Plane', i.e. neither slant range correction nor projection was applied"), '(1, "Slant range correction and a suitable projection technique are used to track in a 2D.reference plane, tangential to the earth model at the Sensor Site co-ordinates")] +type TRuleContent538 = 'GContextFree TContent540 +type TVariation904 = 'GElement 5 1 TRuleContent538 +type TRuleVariation873 = 'GContextFree TVariation904 +type TNonSpare2004 = 'GNonSpare "TCC" "" TRuleVariation873 +type TItem1061 = 'GItem TNonSpare2004 +type TContent278 = 'GContentTable '[ '(0, "Measured position"), '(1, "Smoothed position")] +type TRuleContent276 = 'GContextFree TContent278 +type TVariation968 = 'GElement 6 1 TRuleContent276 +type TRuleVariation937 = 'GContextFree TVariation968 +type TNonSpare1951 = 'GNonSpare "STH" "" TRuleVariation937 +type TItem1030 = 'GItem TNonSpare1951 +type TContent580 = 'GContentTable '[ '(0, "Unknown type of movement"), '(1, "Taking-off"), '(2, "Landing"), '(3, "Other types of movement")] +type TRuleContent578 = 'GContextFree TContent580 +type TVariation123 = 'GElement 0 2 TRuleContent578 +type TRuleVariation123 = 'GContextFree TVariation123 +type TNonSpare2051 = 'GNonSpare "TOM" "" TRuleVariation123 +type TItem1094 = 'GItem TNonSpare2051 +type TContent369 = 'GContentTable '[ '(0, "No doubt"), '(1, "Doubtful correlation (undetermined reason)"), '(2, "Doubtful correlation in clutter"), '(3, "Loss of accuracy"), '(4, "Loss of accuracy in clutter"), '(5, "Unstable track"), '(6, "Previously coasted")] +type TRuleContent367 = 'GContextFree TContent369 +type TVariation618 = 'GElement 2 3 TRuleContent367 +type TRuleVariation606 = 'GContextFree TVariation618 +type TNonSpare962 = 'GNonSpare "DOU" "" TRuleVariation606 +type TItem285 = 'GItem TNonSpare962 +type TContent279 = 'GContentTable '[ '(0, "Merge or split indication undetermined"), '(1, "Track merged by association to plot"), '(2, "Track merged by non-association to plot"), '(3, "Split track")] +type TRuleContent277 = 'GContextFree TContent279 +type TVariation909 = 'GElement 5 2 TRuleContent277 +type TRuleVariation878 = 'GContextFree TVariation909 +type TNonSpare1426 = 'GNonSpare "MRS" "" TRuleVariation878 +type TItem630 = 'GItem TNonSpare1426 +type TVariation29 = 'GElement 0 1 TRuleContent104 +type TRuleVariation29 = 'GContextFree TVariation29 +type TNonSpare1113 = 'GNonSpare "GHO" "" TRuleVariation29 +type TItem392 = 'GItem TNonSpare1113 +type TVariation1420 = 'GExtended '[ 'Just TItem180, 'Just TItem1121, 'Just TItem241, 'Just TItem564, 'Just TItem1061, 'Just TItem1030, 'Nothing, 'Just TItem1094, 'Just TItem285, 'Just TItem630, 'Nothing, 'Just TItem392, 'Just TItem9, 'Nothing] +type TRuleVariation1336 = 'GContextFree TVariation1420 +type TNonSpare397 = 'GNonSpare "170" "Track Status" TRuleVariation1336 +type TUapItem397 = 'GUapItem TNonSpare397 +type TNonSpare2165 = 'GNonSpare "V" "Validated" TRuleVariation16 +type TItem1192 = 'GItem TNonSpare2165 +type TNonSpare1086 = 'GNonSpare "G" "Garbled" TRuleVariation409 +type TItem379 = 'GItem TNonSpare1086 +type TVariation1339 = 'GGroup 0 '[ TItem1192, TItem379, TItem477, TItem16, TItem622] +type TRuleVariation1263 = 'GContextFree TVariation1339 +type TNonSpare200 = 'GNonSpare "060" "Mode-3/A Code in Octal Representation" TRuleVariation1263 +type TUapItem200 = 'GUapItem TNonSpare200 +type TNonSpare454 = 'GNonSpare "220" "Target Address" TRuleVariation355 +type TUapItem454 = 'GUapItem TNonSpare454 +type TContent55 = 'GContentTable '[ '(0, "Callsign or registration downlinked from transponder"), '(1, "Callsign not downlinked from transponder"), '(2, "Registration not downlinked from transponder")] +type TRuleContent55 = 'GContextFree TContent55 +type TVariation102 = 'GElement 0 2 TRuleContent55 +type TRuleVariation102 = 'GContextFree TVariation102 +type TNonSpare1953 = 'GNonSpare "STI" "" TRuleVariation102 +type TItem1032 = 'GItem TNonSpare1953 +type TItem15 = 'GSpare 2 6 +type TNonSpare801 = 'GNonSpare "CHR" "Characters 1-8 (Coded on 6 Bits Each) Defining Target Identification" TRuleVariation396 +type TItem171 = 'GItem TNonSpare801 +type TVariation1278 = 'GGroup 0 '[ TItem1032, TItem15, TItem171] +type TRuleVariation1217 = 'GContextFree TVariation1278 +type TNonSpare473 = 'GNonSpare "245" "Target Identification" TRuleVariation1217 +type TUapItem473 = 'GUapItem TNonSpare473 +type TNonSpare1336 = 'GNonSpare "MBDATA" "" TRuleVariation397 +type TItem573 = 'GItem TNonSpare1336 +type TNonSpare728 = 'GNonSpare "BDS1" "" TRuleVariation140 +type TItem118 = 'GItem TNonSpare728 +type TNonSpare731 = 'GNonSpare "BDS2" "" TRuleVariation796 +type TItem121 = 'GItem TNonSpare731 +type TVariation1200 = 'GGroup 0 '[ TItem573, TItem118, TItem121] +type TVariation1500 = 'GRepetitive ('GRepetitiveRegular 1) TVariation1200 +type TRuleVariation1416 = 'GContextFree TVariation1500 +type TNonSpare481 = 'GNonSpare "250" "Mode S MB Data" TRuleVariation1416 +type TUapItem481 = 'GUapItem TNonSpare481 +type TContent563 = 'GContentTable '[ '(0, "Unknown"), '(1, "ATC equipment maintenance"), '(2, "Airport maintenance"), '(3, "Fire"), '(4, "Bird scarer"), '(5, "Snow plough"), '(6, "Runway sweeper"), '(7, "Emergency"), '(8, "Police"), '(9, "Bus"), '(10, "Tug (push/tow)"), '(11, "Grass cutter"), '(12, "Fuel"), '(13, "Baggage"), '(14, "Catering"), '(15, "Aircraft maintenance"), '(16, "Flyco (follow me)")] +type TRuleContent561 = 'GContextFree TContent563 +type TVariation191 = 'GElement 0 8 TRuleContent561 +type TRuleVariation183 = 'GContextFree TVariation191 +type TNonSpare517 = 'GNonSpare "300" "Vehicle Fleet Identification" TRuleVariation183 +type TUapItem517 = 'GUapItem TNonSpare517 +type TVariation1335 = 'GGroup 0 '[ TItem1192, TItem379, TItem353] +type TRuleVariation1259 = 'GContextFree TVariation1335 +type TNonSpare264 = 'GNonSpare "090" "Flight Level in Binary Representation" TRuleVariation1259 +type TUapItem264 = 'GUapItem TNonSpare264 +type TContent713 = 'GContentQuantity 'GSigned ('GNumDiv ('GNumInt ('GZ 'GPlus 25)) ('GNumPow ('GZ 'GPlus 2) ('GZ 'GPlus 2))) "ft" +type TRuleContent711 = 'GContextFree TContent713 +type TVariation304 = 'GElement 0 16 TRuleContent711 +type TRuleVariation296 = 'GContextFree TVariation304 +type TNonSpare275 = 'GNonSpare "091" "Measured Height" TRuleVariation296 +type TUapItem275 = 'GUapItem TNonSpare275 +type TContent747 = 'GContentQuantity 'GUnsigned ('GNumInt ('GZ 'GPlus 1)) "m" +type TRuleContent745 = 'GContextFree TContent747 +type TVariation172 = 'GElement 0 7 TRuleContent745 +type TRuleVariation165 = 'GContextFree TVariation172 +type TNonSpare1249 = 'GNonSpare "LENGTH" "Length" TRuleVariation165 +type TItem503 = 'GItem TNonSpare1249 +type TContent820 = 'GContentQuantity 'GUnsigned ('GNumDiv ('GNumInt ('GZ 'GPlus 360)) ('GNumPow ('GZ 'GPlus 2) ('GZ 'GPlus 7))) "°" +type TRuleContent817 = 'GContextFree TContent820 +type TVariation177 = 'GElement 0 7 TRuleContent817 +type TRuleVariation170 = 'GContextFree TVariation177 +type TNonSpare1520 = 'GNonSpare "ORIENTATION" "Orientation" TRuleVariation170 +type TItem715 = 'GItem TNonSpare1520 +type TNonSpare2251 = 'GNonSpare "WIDTH" "Width" TRuleVariation165 +type TItem1270 = 'GItem TNonSpare2251 +type TVariation1434 = 'GExtended '[ 'Just TItem503, 'Nothing, 'Just TItem715, 'Nothing, 'Just TItem1270, 'Nothing] +type TRuleVariation1350 = 'GContextFree TVariation1434 +type TNonSpare497 = 'GNonSpare "270" "Target Size and Orientation" TRuleVariation1350 +type TUapItem497 = 'GUapItem TNonSpare497 +type TContent433 = 'GContentTable '[ '(0, "Operational"), '(1, "Degraded"), '(2, "NOGO")] +type TRuleContent431 = 'GContextFree TContent433 +type TVariation113 = 'GElement 0 2 TRuleContent431 +type TRuleVariation113 = 'GContextFree TVariation113 +type TNonSpare1486 = 'GNonSpare "NOGO" "Operational Release Status of the System" TRuleVariation113 +type TItem682 = 'GItem TNonSpare1486 +type TContent387 = 'GContentTable '[ '(0, "No overload"), '(1, "Overload")] +type TRuleContent385 = 'GContextFree TContent387 +type TVariation582 = 'GElement 2 1 TRuleContent385 +type TRuleVariation570 = 'GContextFree TVariation582 +type TNonSpare1527 = 'GNonSpare "OVL" "Overload Indicator" TRuleVariation570 +type TItem721 = 'GItem TNonSpare1527 +type TContent585 = 'GContentTable '[ '(0, "Valid"), '(1, "Invalid")] +type TRuleContent583 = 'GContextFree TContent585 +type TVariation695 = 'GElement 3 1 TRuleContent583 +type TRuleVariation683 = 'GContextFree TVariation695 +type TNonSpare2112 = 'GNonSpare "TSV" "Time Source Validity" TRuleVariation683 +type TItem1145 = 'GItem TNonSpare2112 +type TContent402 = 'GContentTable '[ '(0, "Normal Operation"), '(1, "Diversity degraded")] +type TRuleContent400 = 'GContextFree TContent402 +type TVariation768 = 'GElement 4 1 TRuleContent400 +type TRuleVariation756 = 'GContextFree TVariation768 +type TNonSpare954 = 'GNonSpare "DIV" "" TRuleVariation756 +type TItem279 = 'GItem TNonSpare954 +type TContent511 = 'GContentTable '[ '(0, "Test Target Operative"), '(1, "Test Target Failure")] +type TRuleContent509 = 'GContextFree TContent511 +type TVariation902 = 'GElement 5 1 TRuleContent509 +type TRuleVariation871 = 'GContextFree TVariation902 +type TNonSpare2119 = 'GNonSpare "TTF" "" TRuleVariation871 +type TItem1150 = 'GItem TNonSpare2119 +type TVariation1212 = 'GGroup 0 '[ TItem682, TItem721, TItem1145, TItem279, TItem1150, TItem27] +type TRuleVariation1160 = 'GContextFree TVariation1212 +type TNonSpare571 = 'GNonSpare "550" "System Status" TRuleVariation1160 +type TUapItem569 = 'GUapItem TNonSpare571 +type TContent114 = 'GContentTable '[ '(0, "Default"), '(1, "In Trouble")] +type TRuleContent114 = 'GContextFree TContent114 +type TVariation31 = 'GElement 0 1 TRuleContent114 +type TRuleVariation31 = 'GContextFree TVariation31 +type TNonSpare2077 = 'GNonSpare "TRB" "" TRuleVariation31 +type TItem1116 = 'GItem TNonSpare2077 +type TContent629 = 'GContentTable '[ '(1, "Towing aircraft"), '(2, "“Follow me” operation"), '(3, "Runway check"), '(4, "Emergency operation (fire, medical...)"), '(5, "Work in progress (maintenance, birds scarer, sweepers...)")] +type TRuleContent627 = 'GContextFree TContent629 +type TVariation513 = 'GElement 1 7 TRuleContent627 +type TRuleVariation501 = 'GContextFree TVariation513 +type TNonSpare1441 = 'GNonSpare "MSG" "" TRuleVariation501 +type TItem642 = 'GItem TNonSpare1441 +type TVariation1294 = 'GGroup 0 '[ TItem1116, TItem642] +type TRuleVariation1227 = 'GContextFree TVariation1294 +type TNonSpare519 = 'GNonSpare "310" "Pre-programmed Message" TRuleVariation1227 +type TUapItem519 = 'GUapItem TNonSpare519 +type TContent785 = 'GContentQuantity 'GUnsigned ('GNumDiv ('GNumInt ('GZ 'GPlus 1)) ('GNumPow ('GZ 'GPlus 2) ('GZ 'GPlus 2))) "m" +type TRuleContent782 = 'GContextFree TContent785 +type TVariation246 = 'GElement 0 8 TRuleContent782 +type TRuleVariation238 = 'GContextFree TVariation246 +type TNonSpare949 = 'GNonSpare "DEVX" "Standard Deviation of X Component" TRuleVariation238 +type TItem274 = 'GItem TNonSpare949 +type TNonSpare950 = 'GNonSpare "DEVY" "Standard Deviation of Y Component" TRuleVariation238 +type TItem275 = 'GItem TNonSpare950 +type TContent686 = 'GContentQuantity 'GSigned ('GNumDiv ('GNumInt ('GZ 'GPlus 1)) ('GNumPow ('GZ 'GPlus 2) ('GZ 'GPlus 2))) "m" +type TRuleContent684 = 'GContextFree TContent686 +type TVariation289 = 'GElement 0 16 TRuleContent684 +type TRuleVariation281 = 'GContextFree TVariation289 +type TNonSpare881 = 'GNonSpare "COVXY" "Covariance in Two’s Complement Form" TRuleVariation281 +type TItem221 = 'GItem TNonSpare881 +type TVariation1135 = 'GGroup 0 '[ TItem274, TItem275, TItem221] +type TRuleVariation1090 = 'GContextFree TVariation1135 +type TNonSpare566 = 'GNonSpare "500" "Standard Deviation of Position" TRuleVariation1090 +type TUapItem564 = 'GUapItem TNonSpare566 +type TContent655 = 'GContentQuantity 'GSigned ('GNumInt ('GZ 'GPlus 1)) "m" +type TRuleContent653 = 'GContextFree TContent655 +type TVariation224 = 'GElement 0 8 TRuleContent653 +type TRuleVariation216 = 'GContextFree TVariation224 +type TNonSpare967 = 'GNonSpare "DRHO" "" TRuleVariation216 +type TItem288 = 'GItem TNonSpare967 +type TContent712 = 'GContentQuantity 'GSigned ('GNumDiv ('GNumInt ('GZ 'GPlus 3)) ('GNumInt ('GZ 'GPlus 20))) "°" +type TRuleContent710 = 'GContextFree TContent712 +type TVariation233 = 'GElement 0 8 TRuleContent710 +type TRuleVariation225 = 'GContextFree TVariation233 +type TNonSpare978 = 'GNonSpare "DTHETA" "" TRuleVariation225 +type TItem296 = 'GItem TNonSpare978 +type TVariation1137 = 'GGroup 0 '[ TItem288, TItem296] +type TVariation1497 = 'GRepetitive ('GRepetitiveRegular 1) TVariation1137 +type TRuleVariation1413 = 'GContextFree TVariation1497 +type TNonSpare505 = 'GNonSpare "280" "Presence" TRuleVariation1413 +type TUapItem505 = 'GUapItem TNonSpare505 +type TNonSpare334 = 'GNonSpare "131" "Amplitude of Primary Plot" TRuleVariation171 +type TUapItem334 = 'GUapItem TNonSpare334 +type TContent699 = 'GContentQuantity 'GSigned ('GNumDiv ('GNumInt ('GZ 'GPlus 1)) ('GNumPow ('GZ 'GPlus 2) ('GZ 'GPlus 4))) "m/s²" +type TRuleContent697 = 'GContextFree TContent699 +type TVariation227 = 'GElement 0 8 TRuleContent697 +type TRuleVariation219 = 'GContextFree TVariation227 +type TNonSpare711 = 'GNonSpare "AX" "X Acceleration" TRuleVariation219 +type TItem104 = 'GItem TNonSpare711 +type TNonSpare715 = 'GNonSpare "AY" "Y Acceleration" TRuleVariation219 +type TItem108 = 'GItem TNonSpare715 +type TVariation1102 = 'GGroup 0 '[ TItem104, TItem108] +type TRuleVariation1068 = 'GContextFree TVariation1102 +type TNonSpare435 = 'GNonSpare "210" "Calculated Acceleration" TRuleVariation1068 +type TUapItem435 = 'GUapItem TNonSpare435 +type TRecord44 = 'GRecord '[ TUapItem43, TUapItem13, TUapItem92, TUapItem353, TUapItem161, TUapItem146, TUapItem168, TUapItem416, TUapItem430, TUapItem385, TUapItem397, TUapItem200, TUapItem454, TUapItem473, TUapItem481, TUapItem517, TUapItem264, TUapItem275, TUapItem497, TUapItem569, TUapItem519, TUapItem564, TUapItem505, TUapItem334, TUapItem435, TUapItem598, TUapItem596, TUapItem594] +type TUap38 = 'GUap TRecord44 +type TAsterix12 = 'GAsterixBasic 10 ('GEdition 1 1) TUap38 +type TNonSpare1796 = 'GNonSpare "SAC" "System Area Code Fixed to Zero" TRuleVariation171 +type TItem921 = 'GItem TNonSpare1796 +type TVariation1257 = 'GGroup 0 '[ TItem921, TItem951] +type TRuleVariation1198 = 'GContextFree TVariation1257 +type TNonSpare48 = 'GNonSpare "010" "Data Source Identifier" TRuleVariation1198 +type TUapItem48 = 'GUapItem TNonSpare48 +type TContent627 = 'GContentTable '[ '(1, "Target reports, flight plan data and basic alerts"), '(2, "Manual attachment of flight plan to track"), '(3, "Manual detachment of flight plan to track"), '(4, "Insertion of flight plan data"), '(5, "Suppression of flight plan data"), '(6, "Modification of flight plan data"), '(7, "Holdbar status")] +type TRuleContent625 = 'GContextFree TContent627 +type TVariation213 = 'GElement 0 8 TRuleContent625 +type TRuleVariation205 = 'GContextFree TVariation213 +type TNonSpare14 = 'GNonSpare "000" "Message Type" TRuleVariation205 +type TUapItem14 = 'GUapItem TNonSpare14 +type TNonSpare62 = 'GNonSpare "015" "Service Identification" TRuleVariation171 +type TUapItem62 = 'GUapItem TNonSpare62 +type TNonSpare358 = 'GNonSpare "140" "Time of Track Information" TRuleVariation376 +type TUapItem358 = 'GUapItem TNonSpare358 +type TNonSpare1239 = 'GNonSpare "LAT" "Latitude in WGS-84 in Two's Complement" TRuleVariation389 +type TItem495 = 'GItem TNonSpare1239 +type TNonSpare1272 = 'GNonSpare "LON" "Longitude in WGS-84 in Two's Complement" TRuleVariation387 +type TItem526 = 'GItem TNonSpare1272 +type TVariation1191 = 'GGroup 0 '[ TItem495, TItem526] +type TRuleVariation1142 = 'GContextFree TVariation1191 +type TNonSpare162 = 'GNonSpare "041" "Position in WGS-84 Coordinates" TRuleVariation1142 +type TUapItem162 = 'GUapItem TNonSpare162 +type TNonSpare2287 = 'GNonSpare "X" "X-Component" TRuleVariation265 +type TItem1303 = 'GItem TNonSpare2287 +type TNonSpare2342 = 'GNonSpare "Y" "Y-Component" TRuleVariation265 +type TItem1354 = 'GItem TNonSpare2342 +type TVariation1376 = 'GGroup 0 '[ TItem1303, TItem1354] +type TRuleVariation1298 = 'GContextFree TVariation1376 +type TNonSpare164 = 'GNonSpare "042" "Calculated Position in Cartesian Co-ordinates" TRuleVariation1298 +type TUapItem164 = 'GUapItem TNonSpare164 +type TContent690 = 'GContentQuantity 'GSigned ('GNumDiv ('GNumInt ('GZ 'GPlus 1)) ('GNumPow ('GZ 'GPlus 2) ('GZ 'GPlus 2))) "m/s" +type TRuleContent688 = 'GContextFree TContent690 +type TVariation293 = 'GElement 0 16 TRuleContent688 +type TRuleVariation285 = 'GContextFree TVariation293 +type TNonSpare2240 = 'GNonSpare "VX" "Vx" TRuleVariation285 +type TItem1261 = 'GItem TNonSpare2240 +type TNonSpare2245 = 'GNonSpare "VY" "Vy" TRuleVariation285 +type TItem1266 = 'GItem TNonSpare2245 +type TVariation1346 = 'GGroup 0 '[ TItem1261, TItem1266] +type TRuleVariation1270 = 'GContextFree TVariation1346 +type TNonSpare432 = 'GNonSpare "202" "Calculated Track Velocity in Cartesian Coordinates" TRuleVariation1270 +type TUapItem432 = 'GUapItem TNonSpare432 +type TContent693 = 'GContentQuantity 'GSigned ('GNumDiv ('GNumInt ('GZ 'GPlus 1)) ('GNumPow ('GZ 'GPlus 2) ('GZ 'GPlus 2))) "m/s²" +type TRuleContent691 = 'GContextFree TContent693 +type TVariation226 = 'GElement 0 8 TRuleContent691 +type TRuleVariation218 = 'GContextFree TVariation226 +type TNonSpare710 = 'GNonSpare "AX" "Ax" TRuleVariation218 +type TItem103 = 'GItem TNonSpare710 +type TNonSpare714 = 'GNonSpare "AY" "Ay" TRuleVariation218 +type TItem107 = 'GItem TNonSpare714 +type TVariation1101 = 'GGroup 0 '[ TItem103, TItem107] +type TRuleVariation1067 = 'GContextFree TVariation1101 +type TNonSpare434 = 'GNonSpare "210" "Calculated Acceleration" TRuleVariation1067 +type TUapItem434 = 'GUapItem TNonSpare434 +type TNonSpare1408 = 'GNonSpare "MOD3A" "Mode-3/A Reply in Octal Representation" TRuleVariation807 +type TItem612 = 'GItem TNonSpare1408 +type TVariation1064 = 'GGroup 0 '[ TItem3, TItem612] +type TRuleVariation1032 = 'GContextFree TVariation1064 +type TNonSpare199 = 'GNonSpare "060" "Mode-3/A Code in Octal Representation" TRuleVariation1032 +type TUapItem199 = 'GUapItem TNonSpare199 +type TNonSpare2029 = 'GNonSpare "TID" "Target Identification" TRuleVariation396 +type TItem1083 = 'GItem TNonSpare2029 +type TVariation1279 = 'GGroup 0 '[ TItem1032, TItem15, TItem1083] +type TRuleVariation1218 = 'GContextFree TVariation1279 +type TNonSpare474 = 'GNonSpare "245" "Target Identification" TRuleVariation1218 +type TUapItem474 = 'GUapItem TNonSpare474 +type TContent829 = 'GContentBds 'GBdsWithAddress +type TRuleContent826 = 'GContextFree TContent829 +type TVariation410 = 'GElement 0 64 TRuleContent826 +type TVariation1479 = 'GRepetitive ('GRepetitiveRegular 1) TVariation410 +type TRuleVariation1395 = 'GContextFree TVariation1479 +type TNonSpare1330 = 'GNonSpare "MB" "BDS" TRuleVariation1395 +type TNonSpare622 = 'GNonSpare "ADR" "24 Bits Aircraft Address" TRuleVariation355 +type TContent355 = 'GContentTable '[ '(0, "No communications capability (surveillance only)"), '(1, "Comm. A and Comm. B capability"), '(2, "Comm. A, Comm. B and Uplink ELM"), '(3, "Comm. A, Comm. B, Uplink ELM and Downlink ELM"), '(4, "Level 5 Transponder capability"), '(5, "Not assigned"), '(6, "Not assigned"), '(7, "Not assigned")] +type TRuleContent353 = 'GContextFree TContent355 +type TVariation132 = 'GElement 0 3 TRuleContent353 +type TRuleVariation132 = 'GContextFree TVariation132 +type TNonSpare853 = 'GNonSpare "COM" "Communications Capability of the Transponder" TRuleVariation132 +type TItem204 = 'GItem TNonSpare853 +type TContent334 = 'GContentTable '[ '(0, "No alert, no SPI, aircraft airborne"), '(1, "No alert, no SPI, aircraft on ground"), '(2, "Alert, no SPI, aircraft airborne"), '(3, "Alert, no SPI, aircraft on ground"), '(4, "Alert, SPI, aircraft airborne or on ground"), '(5, "No alert, SPI, aircraft airborne or on ground"), '(6, "General Emergency"), '(7, "Lifeguard / medical"), '(8, "Minimum fuel"), '(9, "No communications"), '(10, "Unlawful")] +type TRuleContent332 = 'GContextFree TContent334 +type TVariation717 = 'GElement 3 4 TRuleContent332 +type TRuleVariation705 = 'GContextFree TVariation717 +type TNonSpare1941 = 'GNonSpare "STAT" "Flight Status" TRuleVariation705 +type TItem1021 = 'GItem TNonSpare1941 +type TNonSpare1917 = 'GNonSpare "SSC" "Specific Service Capability" TRuleVariation58 +type TItem1006 = 'GItem TNonSpare1917 +type TNonSpare723 = 'GNonSpare "B1B" "BDS 1,0 Bit 37/40" TRuleVariation796 +type TItem113 = 'GItem TNonSpare723 +type TNonSpare604 = 'GNonSpare "AC" "ACAS Operational" TRuleVariation58 +type TItem39 = 'GItem TNonSpare604 +type TVariation454 = 'GElement 1 1 TRuleContent314 +type TRuleVariation442 = 'GContextFree TVariation454 +type TNonSpare1405 = 'GNonSpare "MN" "Multiple Navigational Aids Operating" TRuleVariation442 +type TItem609 = 'GItem TNonSpare1405 +type TContent598 = 'GContentTable '[ '(0, "Yes"), '(1, "No")] +type TRuleContent596 = 'GContextFree TContent598 +type TVariation603 = 'GElement 2 1 TRuleContent596 +type TRuleVariation591 = 'GContextFree TVariation603 +type TNonSpare940 = 'GNonSpare "DC" "Differential Correction" TRuleVariation591 +type TItem266 = 'GItem TNonSpare940 +type TItem19 = 'GSpare 3 5 +type TVariation1129 = 'GGroup 0 '[ TItem204, TItem1021, TItem29, TItem1006, TItem84, TItem58, TItem112, TItem113, TItem39, TItem609, TItem266, TItem19] +type TRuleVariation1084 = 'GContextFree TVariation1129 +type TNonSpare857 = 'GNonSpare "COMACAS" "Communications/ACAS Capability and Flight Status" TRuleVariation1084 +type TVariation388 = 'GElement 0 32 TRuleContent634 +type TRuleVariation380 = 'GContextFree TVariation388 +type TNonSpare617 = 'GNonSpare "ACT" "Aircraft Derived Aircraft Type" TRuleVariation380 +type TContent608 = 'GContentTable '[ '(1, "Light aircraft <= 7000 kg"), '(2, "Reserved"), '(3, "7000 kg < medium aircraft < 136000 kg"), '(4, "Reserved"), '(5, "136000 kg <= heavy aircraft"), '(6, "Highly manoeuvrable (5g acceleration capability) and high speed (>400 knots cruise)"), '(7, "Reserved"), '(8, "Reserved"), '(9, "Reserved"), '(10, "Rotocraft"), '(11, "Glider / sailplane"), '(12, "Lighter-than-air"), '(13, "Unmanned aerial vehicle"), '(14, "Space / transatmospheric vehicle"), '(15, "Ultralight / handglider / paraglider"), '(16, "Parachutist / skydiver"), '(17, "Reserved"), '(18, "Reserved"), '(19, "Reserved"), '(20, "Surface emergency vehicle"), '(21, "Surface service vehicle"), '(22, "Fixed ground or tethered obstruction"), '(23, "Reserved"), '(24, "Reserved")] +type TRuleContent606 = 'GContextFree TContent608 +type TVariation197 = 'GElement 0 8 TRuleContent606 +type TRuleVariation189 = 'GContextFree TVariation197 +type TNonSpare988 = 'GNonSpare "ECAT" "Emitter Category" TRuleVariation189 +type TContent581 = 'GContentTable '[ '(0, "VDL Mode 4 available"), '(1, "VDL Mode 4 not available")] +type TRuleContent579 = 'GContextFree TContent581 +type TVariation99 = 'GElement 0 1 TRuleContent579 +type TRuleVariation99 = 'GContextFree TVariation99 +type TNonSpare2218 = 'GNonSpare "VDL" "VDL Mode 4" TRuleVariation99 +type TItem1242 = 'GItem TNonSpare2218 +type TContent293 = 'GContentTable '[ '(0, "Mode S available"), '(1, "Mode S not available")] +type TRuleContent291 = 'GContextFree TContent293 +type TVariation452 = 'GElement 1 1 TRuleContent291 +type TRuleVariation440 = 'GContextFree TVariation452 +type TNonSpare1367 = 'GNonSpare "MDS" "Mode S" TRuleVariation440 +type TItem588 = 'GItem TNonSpare1367 +type TContent554 = 'GContentTable '[ '(0, "UAT available"), '(1, "UAT not available")] +type TRuleContent552 = 'GContextFree TContent554 +type TVariation601 = 'GElement 2 1 TRuleContent552 +type TRuleVariation589 = 'GContextFree TVariation601 +type TNonSpare2153 = 'GNonSpare "UAT" "UAT" TRuleVariation589 +type TItem1180 = 'GItem TNonSpare2153 +type TVariation1342 = 'GGroup 0 '[ TItem1242, TItem588, TItem1180, TItem19] +type TRuleVariation1266 = 'GContextFree TVariation1342 +type TNonSpare707 = 'GNonSpare "AVTECH" "Available Technologies" TRuleVariation1266 +type TVariation1578 = 'GCompound '[ 'Just TNonSpare1330, 'Just TNonSpare622, 'Nothing, 'Just TNonSpare857, 'Nothing, 'Nothing, 'Nothing, 'Just TNonSpare617, 'Just TNonSpare988, 'Nothing, 'Just TNonSpare707] +type TRuleVariation1494 = 'GContextFree TVariation1578 +type TNonSpare530 = 'GNonSpare "380" "Mode-S / ADS-B Related Data" TRuleVariation1494 +type TUapItem530 = 'GUapItem TNonSpare530 +type TNonSpare1081 = 'GNonSpare "FTN" "Fusion Track Number" TRuleVariation504 +type TItem374 = 'GItem TNonSpare1081 +type TVariation1031 = 'GGroup 0 '[ TItem0, TItem374] +type TRuleVariation1000 = 'GContextFree TVariation1031 +type TNonSpare383 = 'GNonSpare "161" "Track Number" TRuleVariation1000 +type TUapItem383 = 'GUapItem TNonSpare383 +type TContent310 = 'GContentTable '[ '(0, "Multisensor Track"), '(1, "Monosensor Track")] +type TRuleContent308 = 'GContextFree TContent310 +type TVariation56 = 'GElement 0 1 TRuleContent308 +type TRuleVariation56 = 'GContextFree TVariation56 +type TNonSpare1421 = 'GNonSpare "MON" "" TRuleVariation56 +type TItem625 = 'GItem TNonSpare1421 +type TContent548 = 'GContentTable '[ '(0, "Transponder Ground bit not set or unknown"), '(1, "Transponder Ground bit set")] +type TRuleContent546 = 'GContextFree TContent548 +type TVariation477 = 'GElement 1 1 TRuleContent546 +type TRuleVariation465 = 'GContextFree TVariation477 +type TNonSpare1104 = 'GNonSpare "GBS" "" TRuleVariation465 +type TItem387 = 'GItem TNonSpare1104 +type TContent49 = 'GContentTable '[ '(0, "Barometric altitude (Mode C) more reliable"), '(1, "Geometric altitude more reliable")] +type TRuleContent49 = 'GContextFree TContent49 +type TVariation528 = 'GElement 2 1 TRuleContent49 +type TRuleVariation516 = 'GContextFree TVariation528 +type TNonSpare1424 = 'GNonSpare "MRH" "" TRuleVariation516 +type TItem628 = 'GItem TNonSpare1424 +type TContent390 = 'GContentTable '[ '(0, "No source"), '(1, "GPS"), '(2, "3d radar"), '(3, "Triangulation"), '(4, "Height from coverage"), '(5, "Speed look-up table"), '(6, "Default height"), '(7, "Multilateration")] +type TRuleContent388 = 'GContextFree TContent390 +type TVariation715 = 'GElement 3 3 TRuleContent388 +type TRuleVariation703 = 'GContextFree TVariation715 +type TNonSpare1906 = 'GNonSpare "SRC" "" TRuleVariation703 +type TItem1000 = 'GItem TNonSpare1906 +type TContent67 = 'GContentTable '[ '(0, "Confirmed track"), '(1, "Tentative track")] +type TRuleContent67 = 'GContextFree TContent67 +type TVariation937 = 'GElement 6 1 TRuleContent67 +type TRuleVariation906 = 'GContextFree TVariation937 +type TNonSpare816 = 'GNonSpare "CNF" "" TRuleVariation906 +type TItem182 = 'GItem TNonSpare816 +type TContent21 = 'GContentTable '[ '(0, "Actual Track"), '(1, "Simulated track")] +type TRuleContent21 = 'GContextFree TContent21 +type TVariation5 = 'GElement 0 1 TRuleContent21 +type TRuleVariation5 = 'GContextFree TVariation5 +type TNonSpare1867 = 'GNonSpare "SIM" "" TRuleVariation5 +type TItem965 = 'GItem TNonSpare1867 +type TContent202 = 'GContentTable '[ '(0, "Default value"), '(1, "Track service end (i.e. last message transmitted to the user for the track)")] +type TRuleContent202 = 'GContextFree TContent202 +type TVariation438 = 'GElement 1 1 TRuleContent202 +type TRuleVariation426 = 'GContextFree TVariation438 +type TNonSpare2101 = 'GNonSpare "TSE" "" TRuleVariation426 +type TItem1134 = 'GItem TNonSpare2101 +type TContent201 = 'GContentTable '[ '(0, "Default value"), '(1, "Track service begin (i.e. first message transmitted to the user for the track)")] +type TRuleContent201 = 'GContextFree TContent201 +type TVariation549 = 'GElement 2 1 TRuleContent201 +type TRuleVariation537 = 'GContextFree TVariation549 +type TNonSpare2099 = 'GNonSpare "TSB" "" TRuleVariation537 +type TItem1132 = 'GItem TNonSpare2099 +type TContent325 = 'GContentTable '[ '(0, "No Mode 4 interrogationt"), '(1, "Friendly target"), '(2, "Unknown target"), '(3, "No reply")] +type TRuleContent323 = 'GContextFree TContent325 +type TVariation701 = 'GElement 3 2 TRuleContent323 +type TRuleVariation689 = 'GContextFree TVariation701 +type TNonSpare1071 = 'GNonSpare "FRIFOE" "" TRuleVariation689 +type TItem367 = 'GItem TNonSpare1071 +type TContent194 = 'GContentTable '[ '(0, "Default value"), '(1, "Military Emergency present in the last report received from a sensor capable of decoding this data")] +type TRuleContent194 = 'GContextFree TContent194 +type TVariation874 = 'GElement 5 1 TRuleContent194 +type TRuleVariation843 = 'GContextFree TVariation874 +type TNonSpare1375 = 'GNonSpare "ME" "" TRuleVariation843 +type TItem593 = 'GItem TNonSpare1375 +type TContent215 = 'GContentTable '[ '(0, "End of Data Item"), '(1, "Military Identification present in the last report received from a sensor capable of decoding this data")] +type TRuleContent215 = 'GContextFree TContent215 +type TVariation956 = 'GElement 6 1 TRuleContent215 +type TRuleVariation925 = 'GContextFree TVariation956 +type TNonSpare1394 = 'GNonSpare "MI" "" TRuleVariation925 +type TItem600 = 'GItem TNonSpare1394 +type TContent537 = 'GContentTable '[ '(0, "Track not resulting from amalgamation process"), '(1, "Track resulting from amalgamation process")] +type TRuleContent535 = 'GContextFree TContent537 +type TVariation93 = 'GElement 0 1 TRuleContent535 +type TRuleVariation93 = 'GContextFree TVariation93 +type TNonSpare659 = 'GNonSpare "AMA" "" TRuleVariation93 +type TItem74 = 'GItem TNonSpare659 +type TContent196 = 'GContentTable '[ '(0, "Default value"), '(1, "SPI present in the last report received from a sensor capable of decoding this data")] +type TRuleContent196 = 'GContextFree TContent196 +type TVariation437 = 'GElement 1 1 TRuleContent196 +type TRuleVariation425 = 'GContextFree TVariation437 +type TNonSpare1895 = 'GNonSpare "SPI" "" TRuleVariation425 +type TItem989 = 'GItem TNonSpare1895 +type TContent185 = 'GContentTable '[ '(0, "Default value"), '(1, "Age of the last received track update is higher than system dependent threshold (coasting)")] +type TRuleContent185 = 'GContextFree TContent185 +type TVariation546 = 'GElement 2 1 TRuleContent185 +type TRuleVariation534 = 'GContextFree TVariation546 +type TNonSpare907 = 'GNonSpare "CST" "" TRuleVariation534 +type TItem238 = 'GItem TNonSpare907 +type TContent421 = 'GContentTable '[ '(0, "Not flight-plan correlated"), '(1, "Flight plan correlated")] +type TRuleContent419 = 'GContextFree TContent421 +type TVariation679 = 'GElement 3 1 TRuleContent419 +type TRuleVariation667 = 'GContextFree TVariation679 +type TNonSpare1063 = 'GNonSpare "FPC" "" TRuleVariation667 +type TItem360 = 'GItem TNonSpare1063 +type TContent177 = 'GContentTable '[ '(0, "Default value"), '(1, "ADS-B data inconsistent with other surveillance information")] +type TRuleContent177 = 'GContextFree TContent177 +type TVariation741 = 'GElement 4 1 TRuleContent177 +type TRuleVariation729 = 'GContextFree TVariation741 +type TNonSpare631 = 'GNonSpare "AFF" "" TRuleVariation729 +type TItem53 = 'GItem TNonSpare631 +type TVariation1437 = 'GExtended '[ 'Just TItem625, 'Just TItem387, 'Just TItem628, 'Just TItem1000, 'Just TItem182, 'Nothing, 'Just TItem965, 'Just TItem1134, 'Just TItem1132, 'Just TItem367, 'Just TItem593, 'Just TItem600, 'Nothing, 'Just TItem74, 'Just TItem989, 'Just TItem238, 'Just TItem360, 'Just TItem53, 'Just TItem24, 'Nothing] +type TRuleVariation1353 = 'GContextFree TVariation1437 +type TNonSpare403 = 'GNonSpare "170" "Track Status" TRuleVariation1353 +type TUapItem403 = 'GUapItem TNonSpare403 +type TContent789 = 'GContentQuantity 'GUnsigned ('GNumDiv ('GNumInt ('GZ 'GPlus 1)) ('GNumPow ('GZ 'GPlus 2) ('GZ 'GPlus 2))) "s" +type TRuleContent786 = 'GContextFree TContent789 +type TVariation249 = 'GElement 0 8 TRuleContent786 +type TRuleVariation241 = 'GContextFree TVariation249 +type TNonSpare1599 = 'GNonSpare "PSR" "Age of The Last Primary Detection Used to Update the Track" TRuleVariation241 +type TNonSpare1921 = 'GNonSpare "SSR" "Age of the Last Secondary Detection Used to Update the Track" TRuleVariation241 +type TNonSpare1358 = 'GNonSpare "MDA" "Age of the Last Mode A Detection Used to Update the Track" TRuleVariation241 +type TNonSpare1381 = 'GNonSpare "MFL" "Age of the Last Mode C Detection Used to Update the Track" TRuleVariation241 +type TNonSpare1365 = 'GNonSpare "MDS" "Age of the Last Mode S Detection Used to Update the Track" TRuleVariation241 +type TVariation340 = 'GElement 0 16 TRuleContent786 +type TRuleVariation332 = 'GContextFree TVariation340 +type TNonSpare628 = 'GNonSpare "ADS" "Age of the Last ADS Report Used to Update the Track" TRuleVariation332 +type TNonSpare618 = 'GNonSpare "ADB" "Age of the Last ADS-B Report Used to Update the Track" TRuleVariation241 +type TNonSpare1347 = 'GNonSpare "MD1" "Age of the Last Valid Mode 1 Used to Update the Track" TRuleVariation241 +type TNonSpare1349 = 'GNonSpare "MD2" "Age of the Last Mode 2 Used to Update the Track" TRuleVariation241 +type TNonSpare1279 = 'GNonSpare "LOP" "Age of the Last Magentic Loop Detection" TRuleVariation241 +type TNonSpare2087 = 'GNonSpare "TRK" "Actual Track Age Since First Occurrence" TRuleVariation241 +type TNonSpare1448 = 'GNonSpare "MUL" "Age of the Last Multilateration Detection" TRuleVariation241 +type TVariation1585 = 'GCompound '[ 'Just TNonSpare1599, 'Just TNonSpare1921, 'Just TNonSpare1358, 'Just TNonSpare1381, 'Just TNonSpare1365, 'Just TNonSpare628, 'Just TNonSpare618, 'Just TNonSpare1347, 'Just TNonSpare1349, 'Just TNonSpare1279, 'Just TNonSpare2087, 'Just TNonSpare1448] +type TRuleVariation1501 = 'GContextFree TVariation1585 +type TNonSpare506 = 'GNonSpare "290" "System Track Update Ages" TRuleVariation1501 +type TUapItem506 = 'GUapItem TNonSpare506 +type TContent577 = 'GContentTable '[ '(0, "Unknown"), '(1, "On stand"), '(2, "Taxiing for departure"), '(3, "Taxiing for arrival"), '(4, "Runway for departure"), '(5, "Runway for arrival"), '(6, "Hold for departure"), '(7, "Hold for arrival"), '(8, "Push back"), '(9, "On finals")] +type TRuleContent575 = 'GContextFree TContent577 +type TVariation192 = 'GElement 0 8 TRuleContent575 +type TRuleVariation184 = 'GContextFree TVariation192 +type TNonSpare552 = 'GNonSpare "430" "Phase of Flight" TRuleVariation184 +type TUapItem550 = 'GUapItem TNonSpare552 +type TContent685 = 'GContentQuantity 'GSigned ('GNumDiv ('GNumInt ('GZ 'GPlus 1)) ('GNumPow ('GZ 'GPlus 2) ('GZ 'GPlus 2))) "FL" +type TRuleContent683 = 'GContextFree TContent685 +type TVariation288 = 'GElement 0 16 TRuleContent683 +type TRuleVariation280 = 'GContextFree TVariation288 +type TNonSpare266 = 'GNonSpare "090" "Measured Flight Level" TRuleVariation280 +type TUapItem266 = 'GUapItem TNonSpare266 +type TContent330 = 'GContentTable '[ '(0, "No QNH correction applied"), '(1, "QNH correction applied")] +type TRuleContent328 = 'GContextFree TContent330 +type TVariation61 = 'GElement 0 1 TRuleContent328 +type TRuleVariation61 = 'GContextFree TVariation61 +type TNonSpare1656 = 'GNonSpare "QNH" "QNH Correction Applied" TRuleVariation61 +type TItem818 = 'GItem TNonSpare1656 +type TContent683 = 'GContentQuantity 'GSigned ('GNumDiv ('GNumInt ('GZ 'GPlus 1)) ('GNumPow ('GZ 'GPlus 2) ('GZ 'GPlus 2))) "FL" +type TRuleContent681 = 'GContextFree TContent683 +type TVariation517 = 'GElement 1 15 TRuleContent681 +type TRuleVariation505 = 'GContextFree TVariation517 +type TNonSpare916 = 'GNonSpare "CTBA" "Calculated Track Barometric Altitude" TRuleVariation505 +type TItem246 = 'GItem TNonSpare916 +type TVariation1228 = 'GGroup 0 '[ TItem818, TItem246] +type TRuleVariation1174 = 'GContextFree TVariation1228 +type TNonSpare280 = 'GNonSpare "093" "Calculated Track Barometric Altitude" TRuleVariation1174 +type TUapItem280 = 'GUapItem TNonSpare280 +type TContent715 = 'GContentQuantity 'GSigned ('GNumDiv ('GNumInt ('GZ 'GPlus 25)) ('GNumPow ('GZ 'GPlus 2) ('GZ 'GPlus 2))) "ft" +type TRuleContent713 = 'GContextFree TContent715 +type TVariation306 = 'GElement 0 16 TRuleContent713 +type TRuleVariation298 = 'GContextFree TVariation306 +type TNonSpare277 = 'GNonSpare "092" "Calculated Track Geometric Altitude" TRuleVariation298 +type TUapItem277 = 'GUapItem TNonSpare277 +type TContent717 = 'GContentQuantity 'GSigned ('GNumDiv ('GNumInt ('GZ 'GPlus 25)) ('GNumPow ('GZ 'GPlus 2) ('GZ 'GPlus 2))) "ft/min" +type TRuleContent715 = 'GContextFree TContent717 +type TVariation308 = 'GElement 0 16 TRuleContent715 +type TRuleVariation300 = 'GContextFree TVariation308 +type TNonSpare445 = 'GNonSpare "215" "Calculated Rate Of Climb/Descent" TRuleVariation300 +type TUapItem445 = 'GUapItem TNonSpare445 +type TNonSpare500 = 'GNonSpare "270" "Target Size and Orientation" TRuleVariation1350 +type TUapItem500 = 'GUapItem TNonSpare500 +type TNonSpare1852 = 'GNonSpare "SIC" "System Identity Code" TRuleVariation171 +type TItem952 = 'GItem TNonSpare1852 +type TVariation1256 = 'GGroup 0 '[ TItem920, TItem952] +type TRuleVariation1197 = 'GContextFree TVariation1256 +type TNonSpare1065 = 'GNonSpare "FPPSID" "FPPS Identification Tag" TRuleVariation1197 +type TNonSpare903 = 'GNonSpare "CSN" "Callsign" TRuleVariation398 +type TContent450 = 'GContentTable '[ '(0, "Plan number"), '(1, "Unit 1 internal flight number"), '(2, "Unit 2 internal flight number"), '(3, "Unit 3 internal flight number")] +type TRuleContent448 = 'GContextFree TContent450 +type TVariation117 = 'GElement 0 2 TRuleContent448 +type TRuleVariation117 = 'GContextFree TVariation117 +type TNonSpare2138 = 'GNonSpare "TYP" "IFPS Flight ID Type" TRuleVariation117 +type TItem1167 = 'GItem TNonSpare2138 +type TItem13 = 'GSpare 2 3 +type TVariation926 = 'GElement 5 27 TRuleContent0 +type TRuleVariation895 = 'GContextFree TVariation926 +type TNonSpare1470 = 'GNonSpare "NBR" "IFPS Flight ID Number" TRuleVariation895 +type TItem666 = 'GItem TNonSpare1470 +type TVariation1300 = 'GGroup 0 '[ TItem1167, TItem13, TItem666] +type TRuleVariation1231 = 'GContextFree TVariation1300 +type TNonSpare1197 = 'GNonSpare "IFPSFLIGHTID" "IFPS_FLIGHT_ID" TRuleVariation1231 +type TNonSpare1102 = 'GNonSpare "GATOAT" "Flight Type" TRuleVariation122 +type TItem385 = 'GItem TNonSpare1102 +type TNonSpare1779 = 'GNonSpare "RVSM" "RVSM" TRuleVariation784 +type TItem908 = 'GItem TNonSpare1779 +type TNonSpare1157 = 'GNonSpare "HPR" "Flight Priority" TRuleVariation943 +type TItem425 = 'GItem TNonSpare1157 +type TVariation1168 = 'GGroup 0 '[ TItem385, TItem366, TItem908, TItem425, TItem29] +type TRuleVariation1121 = 'GContextFree TVariation1168 +type TNonSpare1053 = 'GNonSpare "FLIGHTCAT" "Flight Category" TRuleVariation1121 +type TNonSpare2047 = 'GNonSpare "TOA" "Type of Aircraft" TRuleVariation380 +type TContent635 = 'GContentTable '[ '(76, "Light"), '(77, "Medium"), '(72, "Heavy"), '(74, "Super")] +type TRuleContent633 = 'GContextFree TContent635 +type TVariation216 = 'GElement 0 8 TRuleContent633 +type TRuleVariation208 = 'GContextFree TVariation216 +type TNonSpare2258 = 'GNonSpare "WTC" "Wake Turbulence Category" TRuleVariation208 +type TNonSpare619 = 'GNonSpare "ADEP" "Departure Airport" TRuleVariation380 +type TNonSpare620 = 'GNonSpare "ADES" "Destination Airport" TRuleVariation380 +type TVariation364 = 'GElement 0 24 TRuleContent634 +type TRuleVariation356 = 'GContextFree TVariation364 +type TNonSpare1784 = 'GNonSpare "RWY" "Runway Designation" TRuleVariation356 +type TNonSpare792 = 'GNonSpare "CFL" "Current Cleared Flight Level" TRuleVariation327 +type TNonSpare788 = 'GNonSpare "CENTRE" "8-bit Group Identification Code" TRuleVariation171 +type TItem162 = 'GItem TNonSpare788 +type TNonSpare1575 = 'GNonSpare "POSITION" "8-bit Control Position Identification Code" TRuleVariation171 +type TItem750 = 'GItem TNonSpare1575 +type TVariation1116 = 'GGroup 0 '[ TItem162, TItem750] +type TRuleVariation1074 = 'GContextFree TVariation1116 +type TNonSpare775 = 'GNonSpare "CCP" "Current Control Position" TRuleVariation1074 +type TContent478 = 'GContentTable '[ '(0, "Scheduled off-block time"), '(1, "Estimated off-block time"), '(2, "Estimated take-off time"), '(3, "Actual off-block time"), '(4, "Predicted time at runway hold"), '(5, "Actual time at runway hold"), '(6, "Actual line-up time"), '(7, "Actual take-off time"), '(8, "Estimated time of arrival"), '(9, "Predicted landing time"), '(10, "Actual landing time"), '(11, "Actual time off runway"), '(12, "Predicted time to gate"), '(13, "Actual on-block time")] +type TRuleContent476 = 'GContextFree TContent478 +type TVariation154 = 'GElement 0 5 TRuleContent476 +type TRuleVariation154 = 'GContextFree TVariation154 +type TNonSpare2141 = 'GNonSpare "TYP" "Time Type" TRuleVariation154 +type TItem1170 = 'GItem TNonSpare2141 +type TContent533 = 'GContentTable '[ '(0, "Today"), '(1, "Yesterday"), '(2, "Tomorrow")] +type TRuleContent531 = 'GContextFree TContent533 +type TVariation914 = 'GElement 5 2 TRuleContent531 +type TRuleVariation883 = 'GContextFree TVariation914 +type TNonSpare933 = 'GNonSpare "DAY" "Day" TRuleVariation883 +type TItem259 = 'GItem TNonSpare933 +type TItem30 = 'GSpare 7 4 +type TContent645 = 'GContentInteger 'GUnsigned +type TRuleContent643 = 'GContextFree TContent645 +type TVariation721 = 'GElement 3 5 TRuleContent643 +type TRuleVariation709 = 'GContextFree TVariation721 +type TNonSpare1153 = 'GNonSpare "HOR" "Hours, from 0 to 23" TRuleVariation709 +type TItem422 = 'GItem TNonSpare1153 +type TContent646 = 'GContentInteger 'GUnsigned +type TRuleContent644 = 'GContextFree TContent646 +type TVariation621 = 'GElement 2 6 TRuleContent644 +type TRuleVariation609 = 'GContextFree TVariation621 +type TNonSpare1397 = 'GNonSpare "MIN" "Minutes, from 0 to 59" TRuleVariation609 +type TItem603 = 'GItem TNonSpare1397 +type TContent479 = 'GContentTable '[ '(0, "Seconds available"), '(1, "Seconds not available")] +type TRuleContent477 = 'GContextFree TContent479 +type TVariation78 = 'GElement 0 1 TRuleContent477 +type TRuleVariation78 = 'GContextFree TVariation78 +type TNonSpare705 = 'GNonSpare "AVS" "Seconds Available" TRuleVariation78 +type TItem99 = 'GItem TNonSpare705 +type TNonSpare1842 = 'GNonSpare "SEC" "Seconds, from 0 to 59" TRuleVariation609 +type TItem944 = 'GItem TNonSpare1842 +type TVariation1303 = 'GGroup 0 '[ TItem1170, TItem259, TItem30, TItem422, TItem1, TItem603, TItem99, TItem7, TItem944] +type TVariation1521 = 'GRepetitive ('GRepetitiveRegular 1) TVariation1303 +type TRuleVariation1437 = 'GContextFree TVariation1521 +type TNonSpare2048 = 'GNonSpare "TOD" "Time of Departure" TRuleVariation1437 +type TVariation404 = 'GElement 0 48 TRuleContent634 +type TRuleVariation395 = 'GContextFree TVariation404 +type TNonSpare692 = 'GNonSpare "AST" "Aircraft Stand" TRuleVariation395 +type TContent211 = 'GContentTable '[ '(0, "Empty"), '(1, "Occupied"), '(2, "Unknown")] +type TRuleContent211 = 'GContextFree TContent211 +type TVariation107 = 'GElement 0 2 TRuleContent211 +type TRuleVariation107 = 'GContextFree TVariation107 +type TNonSpare1002 = 'GNonSpare "EMP" "Stand Empty" TRuleVariation107 +type TItem310 = 'GItem TNonSpare1002 +type TContent47 = 'GContentTable '[ '(0, "Available"), '(1, "Not available"), '(2, "Unknown")] +type TRuleContent47 = 'GContextFree TContent47 +type TVariation606 = 'GElement 2 2 TRuleContent47 +type TRuleVariation594 = 'GContextFree TVariation606 +type TNonSpare703 = 'GNonSpare "AVL" "Stand Available" TRuleVariation594 +type TItem97 = 'GItem TNonSpare703 +type TItem22 = 'GSpare 4 4 +type TVariation1139 = 'GGroup 0 '[ TItem310, TItem97, TItem22] +type TRuleVariation1092 = 'GContextFree TVariation1139 +type TNonSpare1961 = 'GNonSpare "STS" "Stand Status" TRuleVariation1092 +type TVariation1572 = 'GCompound '[ 'Just TNonSpare1065, 'Just TNonSpare903, 'Just TNonSpare1197, 'Just TNonSpare1053, 'Just TNonSpare2047, 'Just TNonSpare2258, 'Just TNonSpare619, 'Just TNonSpare620, 'Just TNonSpare1784, 'Just TNonSpare792, 'Just TNonSpare775, 'Just TNonSpare2048, 'Just TNonSpare692, 'Just TNonSpare1961] +type TRuleVariation1488 = 'GContextFree TVariation1572 +type TNonSpare533 = 'GNonSpare "390" "Flight Plan Related Data" TRuleVariation1488 +type TUapItem533 = 'GUapItem TNonSpare533 +type TContent221 = 'GContentTable '[ '(0, "Flyco (follow me)"), '(1, "ATC equipment maintenance"), '(2, "Airport maintenance"), '(3, "Fire"), '(4, "Bird scarer"), '(5, "Snow plough"), '(6, "Runway sweeper"), '(7, "Emergency"), '(8, "Police"), '(9, "Bus"), '(10, "Tug (push/tow)"), '(11, "Grass cutter"), '(12, "Fuel"), '(13, "Baggage"), '(14, "Catering"), '(15, "Aircraft maintenance"), '(16, "Unknown")] +type TRuleContent221 = 'GContextFree TContent221 +type TVariation181 = 'GElement 0 8 TRuleContent221 +type TRuleVariation174 = 'GContextFree TVariation181 +type TNonSpare516 = 'GNonSpare "300" "Vehicle Fleet Identification" TRuleVariation174 +type TUapItem516 = 'GUapItem TNonSpare516 +type TNonSpare2078 = 'GNonSpare "TRB" "In Trouble" TRuleVariation31 +type TItem1117 = 'GItem TNonSpare2078 +type TContent628 = 'GContentTable '[ '(1, "Towing aircraft"), '(2, "FOLLOW-ME operation"), '(3, "Runway check"), '(4, "Emergency operation (fire, medical...)"), '(5, "Work in progress (maintenance, birds scarer, sweepers...)")] +type TRuleContent626 = 'GContextFree TContent628 +type TVariation512 = 'GElement 1 7 TRuleContent626 +type TRuleVariation500 = 'GContextFree TVariation512 +type TNonSpare1442 = 'GNonSpare "MSG" "Message" TRuleVariation500 +type TItem643 = 'GItem TNonSpare1442 +type TVariation1295 = 'GGroup 0 '[ TItem1117, TItem643] +type TRuleVariation1228 = 'GContextFree TVariation1295 +type TNonSpare520 = 'GNonSpare "310" "Pre-programmed Message" TRuleVariation1228 +type TUapItem520 = 'GUapItem TNonSpare520 +type TNonSpare2279 = 'GNonSpare "X" "Estimated Accuracy of the Calculated Position of X Component" TRuleVariation238 +type TItem1295 = 'GItem TNonSpare2279 +type TNonSpare2333 = 'GNonSpare "Y" "Estimated Accuracy of the Calculated Position of Y Component" TRuleVariation238 +type TItem1345 = 'GItem TNonSpare2333 +type TVariation1368 = 'GGroup 0 '[ TItem1295, TItem1345] +type TRuleVariation1292 = 'GContextFree TVariation1368 +type TNonSpare668 = 'GNonSpare "APC" "Estimated Accuracy Of Track Position (Cartesian)" TRuleVariation1292 +type TContent730 = 'GContentQuantity 'GSigned ('GNumDiv ('GNumInt ('GZ 'GPlus 180)) ('GNumPow ('GZ 'GPlus 2) ('GZ 'GPlus 31))) "°" +type TRuleContent728 = 'GContextFree TContent730 +type TVariation312 = 'GElement 0 16 TRuleContent728 +type TRuleVariation304 = 'GContextFree TVariation312 +type TNonSpare1228 = 'GNonSpare "LAT" "APW Latitude Component Accuracy" TRuleVariation304 +type TItem484 = 'GItem TNonSpare1228 +type TNonSpare1260 = 'GNonSpare "LON" "APW Longitude Component Accuracy" TRuleVariation304 +type TItem514 = 'GItem TNonSpare1260 +type TVariation1181 = 'GGroup 0 '[ TItem484, TItem514] +type TRuleVariation1132 = 'GContextFree TVariation1181 +type TNonSpare674 = 'GNonSpare "APW" "Estimated Accuracy Of Track Position (WGS84)" TRuleVariation1132 +type TVariation279 = 'GElement 0 16 TRuleContent664 +type TRuleVariation271 = 'GContextFree TVariation279 +type TNonSpare694 = 'GNonSpare "ATH" "Estimated Accuracy Of Track Height" TRuleVariation271 +type TContent768 = 'GContentQuantity 'GUnsigned ('GNumDiv ('GNumInt ('GZ 'GPlus 1)) ('GNumInt ('GZ 'GPlus 10))) "m/s" +type TRuleContent766 = 'GContextFree TContent768 +type TVariation242 = 'GElement 0 8 TRuleContent766 +type TRuleVariation234 = 'GContextFree TVariation242 +type TNonSpare2280 = 'GNonSpare "X" "Estimated Accuracy of the Calculated Velocity of X Component" TRuleVariation234 +type TItem1296 = 'GItem TNonSpare2280 +type TNonSpare2334 = 'GNonSpare "Y" "Estimated Accuracy of the Calculated Velocity of Y Component" TRuleVariation234 +type TItem1346 = 'GItem TNonSpare2334 +type TVariation1369 = 'GGroup 0 '[ TItem1296, TItem1346] +type TRuleVariation1293 = 'GContextFree TVariation1369 +type TNonSpare701 = 'GNonSpare "AVC" "Estimated Accuracy Of Track Velocity (Cartesian)" TRuleVariation1293 +type TContent669 = 'GContentQuantity 'GSigned ('GNumDiv ('GNumInt ('GZ 'GPlus 1)) ('GNumInt ('GZ 'GPlus 10))) "m/s" +type TRuleContent667 = 'GContextFree TContent669 +type TVariation280 = 'GElement 0 16 TRuleContent667 +type TRuleVariation272 = 'GContextFree TVariation280 +type TNonSpare682 = 'GNonSpare "ARC" "Estimated Accuracy Of Rate Of Climb / Descent" TRuleVariation272 +type TContent776 = 'GContentQuantity 'GUnsigned ('GNumDiv ('GNumInt ('GZ 'GPlus 1)) ('GNumInt ('GZ 'GPlus 100))) "m/s²" +type TRuleContent774 = 'GContextFree TContent776 +type TVariation244 = 'GElement 0 8 TRuleContent774 +type TRuleVariation236 = 'GContextFree TVariation244 +type TNonSpare2278 = 'GNonSpare "X" "Estimated Accuracy Of Acceleration of X Component" TRuleVariation236 +type TItem1294 = 'GItem TNonSpare2278 +type TNonSpare2332 = 'GNonSpare "Y" "Estimated Accuracy Of Acceleration of Y Component" TRuleVariation236 +type TItem1344 = 'GItem TNonSpare2332 +type TVariation1367 = 'GGroup 0 '[ TItem1294, TItem1344] +type TRuleVariation1291 = 'GContextFree TVariation1367 +type TNonSpare601 = 'GNonSpare "AAC" "Estimated Accuracy Of Acceleration (Cartesian)" TRuleVariation1291 +type TVariation1559 = 'GCompound '[ 'Just TNonSpare668, 'Just TNonSpare674, 'Just TNonSpare694, 'Just TNonSpare701, 'Just TNonSpare682, 'Just TNonSpare601] +type TRuleVariation1475 = 'GContextFree TVariation1559 +type TNonSpare564 = 'GNonSpare "500" "Estimated Accuracies" TRuleVariation1475 +type TUapItem562 = 'GUapItem TNonSpare564 +type TContent35 = 'GContentTable '[ '(0, "Alert acknowledged"), '(1, "Alert not acknowledged")] +type TRuleContent35 = 'GContextFree TContent35 +type TVariation12 = 'GElement 0 1 TRuleContent35 +type TRuleVariation12 = 'GContextFree TVariation12 +type TNonSpare612 = 'GNonSpare "ACK" "Alert Acknowleged" TRuleVariation12 +type TItem45 = 'GItem TNonSpare612 +type TContent213 = 'GContentTable '[ '(0, "End fo alert"), '(1, "Pre-alarm"), '(2, "Severe alert")] +type TRuleContent213 = 'GContextFree TContent213 +type TVariation484 = 'GElement 1 2 TRuleContent213 +type TRuleVariation472 = 'GContextFree TVariation484 +type TNonSpare1977 = 'GNonSpare "SVR" "Alert Severity" TRuleVariation472 +type TItem1047 = 'GItem TNonSpare1977 +type TNonSpare693 = 'GNonSpare "AT" "Alert Type" TRuleVariation171 +type TItem91 = 'GItem TNonSpare693 +type TNonSpare661 = 'GNonSpare "AN" "Alert Number" TRuleVariation171 +type TItem76 = 'GItem TNonSpare661 +type TVariation1091 = 'GGroup 0 '[ TItem45, TItem1047, TItem19, TItem91, TItem76] +type TRuleVariation1057 = 'GContextFree TVariation1091 +type TNonSpare576 = 'GNonSpare "600" "Alert Messages" TRuleVariation1057 +type TUapItem574 = 'GUapItem TNonSpare576 +type TNonSpare1082 = 'GNonSpare "FTN" "Fusion Track Number" TRuleVariation806 +type TItem375 = 'GItem TNonSpare1082 +type TVariation1062 = 'GGroup 0 '[ TItem3, TItem375] +type TVariation1482 = 'GRepetitive ('GRepetitiveRegular 1) TVariation1062 +type TRuleVariation1398 = 'GContextFree TVariation1482 +type TNonSpare584 = 'GNonSpare "605" "Tracks in Alert" TRuleVariation1398 +type TUapItem582 = 'GUapItem TNonSpare584 +type TNonSpare746 = 'GNonSpare "BKN" "Bank Number" TRuleVariation140 +type TItem135 = 'GItem TNonSpare746 +type TContent250 = 'GContentTable '[ '(0, "Indicator on"), '(1, "Indicator off")] +type TRuleContent250 = 'GContextFree TContent250 +type TVariation754 = 'GElement 4 1 TRuleContent250 +type TRuleVariation742 = 'GContextFree TVariation754 +type TNonSpare1166 = 'GNonSpare "I1" "Indicator 1" TRuleVariation742 +type TItem432 = 'GItem TNonSpare1166 +type TVariation886 = 'GElement 5 1 TRuleContent250 +type TRuleVariation855 = 'GContextFree TVariation886 +type TNonSpare1170 = 'GNonSpare "I2" "Indicator 2" TRuleVariation855 +type TItem436 = 'GItem TNonSpare1170 +type TVariation965 = 'GElement 6 1 TRuleContent250 +type TRuleVariation934 = 'GContextFree TVariation965 +type TNonSpare1171 = 'GNonSpare "I3" "Indicator 3" TRuleVariation934 +type TItem437 = 'GItem TNonSpare1171 +type TVariation1016 = 'GElement 7 1 TRuleContent250 +type TRuleVariation985 = 'GContextFree TVariation1016 +type TNonSpare1172 = 'GNonSpare "I4" "Indicator 4" TRuleVariation985 +type TItem438 = 'GItem TNonSpare1172 +type TVariation52 = 'GElement 0 1 TRuleContent250 +type TRuleVariation52 = 'GContextFree TVariation52 +type TNonSpare1173 = 'GNonSpare "I5" "Indicator 5" TRuleVariation52 +type TItem439 = 'GItem TNonSpare1173 +type TVariation447 = 'GElement 1 1 TRuleContent250 +type TRuleVariation435 = 'GContextFree TVariation447 +type TNonSpare1174 = 'GNonSpare "I6" "Indicator 6" TRuleVariation435 +type TItem440 = 'GItem TNonSpare1174 +type TVariation557 = 'GElement 2 1 TRuleContent250 +type TRuleVariation545 = 'GContextFree TVariation557 +type TNonSpare1175 = 'GNonSpare "I7" "Indicator 7" TRuleVariation545 +type TItem441 = 'GItem TNonSpare1175 +type TVariation665 = 'GElement 3 1 TRuleContent250 +type TRuleVariation653 = 'GContextFree TVariation665 +type TNonSpare1176 = 'GNonSpare "I8" "Indicator 8" TRuleVariation653 +type TItem442 = 'GItem TNonSpare1176 +type TNonSpare1177 = 'GNonSpare "I9" "Indicator 9" TRuleVariation742 +type TItem443 = 'GItem TNonSpare1177 +type TNonSpare1167 = 'GNonSpare "I10" "Indicator 10" TRuleVariation855 +type TItem433 = 'GItem TNonSpare1167 +type TNonSpare1168 = 'GNonSpare "I11" "Indicator 11" TRuleVariation934 +type TItem434 = 'GItem TNonSpare1168 +type TNonSpare1169 = 'GNonSpare "I12" "Indicator 12" TRuleVariation985 +type TItem435 = 'GItem TNonSpare1169 +type TVariation1108 = 'GGroup 0 '[ TItem135, TItem432, TItem436, TItem437, TItem438, TItem439, TItem440, TItem441, TItem442, TItem443, TItem433, TItem434, TItem435] +type TVariation1490 = 'GRepetitive ('GRepetitiveRegular 1) TVariation1108 +type TRuleVariation1406 = 'GContextFree TVariation1490 +type TNonSpare588 = 'GNonSpare "610" "Holdbar Status" TRuleVariation1406 +type TUapItem586 = 'GUapItem TNonSpare588 +type TRecord56 = 'GRecord '[ TUapItem48, TUapItem14, TUapItem62, TUapItem358, TUapItem162, TUapItem164, TUapItem432, TUapItem434, TUapItem199, TUapItem474, TUapItem530, TUapItem383, TUapItem403, TUapItem506, TUapItem550, TUapItem266, TUapItem280, TUapItem277, TUapItem445, TUapItem500, TUapItem533, TUapItem516, TUapItem520, TUapItem562, TUapItem574, TUapItem582, TUapItem586, TUapItem596, TUapItem594] +type TUap50 = 'GUap TRecord56 +type TAsterix13 = 'GAsterixBasic 11 ('GEdition 1 2) TUap50 +type TNonSpare357 = 'GNonSpare "140" "Time of Track Information" TRuleVariation376 +type TUapItem357 = 'GUapItem TNonSpare357 +type TNonSpare198 = 'GNonSpare "060" "Mode-3/A Code in Octal Representation" TRuleVariation1032 +type TUapItem198 = 'GUapItem TNonSpare198 +type TContent335 = 'GContentTable '[ '(0, "No alert, no SPI, aircraft airborne"), '(1, "No alert, no SPI, aircraft on ground"), '(2, "Alert, no SPI, aircraft airborne"), '(3, "Alert, no SPI, aircraft on ground"), '(4, "Alert, SPI, aircraft airborne or on ground"), '(5, "No alert, SPI, aircraft airborne or on ground"), '(6, "General Emergency"), '(7, "Lifeguard / medical"), '(8, "Minimum fuel"), '(9, "No communications"), '(10, "Unlawful interference")] +type TRuleContent333 = 'GContextFree TContent335 +type TVariation718 = 'GElement 3 4 TRuleContent333 +type TRuleVariation706 = 'GContextFree TVariation718 +type TNonSpare1942 = 'GNonSpare "STAT" "Flight Status" TRuleVariation706 +type TItem1022 = 'GItem TNonSpare1942 +type TVariation1130 = 'GGroup 0 '[ TItem204, TItem1022, TItem29, TItem1006, TItem84, TItem58, TItem112, TItem113, TItem39, TItem609, TItem266, TItem19] +type TRuleVariation1085 = 'GContextFree TVariation1130 +type TNonSpare858 = 'GNonSpare "COMACAS" "Communications/ACAS Capability and Flight Status" TRuleVariation1085 +type TVariation1579 = 'GCompound '[ 'Just TNonSpare1330, 'Just TNonSpare622, 'Nothing, 'Just TNonSpare858, 'Nothing, 'Nothing, 'Nothing, 'Just TNonSpare617, 'Just TNonSpare988, 'Nothing, 'Just TNonSpare707] +type TRuleVariation1495 = 'GContextFree TVariation1579 +type TNonSpare531 = 'GNonSpare "380" "Mode-S / ADS-B Related Data" TRuleVariation1495 +type TUapItem531 = 'GUapItem TNonSpare531 +type TContent183 = 'GContentTable '[ '(0, "Default value"), '(1, "Age of the last received PSR track update is higher than system dependent threshold")] +type TRuleContent183 = 'GContextFree TContent183 +type TVariation434 = 'GElement 1 1 TRuleContent183 +type TRuleVariation422 = 'GContextFree TVariation434 +type TNonSpare1597 = 'GNonSpare "PSR" "" TRuleVariation422 +type TItem769 = 'GItem TNonSpare1597 +type TContent184 = 'GContentTable '[ '(0, "Default value"), '(1, "Age of the last received SSR track update is higher than system dependent threshold")] +type TRuleContent184 = 'GContextFree TContent184 +type TVariation545 = 'GElement 2 1 TRuleContent184 +type TRuleVariation533 = 'GContextFree TVariation545 +type TNonSpare1919 = 'GNonSpare "SSR" "" TRuleVariation533 +type TItem1008 = 'GItem TNonSpare1919 +type TContent181 = 'GContentTable '[ '(0, "Default value"), '(1, "Age of the last received Mode S track update is higher than system dependent threshold")] +type TRuleContent181 = 'GContextFree TContent181 +type TVariation655 = 'GElement 3 1 TRuleContent181 +type TRuleVariation643 = 'GContextFree TVariation655 +type TNonSpare1363 = 'GNonSpare "MDS" "" TRuleVariation643 +type TItem586 = 'GItem TNonSpare1363 +type TContent178 = 'GContentTable '[ '(0, "Default value"), '(1, "Age of the last received ADS track update is higher than system dependent threshold")] +type TRuleContent178 = 'GContextFree TContent178 +type TVariation742 = 'GElement 4 1 TRuleContent178 +type TRuleVariation730 = 'GContextFree TVariation742 +type TNonSpare624 = 'GNonSpare "ADS" "" TRuleVariation730 +type TItem48 = 'GItem TNonSpare624 +type TContent198 = 'GContentTable '[ '(0, "Default value"), '(1, "Special Used Code (Mode A codes to be defined in the system to mark a track with special interest)")] +type TRuleContent198 = 'GContextFree TContent198 +type TVariation876 = 'GElement 5 1 TRuleContent198 +type TRuleVariation845 = 'GContextFree TVariation876 +type TNonSpare1968 = 'GNonSpare "SUC" "" TRuleVariation845 +type TItem1043 = 'GItem TNonSpare1968 +type TContent187 = 'GContentTable '[ '(0, "Default value"), '(1, "Assigned Mode A Code Conflict (same individual Mode A Code assigned to another track)")] +type TRuleContent187 = 'GContextFree TContent187 +type TVariation954 = 'GElement 6 1 TRuleContent187 +type TRuleVariation923 = 'GContextFree TVariation954 +type TNonSpare600 = 'GNonSpare "AAC" "" TRuleVariation923 +type TItem37 = 'GItem TNonSpare600 +type TVariation1438 = 'GExtended '[ 'Just TItem625, 'Just TItem387, 'Just TItem628, 'Just TItem1000, 'Just TItem182, 'Nothing, 'Just TItem965, 'Just TItem1134, 'Just TItem1132, 'Just TItem367, 'Just TItem593, 'Just TItem600, 'Nothing, 'Just TItem74, 'Just TItem989, 'Just TItem238, 'Just TItem360, 'Just TItem53, 'Just TItem24, 'Nothing, 'Just TItem0, 'Just TItem769, 'Just TItem1008, 'Just TItem586, 'Just TItem48, 'Just TItem1043, 'Just TItem37, 'Nothing] +type TRuleVariation1354 = 'GContextFree TVariation1438 +type TNonSpare404 = 'GNonSpare "170" "Track Status" TRuleVariation1354 +type TUapItem404 = 'GUapItem TNonSpare404 +type TNonSpare1600 = 'GNonSpare "PSR" "Age of the Last Primary Report Used to Update the Track" TRuleVariation241 +type TNonSpare1922 = 'GNonSpare "SSR" "Age of the Last Secondary Report Used to Update the Track" TRuleVariation241 +type TNonSpare1359 = 'GNonSpare "MDA" "Age of the Last Valid Mode A Report Used to Update the Track" TRuleVariation241 +type TNonSpare1382 = 'GNonSpare "MFL" "Age of the Last Valid and Credible Mode C Used to Update the Track" TRuleVariation241 +type TNonSpare1366 = 'GNonSpare "MDS" "Age of the Last Mode S Report Used to Update the Track" TRuleVariation241 +type TNonSpare1350 = 'GNonSpare "MD2" "Age of the Last Valid Mode 2 Used to Update the Track" TRuleVariation241 +type TVariation1586 = 'GCompound '[ 'Just TNonSpare1600, 'Just TNonSpare1922, 'Just TNonSpare1359, 'Just TNonSpare1382, 'Just TNonSpare1366, 'Just TNonSpare628, 'Just TNonSpare618, 'Just TNonSpare1347, 'Just TNonSpare1350, 'Just TNonSpare1279, 'Just TNonSpare2087, 'Just TNonSpare1448] +type TRuleVariation1502 = 'GContextFree TVariation1586 +type TNonSpare507 = 'GNonSpare "290" "System Track Update Ages" TRuleVariation1502 +type TUapItem507 = 'GUapItem TNonSpare507 +type TContent329 = 'GContentTable '[ '(0, "No QNH Correction Applied"), '(1, "QNH Correction Applied")] +type TRuleContent327 = 'GContextFree TContent329 +type TVariation60 = 'GElement 0 1 TRuleContent327 +type TRuleVariation60 = 'GContextFree TVariation60 +type TNonSpare1655 = 'GNonSpare "QNH" "QNH Correction Applied" TRuleVariation60 +type TItem817 = 'GItem TNonSpare1655 +type TVariation1227 = 'GGroup 0 '[ TItem817, TItem246] +type TRuleVariation1173 = 'GContextFree TVariation1227 +type TNonSpare279 = 'GNonSpare "093" "Calculated Track Barometric Altitude" TRuleVariation1173 +type TUapItem279 = 'GUapItem TNonSpare279 +type TNonSpare499 = 'GNonSpare "270" "Target Size and Orientation" TRuleVariation1350 +type TUapItem499 = 'GUapItem TNonSpare499 +type TContent251 = 'GContentTable '[ '(0, "Instrument Flight Rules"), '(1, "Visual Flight Rules"), '(2, "Not applicable"), '(3, "Controlled Visual Flight Rules")] +type TRuleContent251 = 'GContextFree TContent251 +type TVariation609 = 'GElement 2 2 TRuleContent251 +type TRuleVariation597 = 'GContextFree TVariation609 +type TNonSpare1069 = 'GNonSpare "FR1FR2" "Flight Rules" TRuleVariation597 +type TItem365 = 'GItem TNonSpare1069 +type TVariation1167 = 'GGroup 0 '[ TItem385, TItem365, TItem908, TItem425, TItem29] +type TRuleVariation1120 = 'GContextFree TVariation1167 +type TNonSpare1052 = 'GNonSpare "FLIGHTCAT" "Flight Category" TRuleVariation1120 +type TVariation1571 = 'GCompound '[ 'Just TNonSpare1065, 'Just TNonSpare903, 'Just TNonSpare1197, 'Just TNonSpare1052, 'Just TNonSpare2047, 'Just TNonSpare2258, 'Just TNonSpare619, 'Just TNonSpare620, 'Just TNonSpare1784, 'Just TNonSpare792, 'Just TNonSpare775, 'Just TNonSpare2048, 'Just TNonSpare692, 'Just TNonSpare1961] +type TRuleVariation1487 = 'GContextFree TVariation1571 +type TNonSpare532 = 'GNonSpare "390" "Flight Plan Related Data" TRuleVariation1487 +type TUapItem532 = 'GUapItem TNonSpare532 +type TRecord55 = 'GRecord '[ TUapItem48, TUapItem14, TUapItem62, TUapItem357, TUapItem162, TUapItem164, TUapItem432, TUapItem434, TUapItem198, TUapItem474, TUapItem531, TUapItem383, TUapItem404, TUapItem507, TUapItem550, TUapItem266, TUapItem279, TUapItem277, TUapItem445, TUapItem499, TUapItem532, TUapItem516, TUapItem520, TUapItem562, TUapItem574, TUapItem582, TUapItem586, TUapItem596, TUapItem594] +type TUap49 = 'GUap TRecord55 +type TAsterix14 = 'GAsterixBasic 11 ('GEdition 1 3) TUap49 +type TNonSpare40 = 'GNonSpare "010" "Data Source Identifier" TRuleVariation1196 +type TUapItem40 = 'GUapItem TNonSpare40 +type TContent612 = 'GContentTable '[ '(1, "Measurement Plot"), '(2, "Measurement Track"), '(3, "Sensor Centric Plot"), '(4, "Sensor Centric Track"), '(5, "Track End Message")] +type TRuleContent610 = 'GContextFree TContent612 +type TVariation169 = 'GElement 0 7 TRuleContent610 +type TRuleVariation162 = 'GContextFree TVariation169 +type TNonSpare1446 = 'GNonSpare "MT" "Message Type" TRuleVariation162 +type TItem647 = 'GItem TNonSpare1446 +type TContent448 = 'GContentTable '[ '(0, "Periodic Report"), '(1, "Event Driven Report")] +type TRuleContent446 = 'GContextFree TContent448 +type TVariation1022 = 'GElement 7 1 TRuleContent446 +type TRuleVariation991 = 'GContextFree TVariation1022 +type TNonSpare1721 = 'GNonSpare "RG" "Report Generation" TRuleVariation991 +type TItem872 = 'GItem TNonSpare1721 +type TVariation1203 = 'GGroup 0 '[ TItem647, TItem872] +type TRuleVariation1151 = 'GContextFree TVariation1203 +type TNonSpare17 = 'GNonSpare "000" "Message Type" TRuleVariation1151 +type TUapItem17 = 'GUapItem TNonSpare17 +type TNonSpare60 = 'GNonSpare "015" "Service Identification" TRuleVariation171 +type TUapItem60 = 'GUapItem TNonSpare60 +type TContent309 = 'GContentTable '[ '(0, "Mono-Static Sensor"), '(1, "Multi-Static Sensor"), '(2, "Other"), '(3, "Unknown")] +type TRuleContent307 = 'GContextFree TContent309 +type TVariation110 = 'GElement 0 2 TRuleContent307 +type TRuleVariation110 = 'GContextFree TVariation110 +type TNonSpare1420 = 'GNonSpare "MOMU" "Mono-Static Target Report or Multi-Static Target Report" TRuleVariation110 +type TItem624 = 'GItem TNonSpare1420 +type TContent20 = 'GContentTable '[ '(0, "Actual Target Report"), '(1, "Reference Target"), '(2, "Synthetic Target"), '(3, "Simulated / Replayed Target")] +type TRuleContent20 = 'GContextFree TContent20 +type TVariation605 = 'GElement 2 2 TRuleContent20 +type TRuleVariation593 = 'GContextFree TVariation605 +type TNonSpare2118 = 'GNonSpare "TTAX" "Target Taxonomy" TRuleVariation593 +type TItem1149 = 'GItem TNonSpare2118 +type TContent573 = 'GContentTable '[ '(0, "Unknown"), '(1, "Forward"), '(2, "Backward"), '(3, "Static")] +type TRuleContent571 = 'GContextFree TContent573 +type TVariation799 = 'GElement 4 2 TRuleContent571 +type TRuleVariation787 = 'GContextFree TVariation799 +type TNonSpare1809 = 'GNonSpare "SCD" "Scanning Direction" TRuleVariation787 +type TItem927 = 'GItem TNonSpare1809 +type TVariation1436 = 'GExtended '[ 'Just TItem624, 'Just TItem1149, 'Just TItem927, 'Just TItem26, 'Nothing] +type TRuleVariation1352 = 'GContextFree TVariation1436 +type TNonSpare85 = 'GNonSpare "020" "Target Report Descriptor" TRuleVariation1352 +type TUapItem85 = 'GUapItem TNonSpare85 +type TNonSpare119 = 'GNonSpare "030" "Warning/Error Conditions" TRuleVariation1449 +type TUapItem119 = 'GUapItem TNonSpare119 +type TNonSpare361 = 'GNonSpare "145" "Time of Applicability" TRuleVariation377 +type TUapItem361 = 'GUapItem TNonSpare361 +type TContent648 = 'GContentInteger 'GUnsigned +type TRuleContent646 = 'GContextFree TContent648 +type TVariation271 = 'GElement 0 16 TRuleContent646 +type TRuleVariation263 = 'GContextFree TVariation271 +type TNonSpare390 = 'GNonSpare "161" "Track/Plot Number" TRuleVariation263 +type TUapItem390 = 'GUapItem TNonSpare390 +type TContent505 = 'GContentTable '[ '(0, "Target not in Blind Zone"), '(1, "Target in Blind Zone")] +type TRuleContent503 = 'GContextFree TContent505 +type TVariation86 = 'GElement 0 1 TRuleContent503 +type TRuleVariation86 = 'GContextFree TVariation86 +type TNonSpare745 = 'GNonSpare "BIZ" "" TRuleVariation86 +type TItem134 = 'GItem TNonSpare745 +type TContent504 = 'GContentTable '[ '(0, "Target not in Blanked Zone"), '(1, "Target in Blanked Zone")] +type TRuleContent502 = 'GContextFree TContent504 +type TVariation469 = 'GElement 1 1 TRuleContent502 +type TRuleVariation457 = 'GContextFree TVariation469 +type TNonSpare727 = 'GNonSpare "BAZ" "" TRuleVariation457 +type TItem117 = 'GItem TNonSpare727 +type TContent535 = 'GContentTable '[ '(0, "Track Alive"), '(1, "Track Terminated by User Request")] +type TRuleContent533 = 'GContextFree TContent535 +type TVariation600 = 'GElement 2 1 TRuleContent533 +type TRuleVariation588 = 'GContextFree TVariation600 +type TNonSpare2125 = 'GNonSpare "TUR" "" TRuleVariation588 +type TItem1156 = 'GItem TNonSpare2125 +type TContent420 = 'GContentTable '[ '(0, "Not extrapolated"), '(1, "Extrapolated")] +type TRuleContent418 = 'GContextFree TContent420 +type TVariation769 = 'GElement 4 1 TRuleContent418 +type TRuleVariation757 = 'GContextFree TVariation769 +type TNonSpare914 = 'GNonSpare "CSTP" "Coasted - Position" TRuleVariation757 +type TItem244 = 'GItem TNonSpare914 +type TVariation896 = 'GElement 5 1 TRuleContent418 +type TRuleVariation865 = 'GContextFree TVariation896 +type TNonSpare913 = 'GNonSpare "CSTH" "Coasted – Height" TRuleVariation865 +type TItem243 = 'GItem TNonSpare913 +type TVariation936 = 'GElement 6 1 TRuleContent65 +type TRuleVariation905 = 'GContextFree TVariation936 +type TNonSpare818 = 'GNonSpare "CNF" "Confirmed vs. Tentative Track" TRuleVariation905 +type TItem184 = 'GItem TNonSpare818 +type TVariation1419 = 'GExtended '[ 'Just TItem134, 'Just TItem117, 'Just TItem1156, 'Just TItem16, 'Just TItem244, 'Just TItem243, 'Just TItem184, 'Nothing] +type TRuleVariation1335 = 'GContextFree TVariation1419 +type TNonSpare405 = 'GNonSpare "170" "Track/Plot Status" TRuleVariation1335 +type TUapItem405 = 'GUapItem TNonSpare405 +type TContent802 = 'GContentQuantity 'GUnsigned ('GNumDiv ('GNumInt ('GZ 'GPlus 1)) ('GNumPow ('GZ 'GPlus 2) ('GZ 'GPlus 7))) "s" +type TRuleContent799 = 'GContextFree TContent802 +type TVariation631 = 'GElement 2 14 TRuleContent799 +type TRuleVariation619 = 'GContextFree TVariation631 +type TNonSpare2162 = 'GNonSpare "UPD" "Update Period" TRuleVariation619 +type TItem1189 = 'GItem TNonSpare2162 +type TVariation1049 = 'GGroup 0 '[ TItem1, TItem1189] +type TRuleVariation1018 = 'GContextFree TVariation1049 +type TNonSpare190 = 'GNonSpare "050" "Update Period" TRuleVariation1018 +type TUapItem190 = 'GUapItem TNonSpare190 +type TContent773 = 'GContentQuantity 'GUnsigned ('GNumDiv ('GNumInt ('GZ 'GPlus 1)) ('GNumInt ('GZ 'GPlus 100))) "m" +type TRuleContent771 = 'GContextFree TContent773 +type TVariation329 = 'GElement 0 16 TRuleContent771 +type TRuleVariation321 = 'GContextFree TVariation329 +type TNonSpare1248 = 'GNonSpare "LEN" "Target Length" TRuleVariation321 +type TNonSpare2250 = 'GNonSpare "WDT" "Target Width" TRuleVariation321 +type TNonSpare1148 = 'GNonSpare "HGT" "Target Height" TRuleVariation321 +type TContent827 = 'GContentQuantity 'GUnsigned ('GNumDiv ('GNumInt ('GZ 'GPlus 360)) ('GNumPow ('GZ 'GPlus 2) ('GZ 'GPlus 16))) "°" +type TRuleContent824 = 'GContextFree TContent827 +type TVariation360 = 'GElement 0 16 TRuleContent824 +type TRuleVariation352 = 'GContextFree TVariation360 +type TNonSpare1522 = 'GNonSpare "ORT" "Target Orientation" TRuleVariation352 +type TVariation1577 = 'GCompound '[ 'Just TNonSpare1248, 'Just TNonSpare2250, 'Just TNonSpare1148, 'Just TNonSpare1522] +type TRuleVariation1493 = 'GContextFree TVariation1577 +type TNonSpare496 = 'GNonSpare "270" "Target Size & Orientation" TRuleVariation1493 +type TUapItem496 = 'GUapItem TNonSpare496 +type TVariation260 = 'GElement 0 9 TRuleContent638 +type TRuleVariation252 = 'GContextFree TVariation260 +type TNonSpare809 = 'GNonSpare "CLS" "Classification" TRuleVariation252 +type TItem176 = 'GItem TNonSpare809 +type TVariation514 = 'GElement 1 7 TRuleContent638 +type TRuleVariation502 = 'GContextFree TVariation514 +type TNonSpare1581 = 'GNonSpare "PRB" "Probability" TRuleVariation502 +type TItem756 = 'GItem TNonSpare1581 +type TVariation1119 = 'GGroup 0 '[ TItem176, TItem756] +type TVariation1495 = 'GRepetitive ('GRepetitiveRegular 1) TVariation1119 +type TRuleVariation1411 = 'GContextFree TVariation1495 +type TNonSpare514 = 'GNonSpare "300" "Object Classification" TRuleVariation1411 +type TUapItem514 = 'GUapItem TNonSpare514 +type TNonSpare1549 = 'GNonSpare "PID" "Pair Identifier" TRuleVariation262 +type TItem738 = 'GItem TNonSpare1549 +type TVariation365 = 'GElement 0 24 TRuleContent638 +type TRuleVariation357 = 'GContextFree TVariation365 +type TNonSpare1515 = 'GNonSpare "ON" "Observation Number" TRuleVariation357 +type TItem710 = 'GItem TNonSpare1515 +type TVariation1217 = 'GGroup 0 '[ TItem738, TItem710] +type TRuleVariation1164 = 'GContextFree TVariation1217 +type TNonSpare541 = 'GNonSpare "400" "Measurement Identifier" TRuleVariation1164 +type TUapItem539 = 'GUapItem TNonSpare541 +type TContent732 = 'GContentQuantity 'GSigned ('GNumDiv ('GNumInt ('GZ 'GPlus 180)) ('GNumPow ('GZ 'GPlus 2) ('GZ 'GPlus 31))) "°" +type TRuleContent730 = 'GContextFree TContent732 +type TVariation396 = 'GElement 0 32 TRuleContent730 +type TRuleVariation388 = 'GContextFree TVariation396 +type TNonSpare1243 = 'GNonSpare "LATITUDE" "" TRuleVariation388 +type TItem499 = 'GItem TNonSpare1243 +type TNonSpare1277 = 'GNonSpare "LONGITUDE" "" TRuleVariation387 +type TItem531 = 'GItem TNonSpare1277 +type TVariation1194 = 'GGroup 0 '[ TItem499, TItem531] +type TRuleVariation1145 = 'GContextFree TVariation1194 +type TNonSpare1535 = 'GNonSpare "P84" "Horizontal Position in WGS-84 Coordinates" TRuleVariation1145 +type TContent763 = 'GContentQuantity 'GUnsigned ('GNumDiv ('GNumInt ('GZ 'GPlus 1)) ('GNumInt ('GZ 'GPlus 2))) "m" +type TRuleContent761 = 'GContextFree TContent763 +type TVariation326 = 'GElement 0 16 TRuleContent761 +type TRuleVariation318 = 'GContextFree TVariation326 +type TNonSpare1758 = 'GNonSpare "RSHPX" "" TRuleVariation318 +type TItem897 = 'GItem TNonSpare1758 +type TNonSpare1759 = 'GNonSpare "RSHPY" "" TRuleVariation318 +type TItem898 = 'GItem TNonSpare1759 +type TContent704 = 'GContentQuantity 'GSigned ('GNumDiv ('GNumInt ('GZ 'GPlus 1)) ('GNumPow ('GZ 'GPlus 2) ('GZ 'GPlus 7))) "" +type TRuleContent702 = 'GContextFree TContent704 +type TVariation228 = 'GElement 0 8 TRuleContent702 +type TRuleVariation220 = 'GContextFree TVariation228 +type TNonSpare864 = 'GNonSpare "CORSHPXY" "" TRuleVariation220 +type TItem211 = 'GItem TNonSpare864 +type TVariation1247 = 'GGroup 0 '[ TItem897, TItem898, TItem211] +type TRuleVariation1192 = 'GContextFree TVariation1247 +type TNonSpare1158 = 'GNonSpare "HPR" "Horizontal Position Resolution" TRuleVariation1192 +type TContent786 = 'GContentQuantity 'GUnsigned ('GNumDiv ('GNumInt ('GZ 'GPlus 1)) ('GNumPow ('GZ 'GPlus 2) ('GZ 'GPlus 2))) "m" +type TRuleContent783 = 'GContextFree TContent786 +type TVariation339 = 'GElement 0 16 TRuleContent783 +type TRuleVariation331 = 'GContextFree TVariation339 +type TNonSpare1827 = 'GNonSpare "SDHPX" "" TRuleVariation331 +type TItem935 = 'GItem TNonSpare1827 +type TNonSpare1828 = 'GNonSpare "SDHPY" "" TRuleVariation331 +type TItem936 = 'GItem TNonSpare1828 +type TNonSpare866 = 'GNonSpare "COSDHPXY" "" TRuleVariation220 +type TItem213 = 'GItem TNonSpare866 +type TVariation1266 = 'GGroup 0 '[ TItem935, TItem936, TItem213] +type TRuleVariation1205 = 'GContextFree TVariation1266 +type TNonSpare1154 = 'GNonSpare "HPP" "Horizontal Position Precision" TRuleVariation1205 +type TVariation1582 = 'GCompound '[ 'Just TNonSpare1535, 'Just TNonSpare1158, 'Just TNonSpare1154] +type TRuleVariation1498 = 'GContextFree TVariation1582 +type TNonSpare577 = 'GNonSpare "600" "Horizontal Position Information" TRuleVariation1498 +type TUapItem575 = 'GUapItem TNonSpare577 +type TContent673 = 'GContentQuantity 'GSigned ('GNumDiv ('GNumInt ('GZ 'GPlus 1)) ('GNumInt ('GZ 'GPlus 100))) "m" +type TRuleContent671 = 'GContextFree TContent673 +type TVariation370 = 'GElement 0 24 TRuleContent671 +type TRuleVariation362 = 'GContextFree TVariation370 +type TNonSpare1111 = 'GNonSpare "GH" "Geometric Height (WGS-84)" TRuleVariation362 +type TContent774 = 'GContentQuantity 'GUnsigned ('GNumDiv ('GNumInt ('GZ 'GPlus 1)) ('GNumInt ('GZ 'GPlus 100))) "m" +type TRuleContent772 = 'GContextFree TContent774 +type TVariation383 = 'GElement 0 24 TRuleContent772 +type TRuleVariation375 = 'GContextFree TVariation383 +type TNonSpare1757 = 'GNonSpare "RSGH" "Geometric Height Resolution" TRuleVariation375 +type TNonSpare1824 = 'GNonSpare "SDGH" "Geometric Height Precision" TRuleVariation375 +type TContent757 = 'GContentQuantity 'GUnsigned ('GNumInt ('GZ 'GPlus 16)) "m" +type TRuleContent755 = 'GContextFree TContent757 +type TVariation262 = 'GElement 0 12 TRuleContent755 +type TRuleVariation254 = 'GContextFree TVariation262 +type TNonSpare2157 = 'GNonSpare "UCI6" "" TRuleVariation254 +type TItem1184 = 'GItem TNonSpare2157 +type TVariation840 = 'GElement 4 12 TRuleContent755 +type TRuleVariation809 = 'GContextFree TVariation840 +type TNonSpare1244 = 'GNonSpare "LCI6" "" TRuleVariation809 +type TItem500 = 'GItem TNonSpare1244 +type TVariation1310 = 'GGroup 0 '[ TItem1184, TItem500] +type TRuleVariation1234 = 'GContextFree TVariation1310 +type TNonSpare804 = 'GNonSpare "CI6" "Confidence Interval for Geometric Height (67%)" TRuleVariation1234 +type TNonSpare2158 = 'GNonSpare "UCI9" "" TRuleVariation254 +type TItem1185 = 'GItem TNonSpare2158 +type TNonSpare1245 = 'GNonSpare "LCI9" "" TRuleVariation809 +type TItem501 = 'GItem TNonSpare1245 +type TVariation1311 = 'GGroup 0 '[ TItem1185, TItem501] +type TRuleVariation1235 = 'GContextFree TVariation1311 +type TNonSpare805 = 'GNonSpare "CI9" "Confidence Interval for Geometric Height (95%)" TRuleVariation1235 +type TNonSpare2261 = 'GNonSpare "X" "" TRuleVariation220 +type TItem1277 = 'GItem TNonSpare2261 +type TNonSpare2315 = 'GNonSpare "Y" "" TRuleVariation220 +type TItem1327 = 'GItem TNonSpare2315 +type TVariation1350 = 'GGroup 0 '[ TItem1277, TItem1327] +type TRuleVariation1274 = 'GContextFree TVariation1350 +type TNonSpare830 = 'GNonSpare "COGHHP" "Correlation of Geometric Height and Horizontal Position" TRuleVariation1274 +type TNonSpare2262 = 'GNonSpare "X" "" TRuleVariation220 +type TItem1278 = 'GItem TNonSpare2262 +type TNonSpare2316 = 'GNonSpare "Y" "" TRuleVariation220 +type TItem1328 = 'GItem TNonSpare2316 +type TVariation1351 = 'GGroup 0 '[ TItem1278, TItem1328] +type TRuleVariation1275 = 'GContextFree TVariation1351 +type TNonSpare831 = 'GNonSpare "COGHHV" "Correlation of Geometric Height and Horizontal Velocity" TRuleVariation1275 +type TNonSpare2260 = 'GNonSpare "X" "" TRuleVariation220 +type TItem1276 = 'GItem TNonSpare2260 +type TNonSpare2314 = 'GNonSpare "Y" "" TRuleVariation220 +type TItem1326 = 'GItem TNonSpare2314 +type TVariation1349 = 'GGroup 0 '[ TItem1276, TItem1326] +type TRuleVariation1273 = 'GContextFree TVariation1349 +type TNonSpare829 = 'GNonSpare "COGHHA" "Correlation of Geometric Height and Horizontal Acceleration" TRuleVariation1273 +type TVariation1573 = 'GCompound '[ 'Just TNonSpare1111, 'Just TNonSpare1757, 'Just TNonSpare1824, 'Just TNonSpare804, 'Just TNonSpare805, 'Just TNonSpare830, 'Just TNonSpare831, 'Just TNonSpare829] +type TRuleVariation1489 = 'GContextFree TVariation1573 +type TNonSpare580 = 'GNonSpare "601" "Geometric Height Information" TRuleVariation1489 +type TUapItem578 = 'GUapItem TNonSpare580 +type TContent675 = 'GContentQuantity 'GSigned ('GNumDiv ('GNumInt ('GZ 'GPlus 1)) ('GNumInt ('GZ 'GPlus 100))) "m/s" +type TRuleContent673 = 'GContextFree TContent675 +type TVariation362 = 'GElement 0 20 TRuleContent673 +type TRuleVariation354 = 'GContextFree TVariation362 +type TNonSpare2273 = 'GNonSpare "X" "" TRuleVariation354 +type TItem1289 = 'GItem TNonSpare2273 +type TVariation844 = 'GElement 4 20 TRuleContent673 +type TRuleVariation813 = 'GContextFree TVariation844 +type TNonSpare2327 = 'GNonSpare "Y" "" TRuleVariation813 +type TItem1339 = 'GItem TNonSpare2327 +type TVariation1362 = 'GGroup 0 '[ TItem1289, TItem1339] +type TRuleVariation1286 = 'GContextFree TVariation1362 +type TNonSpare1162 = 'GNonSpare "HV" "Horizontal Velocity Vector" TRuleVariation1286 +type TContent775 = 'GContentQuantity 'GUnsigned ('GNumDiv ('GNumInt ('GZ 'GPlus 1)) ('GNumInt ('GZ 'GPlus 100))) "m/s" +type TRuleContent773 = 'GContextFree TContent775 +type TVariation330 = 'GElement 0 16 TRuleContent773 +type TRuleVariation322 = 'GContextFree TVariation330 +type TNonSpare2271 = 'GNonSpare "X" "" TRuleVariation322 +type TItem1287 = 'GItem TNonSpare2271 +type TNonSpare2323 = 'GNonSpare "Y" "" TRuleVariation322 +type TItem1335 = 'GItem TNonSpare2323 +type TNonSpare865 = 'GNonSpare "CORSHVXY" "" TRuleVariation220 +type TItem212 = 'GItem TNonSpare865 +type TVariation1360 = 'GGroup 0 '[ TItem1287, TItem1335, TItem212] +type TRuleVariation1284 = 'GContextFree TVariation1360 +type TNonSpare1760 = 'GNonSpare "RSHV" "Horizontal Velocity Resolution" TRuleVariation1284 +type TNonSpare2272 = 'GNonSpare "X" "" TRuleVariation322 +type TItem1288 = 'GItem TNonSpare2272 +type TNonSpare2324 = 'GNonSpare "Y" "" TRuleVariation322 +type TItem1336 = 'GItem TNonSpare2324 +type TNonSpare845 = 'GNonSpare "COHVXY" "" TRuleVariation220 +type TItem199 = 'GItem TNonSpare845 +type TVariation1361 = 'GGroup 0 '[ TItem1288, TItem1336, TItem199] +type TRuleVariation1285 = 'GContextFree TVariation1361 +type TNonSpare1829 = 'GNonSpare "SDHV" "Horizontal Velocity Precision" TRuleVariation1285 +type TNonSpare843 = 'GNonSpare "COHVXHPX" "" TRuleVariation220 +type TItem197 = 'GItem TNonSpare843 +type TNonSpare844 = 'GNonSpare "COHVXHPY" "" TRuleVariation220 +type TItem198 = 'GItem TNonSpare844 +type TNonSpare846 = 'GNonSpare "COHVYHPX" "" TRuleVariation220 +type TItem200 = 'GItem TNonSpare846 +type TNonSpare847 = 'GNonSpare "COHVYHPY" "" TRuleVariation220 +type TItem201 = 'GItem TNonSpare847 +type TVariation1122 = 'GGroup 0 '[ TItem197, TItem198, TItem200, TItem201] +type TRuleVariation1077 = 'GContextFree TVariation1122 +type TNonSpare842 = 'GNonSpare "COHVHP" "Correlation of Horizontal Velocity and Horizontal Position" TRuleVariation1077 +type TVariation1575 = 'GCompound '[ 'Just TNonSpare1162, 'Just TNonSpare1760, 'Just TNonSpare1829, 'Just TNonSpare842] +type TRuleVariation1491 = 'GContextFree TVariation1575 +type TNonSpare581 = 'GNonSpare "602" "Horizontal Velocity Information" TRuleVariation1491 +type TUapItem579 = 'GUapItem TNonSpare581 +type TContent698 = 'GContentQuantity 'GSigned ('GNumDiv ('GNumInt ('GZ 'GPlus 1)) ('GNumPow ('GZ 'GPlus 2) ('GZ 'GPlus 4))) "m/s²" +type TRuleContent696 = 'GContextFree TContent698 +type TVariation261 = 'GElement 0 12 TRuleContent696 +type TRuleVariation253 = 'GContextFree TVariation261 +type TNonSpare2269 = 'GNonSpare "X" "" TRuleVariation253 +type TItem1285 = 'GItem TNonSpare2269 +type TVariation839 = 'GElement 4 12 TRuleContent696 +type TRuleVariation808 = 'GContextFree TVariation839 +type TNonSpare2325 = 'GNonSpare "Y" "" TRuleVariation808 +type TItem1337 = 'GItem TNonSpare2325 +type TVariation1358 = 'GGroup 0 '[ TItem1285, TItem1337] +type TRuleVariation1282 = 'GContextFree TVariation1358 +type TNonSpare1131 = 'GNonSpare "HA" "Horizontal Acceleration Vector" TRuleVariation1282 +type TContent793 = 'GContentQuantity 'GUnsigned ('GNumDiv ('GNumInt ('GZ 'GPlus 1)) ('GNumPow ('GZ 'GPlus 2) ('GZ 'GPlus 4))) "m/s²" +type TRuleContent790 = 'GContextFree TContent793 +type TVariation263 = 'GElement 0 12 TRuleContent790 +type TRuleVariation255 = 'GContextFree TVariation263 +type TNonSpare2270 = 'GNonSpare "X" "" TRuleVariation255 +type TItem1286 = 'GItem TNonSpare2270 +type TVariation843 = 'GElement 4 12 TRuleContent790 +type TRuleVariation812 = 'GContextFree TVariation843 +type TNonSpare2326 = 'GNonSpare "Y" "" TRuleVariation812 +type TItem1338 = 'GItem TNonSpare2326 +type TNonSpare838 = 'GNonSpare "COHAXY" "" TRuleVariation220 +type TItem193 = 'GItem TNonSpare838 +type TVariation1359 = 'GGroup 0 '[ TItem1286, TItem1338, TItem193] +type TRuleVariation1283 = 'GContextFree TVariation1359 +type TNonSpare1826 = 'GNonSpare "SDHA" "Horizontal Acceleration Precision" TRuleVariation1283 +type TNonSpare834 = 'GNonSpare "COHAXHPX" "" TRuleVariation220 +type TItem189 = 'GItem TNonSpare834 +type TNonSpare835 = 'GNonSpare "COHAXHPY" "" TRuleVariation220 +type TItem190 = 'GItem TNonSpare835 +type TNonSpare839 = 'GNonSpare "COHAYHPX" "" TRuleVariation220 +type TItem194 = 'GItem TNonSpare839 +type TNonSpare819 = 'GNonSpare "COAYHPY" "" TRuleVariation220 +type TItem185 = 'GItem TNonSpare819 +type TVariation1120 = 'GGroup 0 '[ TItem189, TItem190, TItem194, TItem185] +type TRuleVariation1075 = 'GContextFree TVariation1120 +type TNonSpare832 = 'GNonSpare "COHAHP" "Correlation of Horizontal Acceleration and Horizontal Position" TRuleVariation1075 +type TNonSpare836 = 'GNonSpare "COHAXHVX" "" TRuleVariation220 +type TItem191 = 'GItem TNonSpare836 +type TNonSpare837 = 'GNonSpare "COHAXHVY" "" TRuleVariation220 +type TItem192 = 'GItem TNonSpare837 +type TNonSpare840 = 'GNonSpare "COHAYHVX" "" TRuleVariation220 +type TItem195 = 'GItem TNonSpare840 +type TNonSpare841 = 'GNonSpare "COHAYHVY" "" TRuleVariation220 +type TItem196 = 'GItem TNonSpare841 +type TVariation1121 = 'GGroup 0 '[ TItem191, TItem192, TItem195, TItem196] +type TRuleVariation1076 = 'GContextFree TVariation1121 +type TNonSpare833 = 'GNonSpare "COHAHV" "Correlation of Horizontal Acceleration and Horizontal Velocity" TRuleVariation1076 +type TVariation1574 = 'GCompound '[ 'Just TNonSpare1131, 'Just TNonSpare1826, 'Just TNonSpare832, 'Just TNonSpare833] +type TRuleVariation1490 = 'GContextFree TVariation1574 +type TNonSpare582 = 'GNonSpare "603" "Horizontal Acceleration Information" TRuleVariation1490 +type TUapItem580 = 'GUapItem TNonSpare582 +type TContent674 = 'GContentQuantity 'GSigned ('GNumDiv ('GNumInt ('GZ 'GPlus 1)) ('GNumInt ('GZ 'GPlus 100))) "m/s" +type TRuleContent672 = 'GContextFree TContent674 +type TVariation371 = 'GElement 0 24 TRuleContent672 +type TRuleVariation363 = 'GContextFree TVariation371 +type TNonSpare2236 = 'GNonSpare "VV" "Vertical Velocity" TRuleVariation363 +type TNonSpare1767 = 'GNonSpare "RSVV" "Vertical Velocity Resolution" TRuleVariation322 +type TNonSpare1838 = 'GNonSpare "SDVV" "" TRuleVariation322 +type TItem941 = 'GItem TNonSpare1838 +type TNonSpare877 = 'GNonSpare "COVVGH" "" TRuleVariation220 +type TItem220 = 'GItem TNonSpare877 +type TVariation1270 = 'GGroup 0 '[ TItem941, TItem220] +type TRuleVariation1209 = 'GContextFree TVariation1270 +type TNonSpare1839 = 'GNonSpare "SDVV" "Vertical Velocity Precision" TRuleVariation1209 +type TNonSpare2266 = 'GNonSpare "X" "" TRuleVariation220 +type TItem1282 = 'GItem TNonSpare2266 +type TNonSpare2321 = 'GNonSpare "Y" "" TRuleVariation220 +type TItem1333 = 'GItem TNonSpare2321 +type TVariation1355 = 'GGroup 0 '[ TItem1282, TItem1333] +type TRuleVariation1279 = 'GContextFree TVariation1355 +type TNonSpare879 = 'GNonSpare "COVVHP" "Correlation of Vertical Velocity and Horizontal Position" TRuleVariation1279 +type TNonSpare2267 = 'GNonSpare "X" "" TRuleVariation220 +type TItem1283 = 'GItem TNonSpare2267 +type TNonSpare2322 = 'GNonSpare "Y" "" TRuleVariation220 +type TItem1334 = 'GItem TNonSpare2322 +type TVariation1356 = 'GGroup 0 '[ TItem1283, TItem1334] +type TRuleVariation1280 = 'GContextFree TVariation1356 +type TNonSpare880 = 'GNonSpare "COVVHV" "Correlation of Vertical Velocity and Horizontal Velocity" TRuleVariation1280 +type TNonSpare2268 = 'GNonSpare "X" "" TRuleVariation220 +type TItem1284 = 'GItem TNonSpare2268 +type TNonSpare2320 = 'GNonSpare "Y" "" TRuleVariation220 +type TItem1332 = 'GItem TNonSpare2320 +type TVariation1357 = 'GGroup 0 '[ TItem1284, TItem1332] +type TRuleVariation1281 = 'GContextFree TVariation1357 +type TNonSpare878 = 'GNonSpare "COVVHA" "Correlation of Vertical Velocity and Horizontal Acceleration" TRuleVariation1281 +type TVariation1607 = 'GCompound '[ 'Just TNonSpare2236, 'Just TNonSpare1767, 'Just TNonSpare1839, 'Just TNonSpare879, 'Just TNonSpare880, 'Just TNonSpare878] +type TRuleVariation1523 = 'GContextFree TVariation1607 +type TNonSpare583 = 'GNonSpare "604" "Vertical Velocity Information" TRuleVariation1523 +type TUapItem581 = 'GUapItem TNonSpare583 +type TContent676 = 'GContentQuantity 'GSigned ('GNumDiv ('GNumInt ('GZ 'GPlus 1)) ('GNumInt ('GZ 'GPlus 100))) "m/s²" +type TRuleContent674 = 'GContextFree TContent676 +type TVariation282 = 'GElement 0 16 TRuleContent674 +type TRuleVariation274 = 'GContextFree TVariation282 +type TNonSpare2168 = 'GNonSpare "VA" "Vertical Acceleration" TRuleVariation274 +type TContent777 = 'GContentQuantity 'GUnsigned ('GNumDiv ('GNumInt ('GZ 'GPlus 1)) ('GNumInt ('GZ 'GPlus 100))) "m/s²" +type TRuleContent775 = 'GContextFree TContent777 +type TVariation331 = 'GElement 0 16 TRuleContent775 +type TRuleVariation323 = 'GContextFree TVariation331 +type TNonSpare1837 = 'GNonSpare "SDVA" "" TRuleVariation323 +type TItem940 = 'GItem TNonSpare1837 +type TNonSpare871 = 'GNonSpare "COVAGH" "" TRuleVariation220 +type TItem217 = 'GItem TNonSpare871 +type TNonSpare875 = 'GNonSpare "COVAVV" "" TRuleVariation220 +type TItem218 = 'GItem TNonSpare875 +type TVariation1269 = 'GGroup 0 '[ TItem940, TItem217, TItem218] +type TRuleVariation1208 = 'GContextFree TVariation1269 +type TNonSpare1766 = 'GNonSpare "RSVA" "Vertical Acceleration Precision" TRuleVariation1208 +type TNonSpare2264 = 'GNonSpare "X" "" TRuleVariation220 +type TItem1280 = 'GItem TNonSpare2264 +type TNonSpare2318 = 'GNonSpare "Y" "" TRuleVariation220 +type TItem1330 = 'GItem TNonSpare2318 +type TVariation1353 = 'GGroup 0 '[ TItem1280, TItem1330] +type TRuleVariation1277 = 'GContextFree TVariation1353 +type TNonSpare873 = 'GNonSpare "COVAHP" "Correlation of Vertical Acceleration and Horizontal Position" TRuleVariation1277 +type TNonSpare2265 = 'GNonSpare "X" "" TRuleVariation220 +type TItem1281 = 'GItem TNonSpare2265 +type TNonSpare2319 = 'GNonSpare "Y" "" TRuleVariation220 +type TItem1331 = 'GItem TNonSpare2319 +type TVariation1354 = 'GGroup 0 '[ TItem1281, TItem1331] +type TRuleVariation1278 = 'GContextFree TVariation1354 +type TNonSpare874 = 'GNonSpare "COVAHV" "Correlation of Vertical Acceleration and Horizontal Velocity" TRuleVariation1278 +type TNonSpare2263 = 'GNonSpare "X" "" TRuleVariation220 +type TItem1279 = 'GItem TNonSpare2263 +type TNonSpare2317 = 'GNonSpare "Y" "" TRuleVariation220 +type TItem1329 = 'GItem TNonSpare2317 +type TVariation1352 = 'GGroup 0 '[ TItem1279, TItem1329] +type TRuleVariation1276 = 'GContextFree TVariation1352 +type TNonSpare872 = 'GNonSpare "COVAHA" "Correlation of Vertical Acceleration and Horizontal Acceleration" TRuleVariation1276 +type TVariation1606 = 'GCompound '[ 'Just TNonSpare2168, 'Just TNonSpare1766, 'Just TNonSpare873, 'Just TNonSpare874, 'Just TNonSpare872] +type TRuleVariation1522 = 'GContextFree TVariation1606 +type TNonSpare585 = 'GNonSpare "605" "Vertical Velocity Information" TRuleVariation1522 +type TUapItem583 = 'GUapItem TNonSpare585 +type TVariation402 = 'GElement 0 40 TRuleContent0 +type TVariation1478 = 'GRepetitive ('GRepetitiveRegular 1) TVariation402 +type TRuleVariation1394 = 'GContextFree TVariation1478 +type TNonSpare560 = 'GNonSpare "480" "Associations" TRuleVariation1394 +type TUapItem558 = 'GUapItem TNonSpare560 +type TContent668 = 'GContentQuantity 'GSigned ('GNumDiv ('GNumInt ('GZ 'GPlus 1)) ('GNumInt ('GZ 'GPlus 10))) "m" +type TRuleContent666 = 'GContextFree TContent668 +type TVariation368 = 'GElement 0 24 TRuleContent666 +type TRuleVariation360 = 'GContextFree TVariation368 +type TNonSpare1658 = 'GNonSpare "R" "Range" TRuleVariation360 +type TContent767 = 'GContentQuantity 'GUnsigned ('GNumDiv ('GNumInt ('GZ 'GPlus 1)) ('GNumInt ('GZ 'GPlus 10))) "m" +type TRuleContent765 = 'GContextFree TContent767 +type TVariation381 = 'GElement 0 24 TRuleContent765 +type TRuleVariation373 = 'GContextFree TVariation381 +type TNonSpare1763 = 'GNonSpare "RSR" "Range Resolution" TRuleVariation373 +type TNonSpare1831 = 'GNonSpare "SDR" "Range Precision" TRuleVariation373 +type TContent670 = 'GContentQuantity 'GSigned ('GNumDiv ('GNumInt ('GZ 'GPlus 1)) ('GNumInt ('GZ 'GPlus 10))) "m/s" +type TRuleContent668 = 'GContextFree TContent670 +type TVariation369 = 'GElement 0 24 TRuleContent668 +type TRuleVariation361 = 'GContextFree TVariation369 +type TNonSpare1748 = 'GNonSpare "RR" "Range Rate" TRuleVariation361 +type TContent769 = 'GContentQuantity 'GUnsigned ('GNumDiv ('GNumInt ('GZ 'GPlus 1)) ('GNumInt ('GZ 'GPlus 10))) "m/s" +type TRuleContent767 = 'GContextFree TContent769 +type TVariation382 = 'GElement 0 24 TRuleContent767 +type TRuleVariation374 = 'GContextFree TVariation382 +type TNonSpare1764 = 'GNonSpare "RSRR" "Range Rate Resolution" TRuleVariation374 +type TNonSpare1834 = 'GNonSpare "SDRR" "" TRuleVariation374 +type TItem938 = 'GItem TNonSpare1834 +type TNonSpare863 = 'GNonSpare "CORRR" "" TRuleVariation220 +type TItem210 = 'GItem TNonSpare863 +type TVariation1268 = 'GGroup 0 '[ TItem938, TItem210] +type TRuleVariation1207 = 'GContextFree TVariation1268 +type TNonSpare1835 = 'GNonSpare "SDRR" "Range Rate Precision" TRuleVariation1207 +type TContent703 = 'GContentQuantity 'GSigned ('GNumDiv ('GNumInt ('GZ 'GPlus 1)) ('GNumPow ('GZ 'GPlus 2) ('GZ 'GPlus 6))) "m/s²" +type TRuleContent701 = 'GContextFree TContent703 +type TVariation299 = 'GElement 0 16 TRuleContent701 +type TRuleVariation291 = 'GContextFree TVariation299 +type TNonSpare1660 = 'GNonSpare "RA" "Range Acceleration" TRuleVariation291 +type TContent799 = 'GContentQuantity 'GUnsigned ('GNumDiv ('GNumInt ('GZ 'GPlus 1)) ('GNumPow ('GZ 'GPlus 2) ('GZ 'GPlus 7))) "m/s²" +type TRuleContent796 = 'GContextFree TContent799 +type TVariation347 = 'GElement 0 16 TRuleContent796 +type TRuleVariation339 = 'GContextFree TVariation347 +type TNonSpare1832 = 'GNonSpare "SDRA" "" TRuleVariation339 +type TItem937 = 'GItem TNonSpare1832 +type TNonSpare861 = 'GNonSpare "CORAR" "" TRuleVariation220 +type TItem208 = 'GItem TNonSpare861 +type TNonSpare862 = 'GNonSpare "CORARR" "" TRuleVariation220 +type TItem209 = 'GItem TNonSpare862 +type TVariation1267 = 'GGroup 0 '[ TItem937, TItem208, TItem209] +type TRuleVariation1206 = 'GContextFree TVariation1267 +type TNonSpare1833 = 'GNonSpare "SDRA" "Range Acceleration Precision" TRuleVariation1206 +type TVariation1589 = 'GCompound '[ 'Just TNonSpare1658, 'Just TNonSpare1763, 'Just TNonSpare1831, 'Just TNonSpare1748, 'Just TNonSpare1764, 'Just TNonSpare1835, 'Just TNonSpare1660, 'Just TNonSpare1833] +type TRuleVariation1505 = 'GContextFree TVariation1589 +type TNonSpare590 = 'GNonSpare "625" "Range Information" TRuleVariation1505 +type TUapItem588 = 'GUapItem TNonSpare590 +type TNonSpare984 = 'GNonSpare "DV" "Doppler Velocity" TRuleVariation363 +type TContent794 = 'GContentQuantity 'GUnsigned ('GNumDiv ('GNumInt ('GZ 'GPlus 1)) ('GNumPow ('GZ 'GPlus 2) ('GZ 'GPlus 6))) "m/s" +type TRuleContent791 = 'GContextFree TContent794 +type TVariation342 = 'GElement 0 16 TRuleContent791 +type TRuleVariation334 = 'GContextFree TVariation342 +type TNonSpare1820 = 'GNonSpare "SDDV" "Precision of Doppler Velocity" TRuleVariation334 +type TNonSpare927 = 'GNonSpare "DA" "Doppler Acceleration" TRuleVariation291 +type TContent795 = 'GContentQuantity 'GUnsigned ('GNumDiv ('GNumInt ('GZ 'GPlus 1)) ('GNumPow ('GZ 'GPlus 2) ('GZ 'GPlus 6))) "m/s²" +type TRuleContent792 = 'GContextFree TContent795 +type TVariation343 = 'GElement 0 16 TRuleContent792 +type TRuleVariation335 = 'GContextFree TVariation343 +type TNonSpare1818 = 'GNonSpare "SDDA" "" TRuleVariation335 +type TItem933 = 'GItem TNonSpare1818 +type TNonSpare821 = 'GNonSpare "CODADV" "" TRuleVariation220 +type TItem187 = 'GItem TNonSpare821 +type TVariation1264 = 'GGroup 0 '[ TItem933, TItem187] +type TRuleVariation1203 = 'GContextFree TVariation1264 +type TNonSpare1819 = 'GNonSpare "SDDA" "Precision of Doppler Acceleration" TRuleVariation1203 +type TNonSpare825 = 'GNonSpare "CODVR" "Correlation of Doppler Velocity and Range" TRuleVariation220 +type TNonSpare827 = 'GNonSpare "CODVRR" "Correlation of Doppler Velocity and Range Rate" TRuleVariation220 +type TNonSpare826 = 'GNonSpare "CODVRA" "Correlation of Doppler Velocity and Range Acceleration" TRuleVariation220 +type TNonSpare822 = 'GNonSpare "CODAR" "Correlation of Doppler Acceleration and Range" TRuleVariation220 +type TNonSpare824 = 'GNonSpare "CODARR" "Correlation of Doppler Acceleration and Range Rate" TRuleVariation220 +type TNonSpare823 = 'GNonSpare "CODARA" "Correlation of Doppler Acceleration and Range Acceleration" TRuleVariation220 +type TVariation1569 = 'GCompound '[ 'Just TNonSpare984, 'Just TNonSpare1820, 'Just TNonSpare927, 'Just TNonSpare1819, 'Just TNonSpare825, 'Just TNonSpare827, 'Just TNonSpare826, 'Just TNonSpare822, 'Just TNonSpare824, 'Just TNonSpare823] +type TRuleVariation1485 = 'GContextFree TVariation1569 +type TNonSpare591 = 'GNonSpare "626" "Doppler Information" TRuleVariation1485 +type TUapItem589 = 'GUapItem TNonSpare591 +type TContent826 = 'GContentQuantity 'GUnsigned ('GNumDiv ('GNumInt ('GZ 'GPlus 360)) ('GNumPow ('GZ 'GPlus 2) ('GZ 'GPlus 16))) "°" +type TRuleContent823 = 'GContextFree TContent826 +type TVariation359 = 'GElement 0 16 TRuleContent823 +type TRuleVariation351 = 'GContextFree TVariation359 +type TNonSpare717 = 'GNonSpare "AZ" "Azimuth" TRuleVariation351 +type TContent817 = 'GContentQuantity 'GUnsigned ('GNumDiv ('GNumInt ('GZ 'GPlus 45)) ('GNumPow ('GZ 'GPlus 2) ('GZ 'GPlus 16))) "°" +type TRuleContent814 = 'GContextFree TContent817 +type TVariation354 = 'GElement 0 16 TRuleContent814 +type TRuleVariation346 = 'GContextFree TVariation354 +type TNonSpare1755 = 'GNonSpare "RSAZ" "Azimuth Resolution" TRuleVariation346 +type TNonSpare1815 = 'GNonSpare "SDASZ" "Standard Deviation of Azimuth" TRuleVariation346 +type TContent718 = 'GContentQuantity 'GSigned ('GNumDiv ('GNumInt ('GZ 'GPlus 180)) ('GNumPow ('GZ 'GPlus 2) ('GZ 'GPlus 16))) "°" +type TRuleContent716 = 'GContextFree TContent718 +type TVariation309 = 'GElement 0 16 TRuleContent716 +type TRuleVariation301 = 'GContextFree TVariation309 +type TNonSpare721 = 'GNonSpare "AZR" "Azimuth Rate" TRuleVariation301 +type TNonSpare1816 = 'GNonSpare "SDAZR" "" TRuleVariation346 +type TItem932 = 'GItem TNonSpare1816 +type TNonSpare820 = 'GNonSpare "COAZRAZ" "" TRuleVariation220 +type TItem186 = 'GItem TNonSpare820 +type TVariation1263 = 'GGroup 0 '[ TItem932, TItem186] +type TRuleVariation1202 = 'GContextFree TVariation1263 +type TNonSpare1817 = 'GNonSpare "SDAZR" "Standard Deviation of Azimuth Rate" TRuleVariation1202 +type TNonSpare1786 = 'GNonSpare "S" "" TRuleVariation352 +type TItem913 = 'GItem TNonSpare1786 +type TNonSpare986 = 'GNonSpare "E" "" TRuleVariation352 +type TItem303 = 'GItem TNonSpare986 +type TVariation1251 = 'GGroup 0 '[ TItem913, TItem303] +type TRuleVariation1195 = 'GContextFree TVariation1251 +type TNonSpare719 = 'GNonSpare "AZEX" "Azimuth Extent" TRuleVariation1195 +type TVariation1560 = 'GCompound '[ 'Just TNonSpare717, 'Just TNonSpare1755, 'Just TNonSpare1815, 'Just TNonSpare721, 'Just TNonSpare1817, 'Just TNonSpare719] +type TRuleVariation1476 = 'GContextFree TVariation1560 +type TNonSpare592 = 'GNonSpare "627" "Azimuth Information" TRuleVariation1476 +type TUapItem590 = 'GUapItem TNonSpare592 +type TNonSpare990 = 'GNonSpare "EL" "Elevation" TRuleVariation301 +type TNonSpare1756 = 'GNonSpare "RSEL" "Elevation Resolution" TRuleVariation346 +type TNonSpare1821 = 'GNonSpare "SDEL" "Standard Deviation of Elevation" TRuleVariation346 +type TContent720 = 'GContentQuantity 'GSigned ('GNumDiv ('GNumInt ('GZ 'GPlus 180)) ('GNumPow ('GZ 'GPlus 2) ('GZ 'GPlus 16))) "°/s" +type TRuleContent718 = 'GContextFree TContent720 +type TVariation311 = 'GElement 0 16 TRuleContent718 +type TRuleVariation303 = 'GContextFree TVariation311 +type TNonSpare1030 = 'GNonSpare "ER" "Elevation Rate" TRuleVariation303 +type TContent818 = 'GContentQuantity 'GUnsigned ('GNumDiv ('GNumInt ('GZ 'GPlus 45)) ('GNumPow ('GZ 'GPlus 2) ('GZ 'GPlus 16))) "°/s" +type TRuleContent815 = 'GContextFree TContent818 +type TVariation355 = 'GElement 0 16 TRuleContent815 +type TRuleVariation347 = 'GContextFree TVariation355 +type TNonSpare1822 = 'GNonSpare "SDELR" "" TRuleVariation347 +type TItem934 = 'GItem TNonSpare1822 +type TNonSpare828 = 'GNonSpare "COELREL" "" TRuleVariation220 +type TItem188 = 'GItem TNonSpare828 +type TVariation1265 = 'GGroup 0 '[ TItem934, TItem188] +type TRuleVariation1204 = 'GContextFree TVariation1265 +type TNonSpare1823 = 'GNonSpare "SDER" "Standard Deviation of Elevation Rate" TRuleVariation1204 +type TNonSpare1785 = 'GNonSpare "S" "" TRuleVariation301 +type TItem912 = 'GItem TNonSpare1785 +type TNonSpare985 = 'GNonSpare "E" "" TRuleVariation301 +type TItem302 = 'GItem TNonSpare985 +type TVariation1250 = 'GGroup 0 '[ TItem912, TItem302] +type TRuleVariation1194 = 'GContextFree TVariation1250 +type TNonSpare992 = 'GNonSpare "ELEX" "Elevation Extent" TRuleVariation1194 +type TVariation1570 = 'GCompound '[ 'Just TNonSpare990, 'Just TNonSpare1756, 'Just TNonSpare1821, 'Just TNonSpare1030, 'Just TNonSpare1823, 'Just TNonSpare992] +type TRuleVariation1486 = 'GContextFree TVariation1570 +type TNonSpare593 = 'GNonSpare "628" "Elevation Information" TRuleVariation1486 +type TUapItem591 = 'GUapItem TNonSpare593 +type TContent651 = 'GContentQuantity 'GSigned ('GNumInt ('GZ 'GPlus 1)) "dB" +type TRuleContent649 = 'GContextFree TContent651 +type TVariation221 = 'GElement 0 8 TRuleContent649 +type TRuleVariation213 = 'GContextFree TVariation221 +type TNonSpare965 = 'GNonSpare "DPP" "Direct Path - Power" TRuleVariation213 +type TNonSpare966 = 'GNonSpare "DPS" "Direct Path - Signal to Noise Ratio (SNR)" TRuleVariation213 +type TContent650 = 'GContentQuantity 'GSigned ('GNumInt ('GZ 'GPlus 1)) "dB" +type TRuleContent648 = 'GContextFree TContent650 +type TVariation1030 = 'GElement 7 9 TRuleContent648 +type TRuleVariation999 = 'GContextFree TVariation1030 +type TNonSpare1745 = 'GNonSpare "RPP" "" TRuleVariation999 +type TItem890 = 'GItem TNonSpare1745 +type TVariation1086 = 'GGroup 0 '[ TItem6, TItem890] +type TRuleVariation1053 = 'GContextFree TVariation1086 +type TNonSpare1746 = 'GNonSpare "RPP" "Reflected Path - Power" TRuleVariation1053 +type TNonSpare1747 = 'GNonSpare "RPS" "Reflected Path - Signal to Noise Ratio (SNR)" TRuleVariation213 +type TVariation1568 = 'GCompound '[ 'Just TNonSpare965, 'Just TNonSpare966, 'Just TNonSpare1746, 'Just TNonSpare1747] +type TRuleVariation1484 = 'GContextFree TVariation1568 +type TNonSpare594 = 'GNonSpare "630" "Path Quality" TRuleVariation1484 +type TUapItem592 = 'GUapItem TNonSpare594 +type TNonSpare718 = 'GNonSpare "AZCON" "" TRuleVariation351 +type TItem110 = 'GItem TNonSpare718 +type TContent719 = 'GContentQuantity 'GSigned ('GNumDiv ('GNumInt ('GZ 'GPlus 180)) ('GNumPow ('GZ 'GPlus 2) ('GZ 'GPlus 16))) "°" +type TRuleContent717 = 'GContextFree TContent719 +type TVariation310 = 'GElement 0 16 TRuleContent717 +type TRuleVariation302 = 'GContextFree TVariation310 +type TNonSpare991 = 'GNonSpare "ELCON" "" TRuleVariation302 +type TItem306 = 'GItem TNonSpare991 +type TContent828 = 'GContentQuantity 'GUnsigned ('GNumDiv ('GNumInt ('GZ 'GPlus 10000)) ('GNumPow ('GZ 'GPlus 2) ('GZ 'GPlus 16))) "m" +type TRuleContent825 = 'GContextFree TContent828 +type TVariation361 = 'GElement 0 16 TRuleContent825 +type TRuleVariation353 = 'GContextFree TVariation361 +type TNonSpare1723 = 'GNonSpare "RGCONSTOP" "" TRuleVariation353 +type TItem874 = 'GItem TNonSpare1723 +type TNonSpare1722 = 'GNonSpare "RGCONSTART" "" TRuleVariation353 +type TItem873 = 'GItem TNonSpare1722 +type TVariation1103 = 'GGroup 0 '[ TItem110, TItem306, TItem874, TItem873] +type TVariation1485 = 'GRepetitive ('GRepetitiveRegular 1) TVariation1103 +type TRuleVariation1401 = 'GContextFree TVariation1485 +type TNonSpare595 = 'GNonSpare "631" "Contour (Azimuth, Elevation Angle, Range Extent)" TRuleVariation1401 +type TUapItem593 = 'GUapItem TNonSpare595 +type TRecord39 = 'GRecord '[ TUapItem40, TUapItem17, TUapItem60, TUapItem85, TUapItem119, TUapItem361, TUapItem390, TUapItem405, TUapItem190, TUapItem496, TUapItem514, TUapItem539, TUapItem575, TUapItem578, TUapItem579, TUapItem580, TUapItem581, TUapItem583, TUapItem558, TUapItem588, TUapItem589, TUapItem590, TUapItem591, TUapItem592, TUapItem593, TUapItem596] +type TUap33 = 'GUap TRecord39 +type TAsterix15 = 'GAsterixBasic 15 ('GEdition 1 0) TUap33 +type TAsterix16 = 'GAsterixBasic 15 ('GEdition 1 1) TUap33 +type TAsterix17 = 'GAsterixBasic 15 ('GEdition 1 2) TUap33 +type TNonSpare31 = 'GNonSpare "010" "Data Source Identifier" TRuleVariation1196 +type TUapItem31 = 'GUapItem TNonSpare31 +type TNonSpare67 = 'GNonSpare "015" "Service Identification" TRuleVariation171 +type TUapItem67 = 'GUapItem TNonSpare67 +type TContent624 = 'GContentTable '[ '(1, "System Configuration"), '(2, "Transmitter / Receiver Configuration")] +type TRuleContent622 = 'GContextFree TContent624 +type TVariation210 = 'GElement 0 8 TRuleContent622 +type TRuleVariation202 = 'GContextFree TVariation210 +type TNonSpare11 = 'GNonSpare "000" "Message Type" TRuleVariation202 +type TUapItem11 = 'GUapItem TNonSpare11 +type TNonSpare349 = 'GNonSpare "140" "Time of Day" TRuleVariation376 +type TUapItem349 = 'GUapItem TNonSpare349 +type TContent754 = 'GContentQuantity 'GUnsigned ('GNumInt ('GZ 'GPlus 1)) "s" +type TRuleContent752 = 'GContextFree TContent754 +type TVariation238 = 'GElement 0 8 TRuleContent752 +type TRuleVariation230 = 'GContextFree TVariation238 +type TNonSpare423 = 'GNonSpare "200" "System Configuration Reporting Period" TRuleVariation230 +type TUapItem423 = 'GUapItem TNonSpare423 +type TNonSpare1548 = 'GNonSpare "PID" "Pair Identification" TRuleVariation259 +type TItem737 = 'GItem TNonSpare1548 +type TNonSpare2035 = 'GNonSpare "TID" "Transmitter Identification" TRuleVariation259 +type TItem1086 = 'GItem TNonSpare2035 +type TNonSpare1731 = 'GNonSpare "RID" "Receiver Identification" TRuleVariation259 +type TItem882 = 'GItem TNonSpare1731 +type TVariation1216 = 'GGroup 0 '[ TItem737, TItem1086, TItem882] +type TVariation1503 = 'GRepetitive ('GRepetitiveRegular 1) TVariation1216 +type TRuleVariation1419 = 'GContextFree TVariation1503 +type TNonSpare515 = 'GNonSpare "300" "Pair Identification" TRuleVariation1419 +type TUapItem515 = 'GUapItem TNonSpare515 +type TNonSpare542 = 'GNonSpare "400" "Position of the System Reference Point" TRuleVariation1137 +type TUapItem540 = 'GUapItem TNonSpare542 +type TContent687 = 'GContentQuantity 'GSigned ('GNumDiv ('GNumInt ('GZ 'GPlus 1)) ('GNumPow ('GZ 'GPlus 2) ('GZ 'GPlus 2))) "m" +type TRuleContent685 = 'GContextFree TContent687 +type TVariation290 = 'GElement 0 16 TRuleContent685 +type TRuleVariation282 = 'GContextFree TVariation290 +type TNonSpare544 = 'GNonSpare "405" "Height of System Reference Point" TRuleVariation282 +type TUapItem542 = 'GUapItem TNonSpare544 +type TNonSpare2034 = 'GNonSpare "TID" "Transmitter ID" TRuleVariation259 +type TItem1085 = 'GItem TNonSpare2034 +type TNonSpare642 = 'GNonSpare "ALT" "Altitude" TRuleVariation282 +type TItem61 = 'GItem TNonSpare642 +type TContent658 = 'GContentQuantity 'GSigned ('GNumInt ('GZ 'GPlus 2)) "ns" +type TRuleContent656 = 'GContextFree TContent658 +type TVariation390 = 'GElement 0 32 TRuleContent656 +type TRuleVariation382 = 'GContextFree TVariation390 +type TNonSpare2123 = 'GNonSpare "TTO" "Transmission Time Offset" TRuleVariation382 +type TItem1154 = 'GItem TNonSpare2123 +type TContent752 = 'GContentQuantity 'GUnsigned ('GNumInt ('GZ 'GPlus 1)) "ns" +type TRuleContent750 = 'GContextFree TContent752 +type TVariation845 = 'GElement 4 20 TRuleContent750 +type TRuleVariation814 = 'GContextFree TVariation845 +type TNonSpare696 = 'GNonSpare "ATO" "Accuracy of Transmission Time Offset" TRuleVariation814 +type TItem92 = 'GItem TNonSpare696 +type TNonSpare1542 = 'GNonSpare "PCI" "Parallel Transmitter Index" TRuleVariation262 +type TItem733 = 'GItem TNonSpare1542 +type TVariation1289 = 'GGroup 0 '[ TItem1085, TItem490, TItem521, TItem61, TItem1154, TItem3, TItem92, TItem733] +type TVariation1517 = 'GRepetitive ('GRepetitiveRegular 1) TVariation1289 +type TRuleVariation1433 = 'GContextFree TVariation1517 +type TNonSpare547 = 'GNonSpare "410" "Transmitter Properties" TRuleVariation1433 +type TUapItem545 = 'GUapItem TNonSpare547 +type TNonSpare1730 = 'GNonSpare "RID" "Receiver Component ID" TRuleVariation259 +type TItem881 = 'GItem TNonSpare1730 +type TVariation1243 = 'GGroup 0 '[ TItem881, TItem490, TItem521, TItem61] +type TVariation1505 = 'GRepetitive ('GRepetitiveRegular 1) TVariation1243 +type TRuleVariation1421 = 'GContextFree TVariation1505 +type TNonSpare551 = 'GNonSpare "420" "Receiver Properties" TRuleVariation1421 +type TUapItem549 = 'GUapItem TNonSpare551 +type TRecord11 = 'GRecord '[ TUapItem31, TUapItem67, TUapItem11, TUapItem349, TUapItem423, TUapItem515, TUapItem540, TUapItem542, TUapItem545, TUapItem549, TUapItem596] +type TUap11 = 'GUap TRecord11 +type TAsterix18 = 'GAsterixBasic 16 ('GEdition 1 0) TUap11 +type TNonSpare41 = 'GNonSpare "010" "Data Source Identifier" TRuleVariation1196 +type TUapItem41 = 'GUapItem TNonSpare41 +type TNonSpare54 = 'GNonSpare "012" "Data Destination Identifier" TRuleVariation1196 +type TUapItem54 = 'GUapItem TNonSpare54 +type TContent315 = 'GContentTable '[ '(0, "Network information"), '(10, "Track data"), '(20, "Track data request"), '(21, "Track data stop"), '(22, "Cancel track data request"), '(23, "Track data stop acknowledgement"), '(30, "New Node / Change-over Initial or intermediate message segment"), '(31, "New Node / Change-over Final or only message segment"), '(32, "New Node / Change-over Initial or intermediate message segment reply"), '(33, "New Node / Change-over Final or only message segment reply"), '(110, "Move node to new cluster state;"), '(111, "Move node to new cluster state acknowledgement")] +type TRuleContent313 = 'GContextFree TContent315 +type TVariation183 = 'GElement 0 8 TRuleContent313 +type TRuleVariation176 = 'GContextFree TVariation183 +type TNonSpare1 = 'GNonSpare "000" "Message Type" TRuleVariation176 +type TUapItem1 = 'GUapItem TNonSpare1 +type TNonSpare523 = 'GNonSpare "350" "Cluster Station/Node List" TRuleVariation1424 +type TUapItem523 = 'GUapItem TNonSpare523 +type TNonSpare446 = 'GNonSpare "220" "Aircraft Address" TRuleVariation355 +type TUapItem446 = 'GUapItem TNonSpare446 +type TNonSpare456 = 'GNonSpare "221" "Duplicate Address Reference Number (DRN)" TRuleVariation259 +type TUapItem456 = 'GUapItem TNonSpare456 +type TNonSpare356 = 'GNonSpare "140" "Time of Day" TRuleVariation377 +type TUapItem356 = 'GUapItem TNonSpare356 +type TVariation378 = 'GElement 0 24 TRuleContent725 +type TRuleVariation370 = 'GContextFree TVariation378 +type TNonSpare1231 = 'GNonSpare "LAT" "Latitude" TRuleVariation370 +type TItem487 = 'GItem TNonSpare1231 +type TVariation377 = 'GElement 0 24 TRuleContent724 +type TRuleVariation369 = 'GContextFree TVariation377 +type TNonSpare1264 = 'GNonSpare "LON" "Longitude" TRuleVariation369 +type TItem518 = 'GItem TNonSpare1264 +type TVariation1183 = 'GGroup 0 '[ TItem487, TItem518] +type TRuleVariation1134 = 'GContextFree TVariation1183 +type TNonSpare172 = 'GNonSpare "045" "Calculated Position in WGS-84 Coordinates" TRuleVariation1134 +type TUapItem172 = 'GUapItem TNonSpare172 +type TContent305 = 'GContentTable '[ '(0, "Mode-3/A code derived from the reply of the transponder"), '(1, "Smoothed Mode-3/A code not extracted during the last scan")] +type TRuleContent303 = 'GContextFree TContent305 +type TVariation574 = 'GElement 2 1 TRuleContent303 +type TRuleVariation562 = 'GContextFree TVariation574 +type TNonSpare1224 = 'GNonSpare "L" "" TRuleVariation562 +type TItem480 = 'GItem TNonSpare1224 +type TNonSpare1415 = 'GNonSpare "MODE3A" "Mode 3/A Reply in Octal Representation" TRuleVariation807 +type TItem619 = 'GItem TNonSpare1415 +type TVariation1331 = 'GGroup 0 '[ TItem1191, TItem377, TItem480, TItem16, TItem619] +type TRuleVariation1255 = 'GContextFree TVariation1331 +type TNonSpare220 = 'GNonSpare "070" "Mode 3/A Code in Octal Representation" TRuleVariation1255 +type TUapItem220 = 'GUapItem TNonSpare220 +type TContent103 = 'GContentTable '[ '(0, "Default"), '(1, "Garbled code / Error correction applied")] +type TRuleContent103 = 'GContextFree TContent103 +type TVariation422 = 'GElement 1 1 TRuleContent103 +type TRuleVariation410 = 'GContextFree TVariation422 +type TNonSpare1085 = 'GNonSpare "G" "" TRuleVariation410 +type TItem378 = 'GItem TNonSpare1085 +type TVariation630 = 'GElement 2 14 TRuleContent779 +type TRuleVariation618 = 'GContextFree TVariation630 +type TNonSpare643 = 'GNonSpare "ALT" "Altitude" TRuleVariation618 +type TItem62 = 'GItem TNonSpare643 +type TVariation1332 = 'GGroup 0 '[ TItem1191, TItem378, TItem62] +type TRuleVariation1256 = 'GContextFree TVariation1332 +type TNonSpare177 = 'GNonSpare "050" "Flight Level in Binary Representation" TRuleVariation1256 +type TUapItem177 = 'GUapItem TNonSpare177 +type TNonSpare429 = 'GNonSpare "200" "Track Velocity in Polar Co-ordinates" TRuleVariation1123 +type TUapItem429 = 'GUapItem TNonSpare429 +type TContent356 = 'GContentTable '[ '(0, "No communications capability (surveillance only), no ability to set CA code 7 either airborne or on the ground"), '(1, "Reserved"), '(2, "Reserved"), '(3, "Reserved"), '(4, "At Least Comm. A and Comm. B capability and the ability to set CA code 7 and on the ground"), '(5, "At Least Comm. A and Comm. B capability and the ability to set CA code 7 and airborne"), '(6, "At Least Comm. A and Comm. B capability and the ability to set CA code 7 and either airborne or on the ground"), '(7, "Signifies the DR field is not equal to 0 or the FS field equals 2, 3, 4 or 5 and either airborne or on the ground SI/II-capabilities of the Transponder")] +type TRuleContent354 = 'GContextFree TContent356 +type TVariation133 = 'GElement 0 3 TRuleContent354 +type TRuleVariation133 = 'GContextFree TVariation133 +type TNonSpare759 = 'GNonSpare "CA" "Communications Capability of the Transponder" TRuleVariation133 +type TItem141 = 'GItem TNonSpare759 +type TContent549 = 'GContentTable '[ '(0, "Transponder SI capable"), '(1, "Transponder not SI capable")] +type TRuleContent547 = 'GContextFree TContent549 +type TVariation691 = 'GElement 3 1 TRuleContent547 +type TRuleVariation679 = 'GContextFree TVariation691 +type TNonSpare1849 = 'GNonSpare "SI" "SI/II-capabilities of the Transponder" TRuleVariation679 +type TItem949 = 'GItem TNonSpare1849 +type TVariation1110 = 'GGroup 0 '[ TItem141, TItem949, TItem22] +type TRuleVariation1070 = 'GContextFree TVariation1110 +type TNonSpare465 = 'GNonSpare "230" "Transponder Capability" TRuleVariation1070 +type TUapItem465 = 'GUapItem TNonSpare465 +type TContent277 = 'GContentTable '[ '(0, "Measured position"), '(1, "No measured position (coasted)")] +type TRuleContent275 = 'GContextFree TContent277 +type TVariation55 = 'GElement 0 1 TRuleContent275 +type TRuleVariation55 = 'GContextFree TVariation55 +type TNonSpare912 = 'GNonSpare "CST" "Track Coasted" TRuleVariation55 +type TItem242 = 'GItem TNonSpare912 +type TContent265 = 'GContentTable '[ '(0, "Last Measured Flight Level"), '(1, "Predicted Flight Level")] +type TRuleContent263 = 'GContextFree TContent265 +type TVariation450 = 'GElement 1 1 TRuleContent263 +type TRuleVariation438 = 'GContextFree TVariation450 +type TNonSpare1054 = 'GNonSpare "FLT" "Flight Level Tracking" TRuleVariation438 +type TItem355 = 'GItem TNonSpare1054 +type TVariation1131 = 'GGroup 0 '[ TItem242, TItem355, TItem15] +type TRuleVariation1086 = 'GContextFree TVariation1131 +type TNonSpare470 = 'GNonSpare "240" "Track Status" TRuleVariation1086 +type TUapItem470 = 'GUapItem TNonSpare470 +type TVariation1473 = 'GRepetitive ('GRepetitiveRegular 1) TVariation363 +type TRuleVariation1389 = 'GContextFree TVariation1473 +type TNonSpare441 = 'GNonSpare "210" "Mode S Address List" TRuleVariation1389 +type TUapItem441 = 'GUapItem TNonSpare441 +type TNonSpare524 = 'GNonSpare "360" "Cluster Controller Command State" TRuleVariation171 +type TUapItem524 = 'GUapItem TNonSpare524 +type TRecord40 = 'GRecord '[ TUapItem41, TUapItem54, TUapItem1, TUapItem523, TUapItem446, TUapItem456, TUapItem356, TUapItem172, TUapItem220, TUapItem177, TUapItem429, TUapItem465, TUapItem470, TUapItem441, TUapItem524, TUapItem598, TUapItem598, TUapItem598, TUapItem598, TUapItem598, TUapItem596] +type TUap34 = 'GUap TRecord40 +type TAsterix19 = 'GAsterixBasic 17 ('GEdition 1 3) TUap34 +type TNonSpare137 = 'GNonSpare "036" "Data Source Identifier" TRuleVariation1196 +type TUapItem137 = 'GUapItem TNonSpare137 +type TNonSpare139 = 'GNonSpare "037" "Data Destination Identifier" TRuleVariation1196 +type TUapItem139 = 'GUapItem TNonSpare139 +type TContent40 = 'GContentTable '[ '(0, "Associate_req"), '(1, "Associate_resp"), '(2, "Release_req"), '(3, "Release_resp"), '(4, "Abort_req"), '(5, "Keep_alive"), '(16, "Aircraft_report"), '(17, "Aircraft_command"), '(18, "II_code_change"), '(32, "Uplink_packet"), '(33, "Cancel_uplink_packet"), '(34, "Uplink_packet_ack"), '(35, "Downlink_packet"), '(38, "Data_XON"), '(39, "Data_XOFF"), '(48, "Uplink_broadcast"), '(49, "Cancel_uplink_broadcast"), '(50, "Uplink_broadcast_ack"), '(52, "Downlink_broadcast"), '(64, "GICB_extraction"), '(65, "Cancel_GICB_extraction"), '(66, "GICB_extraction_ack"), '(67, "GICB_response")] +type TRuleContent40 = 'GContextFree TContent40 +type TVariation180 = 'GElement 0 8 TRuleContent40 +type TRuleVariation173 = 'GContextFree TVariation180 +type TNonSpare0 = 'GNonSpare "000" "Message Type" TRuleVariation173 +type TUapItem0 = 'GUapItem TNonSpare0 +type TContent16 = 'GContentTable '[ '(0, "Accepted, the request is accepted and is under processing"), '(1, "Rejected, the request has not been accepted"), '(2, "Cancelled, the request has been cancelled"), '(3, "Finished, the request has been accepted and successfully processed"), '(4, "Delayed, the request processing is temporarily delayed but the request is still valid"), '(5, "In Progress, the request is being successfully processed"), '(6, "In Progress, the request is being successfully processed")] +type TRuleContent16 = 'GContextFree TContent16 +type TVariation141 = 'GElement 0 4 TRuleContent16 +type TRuleVariation141 = 'GContextFree TVariation141 +type TNonSpare772 = 'GNonSpare "CAUSE" "Cause" TRuleVariation141 +type TItem150 = 'GItem TNonSpare772 +type TContent367 = 'GContentTable '[ '(0, "No diagnostic available"), '(1, "Aircraft Exit"), '(2, "Incorrect aircraft address"), '(3, "Impossibility to process the message"), '(4, "Insufficient or change in data link capability"), '(5, "Invalid LV field"), '(6, "Duplicate request number"), '(7, "Unknown request number"), '(8, "Timer T3 expiry"), '(9, "Expiry of I/R delivery timer"), '(10, "Uplink flow disabled by UC")] +type TRuleContent365 = 'GContextFree TContent367 +type TVariation829 = 'GElement 4 4 TRuleContent365 +type TRuleVariation798 = 'GContextFree TVariation829 +type TNonSpare953 = 'GNonSpare "DIAG" "Diagnostic" TRuleVariation798 +type TItem278 = 'GItem TNonSpare953 +type TVariation1112 = 'GGroup 0 '[ TItem150, TItem278] +type TRuleVariation1071 = 'GContextFree TVariation1112 +type TNonSpare20 = 'GNonSpare "001" "Result" TRuleVariation1071 +type TUapItem20 = 'GUapItem TNonSpare20 +type TNonSpare23 = 'GNonSpare "005" "Mode S Address" TRuleVariation355 +type TUapItem23 = 'GUapItem TNonSpare23 +type TVariation389 = 'GElement 0 32 TRuleContent638 +type TRuleVariation381 = 'GContextFree TVariation389 +type TNonSpare71 = 'GNonSpare "016" "Packet Number" TRuleVariation381 +type TUapItem71 = 'GUapItem TNonSpare71 +type TVariation1477 = 'GRepetitive ('GRepetitiveRegular 1) TVariation389 +type TRuleVariation1393 = 'GContextFree TVariation1477 +type TNonSpare73 = 'GNonSpare "017" "Packet Number List" TRuleVariation1393 +type TUapItem73 = 'GUapItem TNonSpare73 +type TVariation509 = 'GElement 1 5 TRuleContent638 +type TRuleVariation497 = 'GContextFree TVariation509 +type TNonSpare1579 = 'GNonSpare "PR" "Mode S Packet Internal Priority" TRuleVariation497 +type TItem754 = 'GItem TNonSpare1579 +type TContent476 = 'GContentTable '[ '(0, "SVC packets"), '(1, "MSP packets"), '(2, "Route packets")] +type TRuleContent474 = 'GContextFree TContent476 +type TVariation998 = 'GElement 6 2 TRuleContent474 +type TRuleVariation967 = 'GContextFree TVariation998 +type TNonSpare1606 = 'GNonSpare "PT" "Packet Type" TRuleVariation967 +type TItem773 = 'GItem TNonSpare1606 +type TVariation1033 = 'GGroup 0 '[ TItem0, TItem754, TItem773] +type TRuleVariation1002 = 'GContextFree TVariation1033 +type TNonSpare75 = 'GNonSpare "018" "Mode S Packet Properties" TRuleVariation1002 +type TUapItem75 = 'GUapItem TNonSpare75 +type TVariation1542 = 'GExplicit 'Nothing +type TRuleVariation1458 = 'GContextFree TVariation1542 +type TNonSpare76 = 'GNonSpare "019" "Mode S Packet" TRuleVariation1458 +type TUapItem76 = 'GUapItem TNonSpare76 +type TContent753 = 'GContentQuantity 'GUnsigned ('GNumInt ('GZ 'GPlus 1)) "s" +type TRuleContent751 = 'GContextFree TContent753 +type TVariation322 = 'GElement 0 16 TRuleContent751 +type TRuleVariation314 = 'GContextFree TVariation322 +type TNonSpare106 = 'GNonSpare "028" "GICB Extraction Periodicity" TRuleVariation314 +type TUapItem106 = 'GUapItem TNonSpare106 +type TVariation156 = 'GElement 0 5 TRuleContent638 +type TRuleVariation156 = 'GContextFree TVariation156 +type TNonSpare1590 = 'GNonSpare "PRIORITY" "GICB Priority" TRuleVariation156 +type TItem765 = 'GItem TNonSpare1590 +type TItem25 = 'GSpare 5 3 +type TContent532 = 'GContentTable '[ '(0, "The periodicity may not be strictly respected"), '(1, "The periodicity shall be strictly respected")] +type TRuleContent530 = 'GContextFree TContent532 +type TVariation92 = 'GElement 0 1 TRuleContent530 +type TRuleVariation92 = 'GContextFree TVariation92 +type TNonSpare1541 = 'GNonSpare "PC" "Periodicity Constraint" TRuleVariation92 +type TItem732 = 'GItem TNonSpare1541 +type TContent226 = 'GContentTable '[ '(0, "GICB extractions should be sent only when required by the periodicity"), '(1, "If a GICB extraction is done due to external conditions, an update will also be sent, even if it does not match the expected periodicity")] +type TRuleContent226 = 'GContextFree TContent226 +type TVariation442 = 'GElement 1 1 TRuleContent226 +type TRuleVariation430 = 'GContextFree TVariation442 +type TNonSpare700 = 'GNonSpare "AU" "Asynchronous Update" TRuleVariation430 +type TItem95 = 'GItem TNonSpare700 +type TContent513 = 'GContentTable '[ '(0, "The GICB extraction is attempted according to the periodicity"), '(1, "There will no GICB attempts")] +type TRuleContent511 = 'GContextFree TContent513 +type TVariation596 = 'GElement 2 1 TRuleContent511 +type TRuleVariation584 = 'GContextFree TVariation596 +type TNonSpare1475 = 'GNonSpare "NE" "Non Extraction" TRuleVariation584 +type TItem671 = 'GItem TNonSpare1475 +type TContent516 = 'GContentTable '[ '(0, "The extracted GICB must be sent only on the Data Link line"), '(1, "The extracted GICB must be sent only on the Surveillance line"), '(2, "The extracted GICB must be sent both on the Data Link and on the Surveillance lines")] +type TRuleContent514 = 'GContextFree TContent516 +type TVariation704 = 'GElement 3 2 TRuleContent514 +type TRuleVariation692 = 'GContextFree TVariation704 +type TNonSpare1690 = 'GNonSpare "RD" "Reply Destination" TRuleVariation692 +type TItem846 = 'GItem TNonSpare1690 +type TVariation1224 = 'GGroup 0 '[ TItem765, TItem25, TItem732, TItem95, TItem671, TItem846, TItem25] +type TRuleVariation1170 = 'GContextFree TVariation1224 +type TNonSpare108 = 'GNonSpare "030" "GICB Properties" TRuleVariation1170 +type TUapItem108 = 'GUapItem TNonSpare108 +type TNonSpare104 = 'GNonSpare "025" "GICB Number" TRuleVariation381 +type TUapItem104 = 'GUapItem TNonSpare104 +type TNonSpare105 = 'GNonSpare "027" "BDS Code" TRuleVariation171 +type TUapItem105 = 'GUapItem TNonSpare105 +type TContent830 = 'GContentBds ('GBdsAt 'Nothing) +type TRuleContent827 = 'GContextFree TContent830 +type TVariation408 = 'GElement 0 56 TRuleContent827 +type TRuleVariation399 = 'GContextFree TVariation408 +type TNonSpare107 = 'GNonSpare "029" "GICB Extracted" TRuleVariation399 +type TUapItem107 = 'GUapItem TNonSpare107 +type TNonSpare21 = 'GNonSpare "002" "Time of Day" TRuleVariation376 +type TUapItem21 = 'GUapItem TNonSpare21 +type TNonSpare24 = 'GNonSpare "006" "Mode S Address List" TRuleVariation1389 +type TUapItem24 = 'GUapItem TNonSpare24 +type TContent556 = 'GContentTable '[ '(0, "UC shall be ignored"), '(1, "UC shall be taken into account")] +type TRuleContent554 = 'GContextFree TContent556 +type TVariation98 = 'GElement 0 1 TRuleContent554 +type TRuleVariation98 = 'GContextFree TVariation98 +type TNonSpare2161 = 'GNonSpare "UM" "Uplink Mask" TRuleVariation98 +type TItem1188 = 'GItem TNonSpare2161 +type TContent76 = 'GContentTable '[ '(0, "DC shall be ignored"), '(1, "DC shall be taken into account")] +type TRuleContent76 = 'GContextFree TContent76 +type TVariation419 = 'GElement 1 1 TRuleContent76 +type TRuleVariation407 = 'GContextFree TVariation419 +type TNonSpare958 = 'GNonSpare "DM" "Downlink Mask" TRuleVariation407 +type TItem282 = 'GItem TNonSpare958 +type TContent600 = 'GContentTable '[ '(0, "the uplink flow shall be enabled"), '(1, "the uplink flow shall be stopped")] +type TRuleContent598 = 'GContextFree TContent600 +type TVariation604 = 'GElement 2 1 TRuleContent598 +type TRuleVariation592 = 'GContextFree TVariation604 +type TNonSpare2156 = 'GNonSpare "UC" "Uplink Command" TRuleVariation592 +type TItem1183 = 'GItem TNonSpare2156 +type TContent599 = 'GContentTable '[ '(0, "the downlink flow shall be enabled"), '(1, "the downlink flow shall be stopped")] +type TRuleContent597 = 'GContextFree TContent599 +type TVariation697 = 'GElement 3 1 TRuleContent597 +type TRuleVariation685 = 'GContextFree TVariation697 +type TNonSpare943 = 'GNonSpare "DC" "Downlink Command" TRuleVariation685 +type TItem269 = 'GItem TNonSpare943 +type TVariation1312 = 'GGroup 0 '[ TItem1188, TItem282, TItem1183, TItem269, TItem22] +type TRuleVariation1236 = 'GContextFree TVariation1312 +type TNonSpare25 = 'GNonSpare "007" "Aircraft Data Link Command" TRuleVariation1236 +type TUapItem25 = 'GUapItem TNonSpare25 +type TContent518 = 'GContentTable '[ '(0, "The interrogator is enabled to uplink frames"), '(1, "The interrogator is disabled to uplink frames")] +type TRuleContent516 = 'GContextFree TContent518 +type TVariation88 = 'GElement 0 1 TRuleContent516 +type TRuleVariation88 = 'GContextFree TVariation88 +type TNonSpare2160 = 'GNonSpare "UDS" "Uplink Default Status" TRuleVariation88 +type TItem1187 = 'GItem TNonSpare2160 +type TContent517 = 'GContentTable '[ '(0, "The interrogator is enabled to extract frames"), '(1, "The interrogator is disabled to extract frames")] +type TRuleContent515 = 'GContextFree TContent517 +type TVariation472 = 'GElement 1 1 TRuleContent515 +type TRuleVariation460 = 'GContextFree TVariation472 +type TNonSpare947 = 'GNonSpare "DDS" "Downlink Default Status" TRuleVariation460 +type TItem273 = 'GItem TNonSpare947 +type TVariation597 = 'GElement 2 1 TRuleContent516 +type TRuleVariation585 = 'GContextFree TVariation597 +type TNonSpare2159 = 'GNonSpare "UCS" "Uplink Current Status" TRuleVariation585 +type TItem1186 = 'GItem TNonSpare2159 +type TVariation684 = 'GElement 3 1 TRuleContent515 +type TRuleVariation672 = 'GContextFree TVariation684 +type TNonSpare946 = 'GNonSpare "DCS" "Downlink Current Status" TRuleVariation672 +type TItem272 = 'GItem TNonSpare946 +type TContent515 = 'GContentTable '[ '(0, "The aircraft is in the Datalink coverage map of the interrogator"), '(1, "The aircraft is not in the Datalink coverage map of the interrogator")] +type TRuleContent513 = 'GContextFree TContent515 +type TVariation987 = 'GElement 6 1 TRuleContent513 +type TRuleVariation956 = 'GContextFree TVariation987 +type TNonSpare989 = 'GNonSpare "EI" "Exit Indication" TRuleVariation956 +type TItem305 = 'GItem TNonSpare989 +type TContent519 = 'GContentTable '[ '(0, "The interrogators current ability to uplink/downlink frames (UCS/DCS) and the content of the Aircraft_report could be changed using D_Data_link_command"), '(1, "The interrogators current ability to uplink/downlink frames (UCS/DCS) and the content of the Aircraft_report cannot be changed using D_Data_link_command")] +type TRuleContent517 = 'GContextFree TContent519 +type TVariation89 = 'GElement 0 1 TRuleContent517 +type TRuleVariation89 = 'GContextFree TVariation89 +type TNonSpare1184 = 'GNonSpare "IC" "Interrogator Control" TRuleVariation89 +type TItem446 = 'GItem TNonSpare1184 +type TVariation1468 = 'GExtended '[ 'Just TItem1187, 'Just TItem273, 'Just TItem1186, 'Just TItem272, 'Just TItem20, 'Just TItem305, 'Nothing, 'Just TItem446, 'Just TItem9, 'Nothing] +type TRuleVariation1384 = 'GContextFree TVariation1468 +type TNonSpare26 = 'GNonSpare "008" "Aircraft Data Link Status" TRuleVariation1384 +type TUapItem26 = 'GUapItem TNonSpare26 +type TContent525 = 'GContentTable '[ '(0, "The next Aircraft_report may not include D_Data_link_status"), '(1, "The next Aircraft_report shall include D_Data_link_status")] +type TRuleContent523 = 'GContextFree TContent525 +type TVariation91 = 'GElement 0 1 TRuleContent523 +type TRuleVariation91 = 'GContextFree TVariation91 +type TNonSpare1903 = 'GNonSpare "SR" "" TRuleVariation91 +type TItem997 = 'GItem TNonSpare1903 +type TContent521 = 'GContentTable '[ '(0, "The next Aircraft_report may not include D_COM"), '(1, "The next Aircraft_report shall include D_COM")] +type TRuleContent519 = 'GContextFree TContent521 +type TVariation473 = 'GElement 1 1 TRuleContent519 +type TRuleVariation461 = 'GContextFree TVariation473 +type TNonSpare675 = 'GNonSpare "AR" "" TRuleVariation461 +type TItem82 = 'GItem TNonSpare675 +type TContent526 = 'GContentTable '[ '(0, "The next Aircraft_report may not include D_ECA"), '(1, "The next Aircraft_report shall include D_ECA")] +type TRuleContent524 = 'GContextFree TContent526 +type TVariation598 = 'GElement 2 1 TRuleContent524 +type TRuleVariation586 = 'GContextFree TVariation598 +type TNonSpare1028 = 'GNonSpare "ER" "" TRuleVariation586 +type TItem336 = 'GItem TNonSpare1028 +type TContent522 = 'GContentTable '[ '(0, "The next Aircraft_report may not include D_CQF"), '(1, "The next Aircraft_report shall include D_CQF")] +type TRuleContent520 = 'GContextFree TContent522 +type TVariation685 = 'GElement 3 1 TRuleContent520 +type TRuleVariation673 = 'GContextFree TVariation685 +type TNonSpare1066 = 'GNonSpare "FR" "" TRuleVariation673 +type TItem362 = 'GItem TNonSpare1066 +type TContent523 = 'GContentTable '[ '(0, "The next Aircraft_report may not include D_CQF_method"), '(1, "The next Aircraft_report shall include D_CQF_method")] +type TRuleContent521 = 'GContextFree TContent523 +type TVariation783 = 'GElement 4 1 TRuleContent521 +type TRuleVariation771 = 'GContextFree TVariation783 +type TNonSpare1423 = 'GNonSpare "MR" "" TRuleVariation771 +type TItem627 = 'GItem TNonSpare1423 +type TContent527 = 'GContentTable '[ '(0, "The next Aircraft_report may not include D_Polar_position"), '(1, "The next Aircraft_report shall include D_Polar_position")] +type TRuleContent525 = 'GContextFree TContent527 +type TVariation903 = 'GElement 5 1 TRuleContent525 +type TRuleVariation872 = 'GContextFree TVariation903 +type TNonSpare1578 = 'GNonSpare "PR" "" TRuleVariation872 +type TItem753 = 'GItem TNonSpare1578 +type TContent524 = 'GContentTable '[ '(0, "The next Aircraft_report may not include D_Cartesian_position"), '(1, "The next Aircraft_report shall include D_Cartesian_position")] +type TRuleContent522 = 'GContextFree TContent524 +type TVariation988 = 'GElement 6 1 TRuleContent522 +type TRuleVariation957 = 'GContextFree TVariation988 +type TNonSpare895 = 'GNonSpare "CR" "" TRuleVariation957 +type TItem229 = 'GItem TNonSpare895 +type TContent520 = 'GContentTable '[ '(0, "The next Aircraft_report may not include Aircraft_ID"), '(1, "The next Aircraft_report shall include Aircraft_ID")] +type TRuleContent518 = 'GContextFree TContent520 +type TVariation90 = 'GElement 0 1 TRuleContent518 +type TRuleVariation90 = 'GContextFree TVariation90 +type TNonSpare1186 = 'GNonSpare "ID" "" TRuleVariation90 +type TItem448 = 'GItem TNonSpare1186 +type TContent530 = 'GContentTable '[ '(0, "The next Aircraft_report may not include Mode_A"), '(1, "The next Aircraft_report shall include Mode_A")] +type TRuleContent528 = 'GContextFree TContent530 +type TVariation474 = 'GElement 1 1 TRuleContent528 +type TRuleVariation462 = 'GContextFree TVariation474 +type TNonSpare1319 = 'GNonSpare "MA" "" TRuleVariation462 +type TItem563 = 'GItem TNonSpare1319 +type TContent531 = 'GContentTable '[ '(0, "The next Aircraft_report may not include Speed"), '(1, "The next Aircraft_report shall include Speed")] +type TRuleContent529 = 'GContextFree TContent531 +type TVariation599 = 'GElement 2 1 TRuleContent529 +type TRuleVariation587 = 'GContextFree TVariation599 +type TNonSpare1887 = 'GNonSpare "SP" "" TRuleVariation587 +type TItem983 = 'GItem TNonSpare1887 +type TContent529 = 'GContentTable '[ '(0, "The next Aircraft_report may not include Height"), '(1, "The next Aircraft_report shall include Height")] +type TRuleContent527 = 'GContextFree TContent529 +type TVariation686 = 'GElement 3 1 TRuleContent527 +type TRuleVariation674 = 'GContextFree TVariation686 +type TNonSpare1144 = 'GNonSpare "HG" "" TRuleVariation674 +type TItem414 = 'GItem TNonSpare1144 +type TContent528 = 'GContentTable '[ '(0, "The next Aircraft_report may not include Heading"), '(1, "The next Aircraft_report shall include Heading")] +type TRuleContent526 = 'GContextFree TContent528 +type TVariation784 = 'GElement 4 1 TRuleContent526 +type TRuleVariation772 = 'GContextFree TVariation784 +type TNonSpare1138 = 'GNonSpare "HD" "" TRuleVariation772 +type TItem410 = 'GItem TNonSpare1138 +type TVariation1456 = 'GExtended '[ 'Just TItem997, 'Just TItem82, 'Just TItem336, 'Just TItem362, 'Just TItem627, 'Just TItem753, 'Just TItem229, 'Nothing, 'Just TItem448, 'Just TItem563, 'Just TItem983, 'Just TItem414, 'Just TItem410, 'Just TItem24, 'Nothing] +type TRuleVariation1372 = 'GContextFree TVariation1456 +type TNonSpare28 = 'GNonSpare "009" "Aircraft Data Link Report Request" TRuleVariation1372 +type TUapItem28 = 'GUapItem TNonSpare28 +type TContent352 = 'GContentTable '[ '(0, "No communications capability (surveillance only)"), '(1, "Comm. A and Comm. B capability"), '(2, "Comm. A, Comm. B and Uplink ELM"), '(3, "Comm. A, Comm. B and Uplink ELM and Downlink ELM"), '(4, "Level 5 Transponder capability")] +type TRuleContent350 = 'GContextFree TContent352 +type TVariation920 = 'GElement 5 3 TRuleContent350 +type TRuleVariation889 = 'GContextFree TVariation920 +type TNonSpare854 = 'GNonSpare "COM" "Communications Capability of the Transponder" TRuleVariation889 +type TItem205 = 'GItem TNonSpare854 +type TVariation1079 = 'GGroup 0 '[ TItem4, TItem205] +type TRuleVariation1046 = 'GContextFree TVariation1079 +type TNonSpare51 = 'GNonSpare "010" "Transponder Communications Capability" TRuleVariation1046 +type TUapItem51 = 'GUapItem TNonSpare51 +type TNonSpare52 = 'GNonSpare "011" "Capability Report" TRuleVariation397 +type TUapItem52 = 'GUapItem TNonSpare52 +type TNonSpare56 = 'GNonSpare "014" "Aircraft Position in Polar Co-ordinates" TRuleVariation1185 +type TUapItem56 = 'GUapItem TNonSpare56 +type TNonSpare57 = 'GNonSpare "015" "Aircraft Position in Cartesian Co-ordinates" TRuleVariation1301 +type TUapItem57 = 'GUapItem TNonSpare57 +type TNonSpare78 = 'GNonSpare "020" "Broadcast Number" TRuleVariation381 +type TUapItem78 = 'GUapItem TNonSpare78 +type TVariation146 = 'GElement 0 4 TRuleContent638 +type TRuleVariation146 = 'GContextFree TVariation146 +type TNonSpare1591 = 'GNonSpare "PRIORITY" "Priority" TRuleVariation146 +type TItem766 = 'GItem TNonSpare1591 +type TVariation832 = 'GElement 4 4 TRuleContent638 +type TRuleVariation801 = 'GContextFree TVariation832 +type TNonSpare1576 = 'GNonSpare "POWER" "Power" TRuleVariation801 +type TItem751 = 'GItem TNonSpare1576 +type TVariation237 = 'GElement 0 8 TRuleContent751 +type TRuleVariation229 = 'GContextFree TVariation237 +type TNonSpare983 = 'GNonSpare "DURATION" "Duration" TRuleVariation229 +type TItem301 = 'GItem TNonSpare983 +type TVariation387 = 'GElement 0 32 TRuleContent0 +type TRuleVariation379 = 'GContextFree TVariation387 +type TNonSpare876 = 'GNonSpare "COVERAGE" "Coverage" TRuleVariation379 +type TItem219 = 'GItem TNonSpare876 +type TVariation1225 = 'GGroup 0 '[ TItem766, TItem751, TItem301, TItem219] +type TRuleVariation1171 = 'GContextFree TVariation1225 +type TNonSpare100 = 'GNonSpare "021" "Broadcast Properties" TRuleVariation1171 +type TUapItem100 = 'GUapItem TNonSpare100 +type TNonSpare1585 = 'GNonSpare "PREFIX" "Prefix Field" TRuleVariation895 +type TItem760 = 'GItem TNonSpare1585 +type TVariation1081 = 'GGroup 0 '[ TItem4, TItem760] +type TRuleVariation1048 = 'GContextFree TVariation1081 +type TNonSpare101 = 'GNonSpare "022" "Broadcast Prefix" TRuleVariation1048 +type TUapItem101 = 'GUapItem TNonSpare101 +type TNonSpare102 = 'GNonSpare "023" "Uplink or Downlink Broadcast" TRuleVariation397 +type TUapItem102 = 'GUapItem TNonSpare102 +type TNonSpare1586 = 'GNonSpare "PREVIOUSII" "Former II Code" TRuleVariation140 +type TItem761 = 'GItem TNonSpare1586 +type TNonSpare918 = 'GNonSpare "CURRENTII" "Current II Code" TRuleVariation796 +type TItem247 = 'GItem TNonSpare918 +type TVariation1221 = 'GGroup 0 '[ TItem761, TItem247] +type TRuleVariation1167 = 'GContextFree TVariation1221 +type TNonSpare22 = 'GNonSpare "004" "II Code" TRuleVariation1167 +type TUapItem22 = 'GUapItem TNonSpare22 +type TVariation403 = 'GElement 0 48 TRuleContent0 +type TRuleVariation394 = 'GContextFree TVariation403 +type TNonSpare127 = 'GNonSpare "031" "Aircraft Identity" TRuleVariation394 +type TUapItem127 = 'GUapItem TNonSpare127 +type TNonSpare1407 = 'GNonSpare "MOD3A" "" TRuleVariation807 +type TItem611 = 'GItem TNonSpare1407 +type TVariation1328 = 'GGroup 0 '[ TItem1191, TItem377, TItem477, TItem16, TItem611] +type TRuleVariation1252 = 'GContextFree TVariation1328 +type TNonSpare128 = 'GNonSpare "032" "Aircraft Mode A" TRuleVariation1252 +type TUapItem128 = 'GUapItem TNonSpare128 +type TNonSpare130 = 'GNonSpare "033" "Aircraft Height" TRuleVariation1245 +type TUapItem130 = 'GUapItem TNonSpare130 +type TNonSpare131 = 'GNonSpare "034" "Aircraft Speed" TRuleVariation344 +type TUapItem131 = 'GUapItem TNonSpare131 +type TNonSpare133 = 'GNonSpare "035" "Aircraft Heading" TRuleVariation349 +type TUapItem133 = 'GUapItem TNonSpare133 +type TContent33 = 'GContentTable '[ '(0, "Aircraft is airborne"), '(1, "Aircraft is on the ground")] +type TRuleContent33 = 'GContextFree TContent33 +type TVariation11 = 'GElement 0 1 TRuleContent33 +type TRuleVariation11 = 'GContextFree TVariation11 +type TNonSpare1073 = 'GNonSpare "FS" "Flight Status" TRuleVariation11 +type TItem369 = 'GItem TNonSpare1073 +type TContent512 = 'GContentTable '[ '(0, "The CQF calculation method is not supported"), '(1, "The CQF is minimum"), '(126, "The CQF is maximum"), '(127, "The CQF is undefined according to the calculation method")] +type TRuleContent510 = 'GContextFree TContent512 +type TVariation511 = 'GElement 1 7 TRuleContent510 +type TRuleVariation499 = 'GContextFree TVariation511 +type TNonSpare894 = 'GNonSpare "CQF" "Aircraft CQF" TRuleVariation499 +type TItem228 = 'GItem TNonSpare894 +type TVariation1161 = 'GGroup 0 '[ TItem369, TItem228] +type TRuleVariation1114 = 'GContextFree TVariation1161 +type TNonSpare53 = 'GNonSpare "012" "Aircraft Coverage Quality Factor" TRuleVariation1114 +type TUapItem53 = 'GUapItem TNonSpare53 +type TNonSpare55 = 'GNonSpare "013" "Aircraft CQF Calculation Method" TRuleVariation171 +type TUapItem55 = 'GUapItem TNonSpare55 +type TRecord60 = 'GRecord '[ TUapItem137, TUapItem139, TUapItem0, TUapItem20, TUapItem23, TUapItem71, TUapItem73, TUapItem75, TUapItem76, TUapItem106, TUapItem108, TUapItem104, TUapItem105, TUapItem107, TUapItem21, TUapItem24, TUapItem25, TUapItem26, TUapItem28, TUapItem51, TUapItem52, TUapItem56, TUapItem57, TUapItem78, TUapItem100, TUapItem101, TUapItem102, TUapItem22, TUapItem127, TUapItem128, TUapItem130, TUapItem131, TUapItem133, TUapItem53, TUapItem55] +type TUap54 = 'GUap TRecord60 +type TAsterix20 = 'GAsterixBasic 18 ('GEdition 1 7) TUap54 +type TAsterix21 = 'GAsterixBasic 18 ('GEdition 1 8) TUap54 +type TNonSpare45 = 'GNonSpare "010" "Data Source Identifier" TRuleVariation1196 +type TUapItem45 = 'GUapItem TNonSpare45 +type TContent623 = 'GContentTable '[ '(1, "Start of Update Cycle"), '(2, "Periodic Status Message"), '(3, "Event-triggered Status Message")] +type TRuleContent621 = 'GContextFree TContent623 +type TVariation209 = 'GElement 0 8 TRuleContent621 +type TRuleVariation201 = 'GContextFree TVariation209 +type TNonSpare10 = 'GNonSpare "000" "Message Type" TRuleVariation201 +type TUapItem10 = 'GUapItem TNonSpare10 +type TNonSpare351 = 'GNonSpare "140" "Time of Day" TRuleVariation376 +type TUapItem351 = 'GUapItem TNonSpare351 +type TContent434 = 'GContentTable '[ '(0, "Operational"), '(1, "Degraded"), '(2, "NOGO"), '(3, "Undefined")] +type TRuleContent432 = 'GContextFree TContent434 +type TVariation114 = 'GElement 0 2 TRuleContent432 +type TRuleVariation114 = 'GContextFree TVariation114 +type TNonSpare1487 = 'GNonSpare "NOGO" "Operational Release Status of the System" TRuleVariation114 +type TItem683 = 'GItem TNonSpare1487 +type TVariation782 = 'GElement 4 1 TRuleContent509 +type TRuleVariation770 = 'GContextFree TVariation782 +type TNonSpare2120 = 'GNonSpare "TTF" "Test Target" TRuleVariation770 +type TItem1151 = 'GItem TNonSpare2120 +type TVariation1213 = 'GGroup 0 '[ TItem683, TItem721, TItem1145, TItem1151, TItem25] +type TRuleVariation1161 = 'GContextFree TVariation1213 +type TNonSpare572 = 'GNonSpare "550" "System Status" TRuleVariation1161 +type TUapItem570 = 'GUapItem TNonSpare572 +type TContent482 = 'GContentTable '[ '(0, "Standby"), '(1, "Exec")] +type TRuleContent480 = 'GContextFree TContent482 +type TVariation79 = 'GElement 0 1 TRuleContent480 +type TRuleVariation79 = 'GContextFree TVariation79 +type TNonSpare2058 = 'GNonSpare "TP1A" "" TRuleVariation79 +type TItem1098 = 'GItem TNonSpare2058 +type TContent217 = 'GContentTable '[ '(0, "Faulted"), '(1, "Good")] +type TRuleContent217 = 'GContextFree TContent217 +type TVariation440 = 'GElement 1 1 TRuleContent217 +type TRuleVariation428 = 'GContextFree TVariation440 +type TNonSpare2059 = 'GNonSpare "TP1B" "" TRuleVariation428 +type TItem1099 = 'GItem TNonSpare2059 +type TVariation594 = 'GElement 2 1 TRuleContent480 +type TRuleVariation582 = 'GContextFree TVariation594 +type TNonSpare2060 = 'GNonSpare "TP2A" "" TRuleVariation582 +type TItem1100 = 'GItem TNonSpare2060 +type TVariation660 = 'GElement 3 1 TRuleContent217 +type TRuleVariation648 = 'GContextFree TVariation660 +type TNonSpare2061 = 'GNonSpare "TP2B" "" TRuleVariation648 +type TItem1101 = 'GItem TNonSpare2061 +type TVariation779 = 'GElement 4 1 TRuleContent480 +type TRuleVariation767 = 'GContextFree TVariation779 +type TNonSpare2062 = 'GNonSpare "TP3A" "" TRuleVariation767 +type TItem1102 = 'GItem TNonSpare2062 +type TVariation879 = 'GElement 5 1 TRuleContent217 +type TRuleVariation848 = 'GContextFree TVariation879 +type TNonSpare2063 = 'GNonSpare "TP3B" "" TRuleVariation848 +type TItem1103 = 'GItem TNonSpare2063 +type TVariation983 = 'GElement 6 1 TRuleContent480 +type TRuleVariation952 = 'GContextFree TVariation983 +type TNonSpare2064 = 'GNonSpare "TP4A" "" TRuleVariation952 +type TItem1104 = 'GItem TNonSpare2064 +type TVariation1010 = 'GElement 7 1 TRuleContent217 +type TRuleVariation979 = 'GContextFree TVariation1010 +type TNonSpare2065 = 'GNonSpare "TP4B" "" TRuleVariation979 +type TItem1105 = 'GItem TNonSpare2065 +type TVariation1290 = 'GGroup 0 '[ TItem1098, TItem1099, TItem1100, TItem1101, TItem1102, TItem1103, TItem1104, TItem1105] +type TRuleVariation1224 = 'GContextFree TVariation1290 +type TNonSpare573 = 'GNonSpare "551" "Tracking Processor Detailed Status" TRuleVariation1224 +type TUapItem571 = 'GUapItem TNonSpare573 +type TNonSpare1761 = 'GNonSpare "RSI" "8-bit Identification Number of RS" TRuleVariation171 +type TItem899 = 'GItem TNonSpare1761 +type TContent422 = 'GContentTable '[ '(0, "Not present"), '(1, "Present")] +type TRuleContent420 = 'GContextFree TContent422 +type TVariation461 = 'GElement 1 1 TRuleContent420 +type TRuleVariation449 = 'GContextFree TVariation461 +type TNonSpare1754 = 'GNonSpare "RS1090" "Receiver 1090 MHz" TRuleVariation449 +type TItem896 = 'GItem TNonSpare1754 +type TVariation588 = 'GElement 2 1 TRuleContent420 +type TRuleVariation576 = 'GContextFree TVariation588 +type TNonSpare2127 = 'GNonSpare "TX1030" "Transmitter 1030 MHz" TRuleVariation576 +type TItem1157 = 'GItem TNonSpare2127 +type TVariation680 = 'GElement 3 1 TRuleContent420 +type TRuleVariation668 = 'GContextFree TVariation680 +type TNonSpare2128 = 'GNonSpare "TX1090" "Transmitter 1090 MHz" TRuleVariation668 +type TItem1158 = 'GItem TNonSpare2128 +type TVariation748 = 'GElement 4 1 TRuleContent217 +type TRuleVariation736 = 'GContextFree TVariation748 +type TNonSpare1765 = 'GNonSpare "RSS" "RS Status" TRuleVariation736 +type TItem901 = 'GItem TNonSpare1765 +type TContent431 = 'GContentTable '[ '(0, "Offline"), '(1, "Online")] +type TRuleContent429 = 'GContextFree TContent431 +type TVariation898 = 'GElement 5 1 TRuleContent429 +type TRuleVariation867 = 'GContextFree TVariation898 +type TNonSpare1762 = 'GNonSpare "RSO" "RS Operational" TRuleVariation867 +type TItem900 = 'GItem TNonSpare1762 +type TVariation1248 = 'GGroup 0 '[ TItem899, TItem0, TItem896, TItem1157, TItem1158, TItem901, TItem900, TItem27] +type TVariation1506 = 'GRepetitive ('GRepetitiveRegular 1) TVariation1248 +type TRuleVariation1422 = 'GContextFree TVariation1506 +type TNonSpare574 = 'GNonSpare "552" "Remote Sensor Detailed Status" TRuleVariation1422 +type TUapItem572 = 'GUapItem TNonSpare574 +type TContent631 = 'GContentTable '[ '(1, "Warning"), '(2, "Faulted"), '(3, "Good")] +type TRuleContent629 = 'GContextFree TContent631 +type TVariation124 = 'GElement 0 2 TRuleContent629 +type TRuleVariation124 = 'GContextFree TVariation124 +type TNonSpare1712 = 'GNonSpare "REFTR1" "Ref Trans 1 Status" TRuleVariation124 +type TItem863 = 'GItem TNonSpare1712 +type TVariation800 = 'GElement 4 2 TRuleContent629 +type TRuleVariation788 = 'GContextFree TVariation800 +type TNonSpare1713 = 'GNonSpare "REFTR2" "Ref Trans 2 Status" TRuleVariation788 +type TItem864 = 'GItem TNonSpare1713 +type TNonSpare1714 = 'GNonSpare "REFTR3" "Ref Trans 3 Status" TRuleVariation124 +type TItem865 = 'GItem TNonSpare1714 +type TNonSpare1715 = 'GNonSpare "REFTR4" "Ref Trans 4 Status" TRuleVariation788 +type TItem866 = 'GItem TNonSpare1715 +type TVariation1453 = 'GExtended '[ 'Just TItem863, 'Just TItem12, 'Just TItem864, 'Just TItem26, 'Nothing, 'Just TItem865, 'Just TItem12, 'Just TItem866, 'Just TItem26, 'Nothing] +type TRuleVariation1369 = 'GContextFree TVariation1453 +type TNonSpare575 = 'GNonSpare "553" "Reference Transponder Detailed Status" TRuleVariation1369 +type TUapItem573 = 'GUapItem TNonSpare575 +type TContent729 = 'GContentQuantity 'GSigned ('GNumDiv ('GNumInt ('GZ 'GPlus 180)) ('GNumPow ('GZ 'GPlus 2) ('GZ 'GPlus 30))) "°" +type TRuleContent727 = 'GContextFree TContent729 +type TVariation394 = 'GElement 0 32 TRuleContent727 +type TRuleVariation386 = 'GContextFree TVariation394 +type TNonSpare1233 = 'GNonSpare "LAT" "Latitude" TRuleVariation386 +type TItem489 = 'GItem TNonSpare1233 +type TContent728 = 'GContentQuantity 'GSigned ('GNumDiv ('GNumInt ('GZ 'GPlus 180)) ('GNumPow ('GZ 'GPlus 2) ('GZ 'GPlus 30))) "°" +type TRuleContent726 = 'GContextFree TContent728 +type TVariation393 = 'GElement 0 32 TRuleContent726 +type TRuleVariation385 = 'GContextFree TVariation393 +type TNonSpare1266 = 'GNonSpare "LON" "Longitude" TRuleVariation385 +type TItem520 = 'GItem TNonSpare1266 +type TVariation1185 = 'GGroup 0 '[ TItem489, TItem520] +type TRuleVariation1136 = 'GContextFree TVariation1185 +type TNonSpare578 = 'GNonSpare "600" "Position of the MLT System Reference Point" TRuleVariation1136 +type TUapItem576 = 'GUapItem TNonSpare578 +type TContent688 = 'GContentQuantity 'GSigned ('GNumDiv ('GNumInt ('GZ 'GPlus 1)) ('GNumPow ('GZ 'GPlus 2) ('GZ 'GPlus 2))) "m" +type TRuleContent686 = 'GContextFree TContent688 +type TVariation291 = 'GElement 0 16 TRuleContent686 +type TRuleVariation283 = 'GContextFree TVariation291 +type TNonSpare586 = 'GNonSpare "610" "Height of the MLT System Reference Point" TRuleVariation283 +type TUapItem584 = 'GUapItem TNonSpare586 +type TContent653 = 'GContentQuantity 'GSigned ('GNumInt ('GZ 'GPlus 1)) "m" +type TRuleContent651 = 'GContextFree TContent653 +type TVariation223 = 'GElement 0 8 TRuleContent651 +type TRuleVariation215 = 'GContextFree TVariation223 +type TNonSpare589 = 'GNonSpare "620" "WGS-84 Undulation" TRuleVariation215 +type TUapItem587 = 'GUapItem TNonSpare589 +type TRecord46 = 'GRecord '[ TUapItem45, TUapItem10, TUapItem351, TUapItem570, TUapItem571, TUapItem572, TUapItem573, TUapItem576, TUapItem584, TUapItem587, TUapItem598, TUapItem598, TUapItem594, TUapItem596] +type TUap40 = 'GUap TRecord46 +type TAsterix22 = 'GAsterixBasic 19 ('GEdition 1 3) TUap40 +type TNonSpare42 = 'GNonSpare "010" "Data Source Identifier" TRuleVariation1196 +type TUapItem42 = 'GUapItem TNonSpare42 +type TContent400 = 'GContentTable '[ '(0, "Non-Mode S 1090MHz multilateration"), '(1, "No Non-Mode S 1090MHz multilat")] +type TRuleContent398 = 'GContextFree TContent400 +type TVariation68 = 'GElement 0 1 TRuleContent398 +type TRuleVariation68 = 'GContextFree TVariation68 +type TNonSpare1918 = 'GNonSpare "SSR" "" TRuleVariation68 +type TItem1007 = 'GItem TNonSpare1918 +type TContent306 = 'GContentTable '[ '(0, "Mode-S 1090 MHz multilateration"), '(1, "No Mode-S 1090 MHz multilateration")] +type TRuleContent304 = 'GContextFree TContent306 +type TVariation453 = 'GElement 1 1 TRuleContent304 +type TRuleVariation441 = 'GContextFree TVariation453 +type TNonSpare1429 = 'GNonSpare "MS" "" TRuleVariation441 +type TItem633 = 'GItem TNonSpare1429 +type TContent228 = 'GContentTable '[ '(0, "HF multilateration"), '(1, "No HF multilateration")] +type TRuleContent228 = 'GContextFree TContent228 +type TVariation552 = 'GElement 2 1 TRuleContent228 +type TRuleVariation540 = 'GContextFree TVariation552 +type TNonSpare1143 = 'GNonSpare "HF" "" TRuleVariation540 +type TItem413 = 'GItem TNonSpare1143 +type TContent582 = 'GContentTable '[ '(0, "VDL Mode 4 multilateration"), '(1, "No VDL Mode 4 multilateration")] +type TRuleContent580 = 'GContextFree TContent582 +type TVariation694 = 'GElement 3 1 TRuleContent580 +type TRuleVariation682 = 'GContextFree TVariation694 +type TNonSpare2220 = 'GNonSpare "VDL4" "" TRuleVariation682 +type TItem1244 = 'GItem TNonSpare2220 +type TContent555 = 'GContentTable '[ '(0, "UAT multilateration"), '(1, "No UAT multilateration")] +type TRuleContent553 = 'GContextFree TContent555 +type TVariation786 = 'GElement 4 1 TRuleContent553 +type TRuleVariation774 = 'GContextFree TVariation786 +type TNonSpare2151 = 'GNonSpare "UAT" "" TRuleVariation774 +type TItem1179 = 'GItem TNonSpare2151 +type TContent77 = 'GContentTable '[ '(0, "DME/TACAN multilateration"), '(1, "No DME/TACAN multilateration")] +type TRuleContent77 = 'GContextFree TContent77 +type TVariation856 = 'GElement 5 1 TRuleContent77 +type TRuleVariation825 = 'GContextFree TVariation856 +type TNonSpare959 = 'GNonSpare "DME" "" TRuleVariation825 +type TItem283 = 'GItem TNonSpare959 +type TContent438 = 'GContentTable '[ '(0, "Other Technology Multilateration"), '(1, "No Other Technology Multilateration")] +type TRuleContent436 = 'GContextFree TContent438 +type TVariation976 = 'GElement 6 1 TRuleContent436 +type TRuleVariation945 = 'GContextFree TVariation976 +type TNonSpare1523 = 'GNonSpare "OT" "" TRuleVariation945 +type TItem717 = 'GItem TNonSpare1523 +type TContent464 = 'GContentTable '[ '(0, "Report from target transponder"), '(1, "Report from field monitor (element transponder)")] +type TRuleContent462 = 'GContextFree TContent464 +type TVariation77 = 'GElement 0 1 TRuleContent462 +type TRuleVariation77 = 'GContextFree TVariation77 +type TNonSpare1662 = 'GNonSpare "RAB" "" TRuleVariation77 +type TItem822 = 'GItem TNonSpare1662 +type TVariation416 = 'GElement 1 1 TRuleContent15 +type TRuleVariation404 = 'GContextFree TVariation416 +type TNonSpare1894 = 'GNonSpare "SPI" "" TRuleVariation404 +type TItem988 = 'GItem TNonSpare1894 +type TVariation529 = 'GElement 2 1 TRuleContent57 +type TRuleVariation517 = 'GContextFree TVariation529 +type TNonSpare799 = 'GNonSpare "CHN" "" TRuleVariation517 +type TItem169 = 'GItem TNonSpare799 +type TVariation690 = 'GElement 3 1 TRuleContent545 +type TRuleVariation678 = 'GContextFree TVariation690 +type TNonSpare1105 = 'GNonSpare "GBS" "" TRuleVariation678 +type TItem388 = 'GItem TNonSpare1105 +type TVariation762 = 'GElement 4 1 TRuleContent316 +type TRuleVariation750 = 'GContextFree TVariation762 +type TNonSpare898 = 'GNonSpare "CRT" "" TRuleVariation750 +type TItem232 = 'GItem TNonSpare898 +type TVariation849 = 'GElement 5 1 TRuleContent23 +type TRuleVariation818 = 'GContextFree TVariation849 +type TNonSpare1872 = 'GNonSpare "SIM" "" TRuleVariation818 +type TItem970 = 'GItem TNonSpare1872 +type TVariation950 = 'GElement 6 1 TRuleContent160 +type TRuleVariation919 = 'GContextFree TVariation950 +type TNonSpare2109 = 'GNonSpare "TST" "" TRuleVariation919 +type TItem1142 = 'GItem TNonSpare2109 +type TVariation1457 = 'GExtended '[ 'Just TItem1007, 'Just TItem633, 'Just TItem413, 'Just TItem1244, 'Just TItem1179, 'Just TItem283, 'Just TItem717, 'Nothing, 'Just TItem822, 'Just TItem988, 'Just TItem169, 'Just TItem388, 'Just TItem232, 'Just TItem970, 'Just TItem1142, 'Nothing] +type TRuleVariation1373 = 'GContextFree TVariation1457 +type TNonSpare86 = 'GNonSpare "020" "Target Report Descriptor" TRuleVariation1373 +type TUapItem86 = 'GUapItem TNonSpare86 +type TNonSpare350 = 'GNonSpare "140" "Time of Day" TRuleVariation376 +type TUapItem350 = 'GUapItem TNonSpare350 +type TNonSpare1232 = 'GNonSpare "LAT" "Latitude" TRuleVariation384 +type TItem488 = 'GItem TNonSpare1232 +type TNonSpare1265 = 'GNonSpare "LON" "Longitude" TRuleVariation383 +type TItem519 = 'GItem TNonSpare1265 +type TVariation1184 = 'GGroup 0 '[ TItem488, TItem519] +type TRuleVariation1135 = 'GContextFree TVariation1184 +type TNonSpare160 = 'GNonSpare "041" "Position In WGS-84 Coordinates" TRuleVariation1135 +type TUapItem160 = 'GUapItem TNonSpare160 +type TContent667 = 'GContentQuantity 'GSigned ('GNumDiv ('GNumInt ('GZ 'GPlus 1)) ('GNumInt ('GZ 'GPlus 2))) "m" +type TRuleContent665 = 'GContextFree TContent667 +type TVariation367 = 'GElement 0 24 TRuleContent665 +type TRuleVariation359 = 'GContextFree TVariation367 +type TNonSpare2291 = 'GNonSpare "X" "X-coordinate" TRuleVariation359 +type TItem1307 = 'GItem TNonSpare2291 +type TNonSpare2346 = 'GNonSpare "Y" "Y-coordinate" TRuleVariation359 +type TItem1358 = 'GItem TNonSpare2346 +type TVariation1381 = 'GGroup 0 '[ TItem1307, TItem1358] +type TRuleVariation1302 = 'GContextFree TVariation1381 +type TNonSpare169 = 'GNonSpare "042" "Position in Cartesian Coordinates" TRuleVariation1302 +type TUapItem169 = 'GUapItem TNonSpare169 +type TNonSpare2091 = 'GNonSpare "TRN" "Track Number" TRuleVariation806 +type TItem1126 = 'GItem TNonSpare2091 +type TVariation1077 = 'GGroup 0 '[ TItem3, TItem1126] +type TRuleVariation1044 = 'GContextFree TVariation1077 +type TNonSpare386 = 'GNonSpare "161" "Track Number" TRuleVariation1044 +type TUapItem386 = 'GUapItem TNonSpare386 +type TContent69 = 'GContentTable '[ '(0, "Confirmed track"), '(1, "Track in initiation phase")] +type TRuleContent69 = 'GContextFree TContent69 +type TVariation20 = 'GElement 0 1 TRuleContent69 +type TRuleVariation20 = 'GContextFree TVariation20 +type TNonSpare815 = 'GNonSpare "CNF" "" TRuleVariation20 +type TItem181 = 'GItem TNonSpare815 +type TVariation587 = 'GElement 2 1 TRuleContent418 +type TRuleVariation575 = 'GContextFree TVariation587 +type TNonSpare909 = 'GNonSpare "CST" "" TRuleVariation575 +type TItem240 = 'GItem TNonSpare909 +type TVariation700 = 'GElement 3 2 TRuleContent271 +type TRuleVariation688 = 'GContextFree TVariation700 +type TNonSpare777 = 'GNonSpare "CDM" "" TRuleVariation688 +type TItem151 = 'GItem TNonSpare777 +type TVariation860 = 'GElement 5 1 TRuleContent110 +type TRuleVariation829 = 'GContextFree TVariation860 +type TNonSpare1323 = 'GNonSpare "MAH" "" TRuleVariation829 +type TItem565 = 'GItem TNonSpare1323 +type TVariation1422 = 'GExtended '[ 'Just TItem181, 'Just TItem1121, 'Just TItem240, 'Just TItem151, 'Just TItem565, 'Just TItem1030, 'Nothing, 'Just TItem392, 'Just TItem9, 'Nothing] +type TRuleVariation1338 = 'GContextFree TVariation1422 +type TNonSpare399 = 'GNonSpare "170" "Track Status" TRuleVariation1338 +type TUapItem399 = 'GUapItem TNonSpare399 +type TContent303 = 'GContentTable '[ '(0, "Mode-3/A code derived from the reply of the transponder"), '(1, "Mode-3/A code not extracted during the last update period")] +type TRuleContent301 = 'GContextFree TContent303 +type TVariation572 = 'GElement 2 1 TRuleContent301 +type TRuleVariation560 = 'GContextFree TVariation572 +type TNonSpare1222 = 'GNonSpare "L" "" TRuleVariation560 +type TItem478 = 'GItem TNonSpare1222 +type TVariation1340 = 'GGroup 0 '[ TItem1192, TItem379, TItem478, TItem16, TItem622] +type TRuleVariation1264 = 'GContextFree TVariation1340 +type TNonSpare225 = 'GNonSpare "070" "Mode-3/A Code in Octal Representation" TRuleVariation1264 +type TUapItem225 = 'GUapItem TNonSpare225 +type TNonSpare2237 = 'GNonSpare "VX" "" TRuleVariation285 +type TItem1258 = 'GItem TNonSpare2237 +type TNonSpare2242 = 'GNonSpare "VY" "" TRuleVariation285 +type TItem1263 = 'GItem TNonSpare2242 +type TVariation1343 = 'GGroup 0 '[ TItem1258, TItem1263] +type TRuleVariation1267 = 'GContextFree TVariation1343 +type TNonSpare431 = 'GNonSpare "202" "Calculated Track Velocity in Cartesian Coordinates" TRuleVariation1267 +type TUapItem431 = 'GUapItem TNonSpare431 +type TNonSpare265 = 'GNonSpare "090" "Flight Level in Binary Representation" TRuleVariation1259 +type TUapItem265 = 'GUapItem TNonSpare265 +type TNonSpare1637 = 'GNonSpare "QC1" "Quality Pulse C1" TRuleVariation741 +type TItem800 = 'GItem TNonSpare1637 +type TNonSpare1616 = 'GNonSpare "QA1" "Quality Pulse A1" TRuleVariation850 +type TItem779 = 'GItem TNonSpare1616 +type TNonSpare1640 = 'GNonSpare "QC2" "Quality Pulse C2" TRuleVariation931 +type TItem803 = 'GItem TNonSpare1640 +type TNonSpare1620 = 'GNonSpare "QA2" "Quality Pulse A2" TRuleVariation980 +type TItem783 = 'GItem TNonSpare1620 +type TNonSpare1643 = 'GNonSpare "QC4" "Quality Pulse C4" TRuleVariation49 +type TItem806 = 'GItem TNonSpare1643 +type TNonSpare1624 = 'GNonSpare "QA4" "Quality Pulse A4" TRuleVariation433 +type TItem787 = 'GItem TNonSpare1624 +type TNonSpare1628 = 'GNonSpare "QB1" "Quality Pulse B1" TRuleVariation542 +type TItem791 = 'GItem TNonSpare1628 +type TNonSpare1646 = 'GNonSpare "QD1" "Quality Pulse D1" TRuleVariation651 +type TItem809 = 'GItem TNonSpare1646 +type TNonSpare1632 = 'GNonSpare "QB2" "Quality Pulse B2" TRuleVariation740 +type TItem795 = 'GItem TNonSpare1632 +type TVariation883 = 'GElement 5 1 TRuleContent235 +type TRuleVariation852 = 'GContextFree TVariation883 +type TNonSpare1649 = 'GNonSpare "QD2" "Quality Pulse D2" TRuleVariation852 +type TItem812 = 'GItem TNonSpare1649 +type TNonSpare1635 = 'GNonSpare "QB4" "Quality Pulse B4" TRuleVariation930 +type TItem798 = 'GItem TNonSpare1635 +type TNonSpare1652 = 'GNonSpare "QD4" "Quality Pulse D4" TRuleVariation984 +type TItem815 = 'GItem TNonSpare1652 +type TVariation1333 = 'GGroup 0 '[ TItem1192, TItem379, TItem12, TItem623, TItem3, TItem800, TItem779, TItem803, TItem783, TItem806, TItem787, TItem791, TItem809, TItem795, TItem812, TItem798, TItem815] +type TRuleVariation1257 = 'GContextFree TVariation1333 +type TNonSpare287 = 'GNonSpare "100" "Mode C Code" TRuleVariation1257 +type TUapItem287 = 'GUapItem TNonSpare287 +type TNonSpare455 = 'GNonSpare "220" "Target Address" TRuleVariation355 +type TUapItem455 = 'GUapItem TNonSpare455 +type TContent56 = 'GContentTable '[ '(0, "Callsign or registration not downlinked from transponder"), '(1, "Registration downlinked from transponder"), '(2, "Callsign downlinked from transponder"), '(3, "Not defined")] +type TRuleContent56 = 'GContextFree TContent56 +type TVariation103 = 'GElement 0 2 TRuleContent56 +type TRuleVariation103 = 'GContextFree TVariation103 +type TNonSpare1954 = 'GNonSpare "STI" "" TRuleVariation103 +type TItem1033 = 'GItem TNonSpare1954 +type TNonSpare802 = 'GNonSpare "CHR" "Characters 1-8 (coded on 6 Bits Each) Defining Target Identification" TRuleVariation396 +type TItem172 = 'GItem TNonSpare802 +type TVariation1280 = 'GGroup 0 '[ TItem1033, TItem15, TItem172] +type TRuleVariation1219 = 'GContextFree TVariation1280 +type TNonSpare475 = 'GNonSpare "245" "Target Identification" TRuleVariation1219 +type TUapItem475 = 'GUapItem TNonSpare475 +type TNonSpare305 = 'GNonSpare "110" "Measured Height (Local Cartesian Coordinates)" TRuleVariation296 +type TUapItem305 = 'GUapItem TNonSpare305 +type TNonSpare298 = 'GNonSpare "105" "Geometric Height (WGS-84)" TRuleVariation296 +type TUapItem298 = 'GUapItem TNonSpare298 +type TNonSpare709 = 'GNonSpare "AX" "" TRuleVariation218 +type TItem102 = 'GItem TNonSpare709 +type TNonSpare713 = 'GNonSpare "AY" "" TRuleVariation218 +type TItem106 = 'GItem TNonSpare713 +type TVariation1100 = 'GGroup 0 '[ TItem102, TItem106] +type TRuleVariation1066 = 'GContextFree TVariation1100 +type TNonSpare433 = 'GNonSpare "210" "Calculated Acceleration" TRuleVariation1066 +type TUapItem433 = 'GUapItem TNonSpare433 +type TNonSpare1440 = 'GNonSpare "MSG" "" TRuleVariation500 +type TItem641 = 'GItem TNonSpare1440 +type TVariation1293 = 'GGroup 0 '[ TItem1116, TItem641] +type TRuleVariation1226 = 'GContextFree TVariation1293 +type TNonSpare518 = 'GNonSpare "310" "Pre-programmed Message" TRuleVariation1226 +type TUapItem518 = 'GUapItem TNonSpare518 +type TContent781 = 'GContentQuantity 'GUnsigned ('GNumDiv ('GNumInt ('GZ 'GPlus 1)) ('GNumPow ('GZ 'GPlus 2) ('GZ 'GPlus 2))) "" +type TRuleContent778 = 'GContextFree TContent781 +type TVariation334 = 'GElement 0 16 TRuleContent778 +type TRuleVariation326 = 'GContextFree TVariation334 +type TNonSpare2277 = 'GNonSpare "X" "DOP (X-Component)" TRuleVariation326 +type TItem1293 = 'GItem TNonSpare2277 +type TNonSpare2331 = 'GNonSpare "Y" "DOP (Y-Component)" TRuleVariation326 +type TItem1343 = 'GItem TNonSpare2331 +type TNonSpare2312 = 'GNonSpare "XY" "DOP (Correlation XY)" TRuleVariation326 +type TItem1324 = 'GItem TNonSpare2312 +type TVariation1366 = 'GGroup 0 '[ TItem1293, TItem1343, TItem1324] +type TRuleVariation1290 = 'GContextFree TVariation1366 +type TNonSpare960 = 'GNonSpare "DOP" "DOP of Position" TRuleVariation1290 +type TVariation338 = 'GElement 0 16 TRuleContent782 +type TRuleVariation330 = 'GContextFree TVariation338 +type TNonSpare2281 = 'GNonSpare "X" "SDP (X-Component)" TRuleVariation330 +type TItem1297 = 'GItem TNonSpare2281 +type TNonSpare2335 = 'GNonSpare "Y" "SDP (Y-Component)" TRuleVariation330 +type TItem1347 = 'GItem TNonSpare2335 +type TNonSpare2313 = 'GNonSpare "XY" "SDP (Correlation XY)" TRuleVariation326 +type TItem1325 = 'GItem TNonSpare2313 +type TVariation1370 = 'GGroup 0 '[ TItem1297, TItem1347, TItem1325] +type TRuleVariation1294 = 'GContextFree TVariation1370 +type TNonSpare1830 = 'GNonSpare "SDP" "Standard Deviation of Position" TRuleVariation1294 +type TNonSpare1825 = 'GNonSpare "SDH" "Standard Deviation of Geometric Height (WGS 84)" TRuleVariation317 +type TVariation1567 = 'GCompound '[ 'Just TNonSpare960, 'Just TNonSpare1830, 'Just TNonSpare1825] +type TRuleVariation1483 = 'GContextFree TVariation1567 +type TNonSpare565 = 'GNonSpare "500" "Position Accuracy" TRuleVariation1483 +type TUapItem563 = 'GUapItem TNonSpare565 +type TContent492 = 'GContentTable '[ '(0, "TU1/RU1 has NOT contributed to the target detection"), '(1, "TU1/RU1 has contributed to the target detection")] +type TRuleContent490 = 'GContextFree TContent492 +type TVariation84 = 'GElement 0 1 TRuleContent490 +type TRuleVariation84 = 'GContextFree TVariation84 +type TNonSpare737 = 'GNonSpare "BIT1" "TU1/RU1 Contribution" TRuleVariation84 +type TItem126 = 'GItem TNonSpare737 +type TContent493 = 'GContentTable '[ '(0, "TU2/RU2 has NOT contributed to the target detection"), '(1, "TU2/RU2 has contributed to the target detection")] +type TRuleContent491 = 'GContextFree TContent493 +type TVariation467 = 'GElement 1 1 TRuleContent491 +type TRuleVariation455 = 'GContextFree TVariation467 +type TNonSpare738 = 'GNonSpare "BIT2" "TU2/RU2 Contribution" TRuleVariation455 +type TItem127 = 'GItem TNonSpare738 +type TContent494 = 'GContentTable '[ '(0, "TU3/RU3 has NOT contributed to the target detection"), '(1, "TU3/RU3 has contributed to the target detection")] +type TRuleContent492 = 'GContextFree TContent494 +type TVariation595 = 'GElement 2 1 TRuleContent492 +type TRuleVariation583 = 'GContextFree TVariation595 +type TNonSpare739 = 'GNonSpare "BIT3" "TU3/RU3 Contribution" TRuleVariation583 +type TItem128 = 'GItem TNonSpare739 +type TContent495 = 'GContentTable '[ '(0, "TU4/RU4 has NOT contributed to the target detection"), '(1, "TU4/RU4 has contributed to the target detection")] +type TRuleContent493 = 'GContextFree TContent495 +type TVariation683 = 'GElement 3 1 TRuleContent493 +type TRuleVariation671 = 'GContextFree TVariation683 +type TNonSpare740 = 'GNonSpare "BIT4" "TU4/RU4 Contribution" TRuleVariation671 +type TItem129 = 'GItem TNonSpare740 +type TContent496 = 'GContentTable '[ '(0, "TU5/RU5 has NOT contributed to the target detection"), '(1, "TU5/RU5 has contributed to the target detection")] +type TRuleContent494 = 'GContextFree TContent496 +type TVariation780 = 'GElement 4 1 TRuleContent494 +type TRuleVariation768 = 'GContextFree TVariation780 +type TNonSpare741 = 'GNonSpare "BIT5" "TU5/RU5 Contribution" TRuleVariation768 +type TItem130 = 'GItem TNonSpare741 +type TContent497 = 'GContentTable '[ '(0, "TU6/RU6 has NOT contributed to the target detection"), '(1, "TU6/RU6 has contributed to the target detection")] +type TRuleContent495 = 'GContextFree TContent497 +type TVariation901 = 'GElement 5 1 TRuleContent495 +type TRuleVariation870 = 'GContextFree TVariation901 +type TNonSpare742 = 'GNonSpare "BIT6" "TU6/RU6 Contribution" TRuleVariation870 +type TItem131 = 'GItem TNonSpare742 +type TContent498 = 'GContentTable '[ '(0, "TU7/RU7 has NOT contributed to the target detection"), '(1, "TU7/RU7 has contributed to the target detection")] +type TRuleContent496 = 'GContextFree TContent498 +type TVariation986 = 'GElement 6 1 TRuleContent496 +type TRuleVariation955 = 'GContextFree TVariation986 +type TNonSpare743 = 'GNonSpare "BIT7" "TU7/RU7 Contribution" TRuleVariation955 +type TItem132 = 'GItem TNonSpare743 +type TContent499 = 'GContentTable '[ '(0, "TU8/RU8 has NOT contributed to the target detection"), '(1, "TU8/RU8 has contributed to the target detection")] +type TRuleContent497 = 'GContextFree TContent499 +type TVariation1025 = 'GElement 7 1 TRuleContent497 +type TRuleVariation994 = 'GContextFree TVariation1025 +type TNonSpare744 = 'GNonSpare "BIT8" "TU8/RU8 Contribution" TRuleVariation994 +type TItem133 = 'GItem TNonSpare744 +type TVariation1107 = 'GGroup 0 '[ TItem126, TItem127, TItem128, TItem129, TItem130, TItem131, TItem132, TItem133] +type TVariation1489 = 'GRepetitive ('GRepetitiveRegular 1) TVariation1107 +type TRuleVariation1405 = 'GContextFree TVariation1489 +type TNonSpare539 = 'GNonSpare "400" "Contributing Devices" TRuleVariation1405 +type TUapItem537 = 'GUapItem TNonSpare539 +type TNonSpare1337 = 'GNonSpare "MBDATA" "56-bit Message Conveying Mode S Comm B Message Data" TRuleVariation397 +type TItem574 = 'GItem TNonSpare1337 +type TVariation1201 = 'GGroup 0 '[ TItem574, TItem120, TItem123] +type TVariation1501 = 'GRepetitive ('GRepetitiveRegular 1) TVariation1201 +type TRuleVariation1417 = 'GContextFree TVariation1501 +type TNonSpare482 = 'GNonSpare "250" "Mode S MB Data" TRuleVariation1417 +type TUapItem482 = 'GUapItem TNonSpare482 +type TContent337 = 'GContentTable '[ '(0, "No alert, no SPI, aircraft airborne"), '(1, "No alert, no SPI, aircraft on ground"), '(2, "Alert, no SPI, aircraft airborne"), '(3, "Alert, no SPI, aircraft on ground"), '(4, "Alert, SPI, aircraft airborne or on ground"), '(5, "No alert, SPI, aircraft airborne or on ground"), '(6, "Not assigned"), '(7, "Information not yet extracted")] +type TRuleContent335 = 'GContextFree TContent337 +type TVariation710 = 'GElement 3 3 TRuleContent335 +type TRuleVariation698 = 'GContextFree TVariation710 +type TNonSpare1938 = 'GNonSpare "STAT" "Flight Status" TRuleVariation698 +type TItem1018 = 'GItem TNonSpare1938 +type TVariation1126 = 'GGroup 0 '[ TItem204, TItem1018, TItem27, TItem646, TItem84, TItem58, TItem112, TItem114] +type TRuleVariation1081 = 'GContextFree TVariation1126 +type TNonSpare460 = 'GNonSpare "230" "Communications/ACAS Capability and Flight Status" TRuleVariation1081 +type TUapItem460 = 'GUapItem TNonSpare460 +type TNonSpare487 = 'GNonSpare "260" "ACAS Resolution Advisory Report" TRuleVariation397 +type TUapItem487 = 'GUapItem TNonSpare487 +type TContent419 = 'GContentTable '[ '(0, "Not defined; never used"), '(1, "Multipath Reply (Reflection)"), '(3, "Split plot"), '(10, "Phantom SSR plot"), '(11, "Non-Matching Mode-3/A Code"), '(12, "Mode C code / Mode S altitude code abnormal value compared to the track"), '(15, "Transponder anomaly detected"), '(16, "Duplicated or Illegal Mode S Aircraft Address"), '(17, "Mode S error correction applied"), '(18, "Undecodable Mode C code / Mode S altitude code")] +type TRuleContent417 = 'GContextFree TContent419 +type TVariation168 = 'GElement 0 7 TRuleContent417 +type TVariation1540 = 'GRepetitive 'GRepetitiveFx TVariation168 +type TRuleVariation1456 = 'GContextFree TVariation1540 +type TNonSpare122 = 'GNonSpare "030" "Warning/Error Conditions" TRuleVariation1456 +type TUapItem122 = 'GUapItem TNonSpare122 +type TContent296 = 'GContentTable '[ '(0, "Mode-1 code derived from the reply of the transponder"), '(1, "Smoothed Mode-1 code as provided by a local tracker")] +type TRuleContent294 = 'GContextFree TContent296 +type TVariation565 = 'GElement 2 1 TRuleContent294 +type TRuleVariation553 = 'GContextFree TVariation565 +type TNonSpare1215 = 'GNonSpare "L" "" TRuleVariation553 +type TItem471 = 'GItem TNonSpare1215 +type TNonSpare1410 = 'GNonSpare "MODE1" "Mode-1 Code in Octal Representation" TRuleVariation708 +type TItem614 = 'GItem TNonSpare1410 +type TVariation1337 = 'GGroup 0 '[ TItem1192, TItem379, TItem471, TItem614] +type TRuleVariation1261 = 'GContextFree TVariation1337 +type TNonSpare195 = 'GNonSpare "055" "Mode-1 Code in Octal Representation" TRuleVariation1261 +type TUapItem195 = 'GUapItem TNonSpare195 +type TContent299 = 'GContentTable '[ '(0, "Mode-2 code derived from the reply of the transponder"), '(1, "Smoothed Mode-2 code as provided by a local tracker n")] +type TRuleContent297 = 'GContextFree TContent299 +type TVariation568 = 'GElement 2 1 TRuleContent297 +type TRuleVariation556 = 'GContextFree TVariation568 +type TNonSpare1218 = 'GNonSpare "L" "" TRuleVariation556 +type TItem474 = 'GItem TNonSpare1218 +type TNonSpare1413 = 'GNonSpare "MODE2" "Mode-2 Reply in Octal Representation" TRuleVariation807 +type TItem617 = 'GItem TNonSpare1413 +type TVariation1338 = 'GGroup 0 '[ TItem1192, TItem379, TItem474, TItem16, TItem617] +type TRuleVariation1262 = 'GContextFree TVariation1338 +type TNonSpare183 = 'GNonSpare "050" "Mode-2 Code in Octal Representation" TRuleVariation1262 +type TUapItem183 = 'GUapItem TNonSpare183 +type TRecord41 = 'GRecord '[ TUapItem42, TUapItem86, TUapItem350, TUapItem160, TUapItem169, TUapItem386, TUapItem399, TUapItem225, TUapItem431, TUapItem265, TUapItem287, TUapItem455, TUapItem475, TUapItem305, TUapItem298, TUapItem433, TUapItem517, TUapItem518, TUapItem563, TUapItem537, TUapItem482, TUapItem460, TUapItem487, TUapItem122, TUapItem195, TUapItem183, TUapItem594, TUapItem596] +type TUap35 = 'GUap TRecord41 +type TAsterix23 = 'GAsterixBasic 20 ('GEdition 1 9) TUap35 +type TContent508 = 'GContentTable '[ '(0, "Target with 24-bit ICAO address"), '(1, "Target with a non-ICAO 24-bit address"), '(2, "Non-ADS-B Message"), '(3, "Information not available")] +type TRuleContent506 = 'GContextFree TContent508 +type TVariation118 = 'GElement 0 2 TRuleContent506 +type TRuleVariation118 = 'GContextFree TVariation118 +type TNonSpare789 = 'GNonSpare "CF" "" TRuleVariation118 +type TItem163 = 'GItem TNonSpare789 +type TItem14 = 'GSpare 2 5 +type TVariation1458 = 'GExtended '[ 'Just TItem1007, 'Just TItem633, 'Just TItem413, 'Just TItem1244, 'Just TItem1179, 'Just TItem283, 'Just TItem717, 'Nothing, 'Just TItem822, 'Just TItem988, 'Just TItem169, 'Just TItem388, 'Just TItem232, 'Just TItem970, 'Just TItem1142, 'Nothing, 'Just TItem163, 'Just TItem14, 'Nothing] +type TRuleVariation1374 = 'GContextFree TVariation1458 +type TNonSpare87 = 'GNonSpare "020" "Target Report Descriptor" TRuleVariation1374 +type TUapItem87 = 'GUapItem TNonSpare87 +type TContent406 = 'GContentTable '[ '(0, "Not Coasted"), '(1, "Coasted")] +type TRuleContent404 = 'GContextFree TContent406 +type TVariation584 = 'GElement 2 1 TRuleContent404 +type TRuleVariation572 = 'GContextFree TVariation584 +type TNonSpare908 = 'GNonSpare "CST" "" TRuleVariation572 +type TItem239 = 'GItem TNonSpare908 +type TVariation1421 = 'GExtended '[ 'Just TItem181, 'Just TItem1121, 'Just TItem239, 'Just TItem151, 'Just TItem565, 'Just TItem1030, 'Nothing, 'Just TItem392, 'Just TItem9, 'Nothing] +type TRuleVariation1337 = 'GContextFree TVariation1421 +type TNonSpare398 = 'GNonSpare "170" "Track Status" TRuleVariation1337 +type TUapItem398 = 'GUapItem TNonSpare398 +type TNonSpare453 = 'GNonSpare "220" "Target Address" TRuleVariation355 +type TUapItem453 = 'GUapItem TNonSpare453 +type TNonSpare736 = 'GNonSpare "BDSREGISTER" "56-bit Message Conveying Mode S Comm B Message Data" TRuleVariation397 +type TItem125 = 'GItem TNonSpare736 +type TVariation1106 = 'GGroup 0 '[ TItem125, TItem120, TItem123] +type TVariation1488 = 'GRepetitive ('GRepetitiveRegular 1) TVariation1106 +type TRuleVariation1404 = 'GContextFree TVariation1488 +type TNonSpare477 = 'GNonSpare "250" "BDS Register Data" TRuleVariation1404 +type TUapItem477 = 'GUapItem TNonSpare477 +type TRecord43 = 'GRecord '[ TUapItem42, TUapItem87, TUapItem350, TUapItem160, TUapItem169, TUapItem386, TUapItem398, TUapItem225, TUapItem431, TUapItem265, TUapItem287, TUapItem453, TUapItem475, TUapItem305, TUapItem298, TUapItem433, TUapItem517, TUapItem518, TUapItem563, TUapItem537, TUapItem477, TUapItem460, TUapItem487, TUapItem122, TUapItem195, TUapItem183, TUapItem594, TUapItem596] +type TUap37 = 'GUap TRecord43 +type TAsterix24 = 'GAsterixBasic 20 ('GEdition 1 10) TUap37 +type TNonSpare734 = 'GNonSpare "BDSDATA" "56-bit Message Conveying BDS Register Data" TRuleVariation397 +type TItem124 = 'GItem TNonSpare734 +type TNonSpare729 = 'GNonSpare "BDS1" "BDS Register Address 1" TRuleVariation140 +type TItem119 = 'GItem TNonSpare729 +type TNonSpare732 = 'GNonSpare "BDS2" "BDS Register Address 2" TRuleVariation796 +type TItem122 = 'GItem TNonSpare732 +type TVariation1105 = 'GGroup 0 '[ TItem124, TItem119, TItem122] +type TVariation1487 = 'GRepetitive ('GRepetitiveRegular 1) TVariation1105 +type TRuleVariation1403 = 'GContextFree TVariation1487 +type TNonSpare476 = 'GNonSpare "250" "BDS Register Data" TRuleVariation1403 +type TUapItem476 = 'GUapItem TNonSpare476 +type TContent401 = 'GContentTable '[ '(0, "Non-extended version"), '(1, "ACAS Xa Version 1"), '(2, "ACAS Xu Version 1"), '(3, "Reserved for future use")] +type TRuleContent399 = 'GContextFree TContent401 +type TVariation996 = 'GElement 6 2 TRuleContent399 +type TRuleVariation965 = 'GContextFree TVariation996 +type TNonSpare766 = 'GNonSpare "CASEVN" "CAS Extended Version Number" TRuleVariation965 +type TItem145 = 'GItem TNonSpare766 +type TVariation1127 = 'GGroup 0 '[ TItem204, TItem1018, TItem145, TItem646, TItem84, TItem58, TItem112, TItem114] +type TRuleVariation1082 = 'GContextFree TVariation1127 +type TNonSpare461 = 'GNonSpare "230" "Communications/ACAS Capability and Flight Status" TRuleVariation1082 +type TUapItem461 = 'GUapItem TNonSpare461 +type TNonSpare488 = 'GNonSpare "260" "ACAS Resolution Advisory Report" TRuleVariation397 +type TUapItem488 = 'GUapItem TNonSpare488 +type TRecord42 = 'GRecord '[ TUapItem42, TUapItem87, TUapItem350, TUapItem160, TUapItem169, TUapItem386, TUapItem398, TUapItem225, TUapItem431, TUapItem265, TUapItem287, TUapItem453, TUapItem475, TUapItem305, TUapItem298, TUapItem433, TUapItem517, TUapItem518, TUapItem563, TUapItem537, TUapItem476, TUapItem461, TUapItem488, TUapItem122, TUapItem195, TUapItem183, TUapItem594, TUapItem596] +type TUap36 = 'GUap TRecord42 +type TAsterix25 = 'GAsterixBasic 20 ('GEdition 1 11) TUap36 +type TNonSpare29 = 'GNonSpare "010" "Data Source Identification" TRuleVariation1196 +type TUapItem29 = 'GUapItem TNonSpare29 +type TVariation63 = 'GElement 0 1 TRuleContent366 +type TRuleVariation63 = 'GContextFree TVariation63 +type TNonSpare945 = 'GNonSpare "DCR" "Differential Correction" TRuleVariation63 +type TItem271 = 'GItem TNonSpare945 +type TContent227 = 'GContentTable '[ '(0, "Ground Bit not set"), '(1, "Ground Bit set")] +type TRuleContent227 = 'GContextFree TContent227 +type TVariation443 = 'GElement 1 1 TRuleContent227 +type TRuleVariation431 = 'GContextFree TVariation443 +type TNonSpare1108 = 'GNonSpare "GBS" "Ground Bit Setting" TRuleVariation431 +type TItem391 = 'GItem TNonSpare1108 +type TVariation525 = 'GElement 2 1 TRuleContent23 +type TRuleVariation513 = 'GContextFree TVariation525 +type TNonSpare1873 = 'GNonSpare "SIM" "Simulated Target" TRuleVariation513 +type TItem971 = 'GItem TNonSpare1873 +type TVariation653 = 'GElement 3 1 TRuleContent160 +type TRuleVariation641 = 'GContextFree TVariation653 +type TNonSpare2110 = 'GNonSpare "TST" "Test Target" TRuleVariation641 +type TItem1143 = 'GItem TNonSpare2110 +type TVariation776 = 'GElement 4 1 TRuleContent463 +type TRuleVariation764 = 'GContextFree TVariation776 +type TNonSpare1667 = 'GNonSpare "RAB" "Report Type" TRuleVariation764 +type TItem827 = 'GItem TNonSpare1667 +type TContent216 = 'GContentTable '[ '(0, "Equipment capable to provide Selected Altitude"), '(1, "Equipment not capable to provide Selected Altitude")] +type TRuleContent216 = 'GContextFree TContent216 +type TVariation878 = 'GElement 5 1 TRuleContent216 +type TRuleVariation847 = 'GContextFree TVariation878 +type TNonSpare1791 = 'GNonSpare "SAA" "Selected Altitude Available" TRuleVariation847 +type TItem918 = 'GItem TNonSpare1791 +type TVariation931 = 'GElement 6 1 TRuleContent15 +type TRuleVariation900 = 'GContextFree TVariation931 +type TNonSpare1898 = 'GNonSpare "SPI" "Special Position Identification" TRuleVariation900 +type TItem992 = 'GItem TNonSpare1898 +type TContent397 = 'GContentTable '[ '(0, "Non unique address"), '(1, "24-Bit ICAO address"), '(2, "Surface vehicle address"), '(3, "Anonymous address"), '(4, "Reserved for future use"), '(5, "Reserved for future use"), '(6, "Reserved for future use"), '(7, "Reserved for future use")] +type TRuleContent395 = 'GContextFree TContent397 +type TVariation138 = 'GElement 0 3 TRuleContent395 +type TRuleVariation138 = 'GContextFree TVariation138 +type TNonSpare698 = 'GNonSpare "ATP" "Address Type" TRuleVariation138 +type TItem94 = 'GItem TNonSpare698 +type TContent560 = 'GContentTable '[ '(0, "Unknown"), '(1, "25 ft"), '(2, "100 ft")] +type TRuleContent558 = 'GContextFree TContent560 +type TVariation706 = 'GElement 3 2 TRuleContent558 +type TRuleVariation694 = 'GContextFree TVariation706 +type TNonSpare681 = 'GNonSpare "ARC" "Altitude Reporting Capability" TRuleVariation694 +type TItem86 = 'GItem TNonSpare681 +type TVariation1134 = 'GGroup 0 '[ TItem271, TItem391, TItem971, TItem1143, TItem827, TItem918, TItem992, TItem29, TItem94, TItem86, TItem25] +type TRuleVariation1089 = 'GContextFree TVariation1134 +type TNonSpare150 = 'GNonSpare "040" "Target Report Descriptor" TRuleVariation1089 +type TUapItem150 = 'GUapItem TNonSpare150 +type TNonSpare113 = 'GNonSpare "030" "Time of Day" TRuleVariation376 +type TUapItem113 = 'GUapItem TNonSpare113 +type TNonSpare1230 = 'GNonSpare "LAT" "Latitude" TRuleVariation366 +type TItem486 = 'GItem TNonSpare1230 +type TNonSpare1262 = 'GNonSpare "LON" "Longitude" TRuleVariation364 +type TItem516 = 'GItem TNonSpare1262 +type TVariation1182 = 'GGroup 0 '[ TItem486, TItem516] +type TRuleVariation1133 = 'GContextFree TVariation1182 +type TNonSpare328 = 'GNonSpare "130" "Position in WGS-84 Co-ordinates" TRuleVariation1133 +type TUapItem328 = 'GUapItem TNonSpare328 +type TNonSpare248 = 'GNonSpare "080" "Target Address" TRuleVariation355 +type TUapItem248 = 'GUapItem TNonSpare248 +type TContent714 = 'GContentQuantity 'GSigned ('GNumDiv ('GNumInt ('GZ 'GPlus 25)) ('GNumPow ('GZ 'GPlus 2) ('GZ 'GPlus 2))) "ft" +type TRuleContent712 = 'GContextFree TContent714 +type TVariation305 = 'GElement 0 16 TRuleContent712 +type TRuleVariation297 = 'GContextFree TVariation305 +type TNonSpare344 = 'GNonSpare "140" "Geometric Altitude" TRuleVariation297 +type TUapItem344 = 'GUapItem TNonSpare344 +type TContent561 = 'GContentTable '[ '(0, "Unknown"), '(1, "ACAS not operational"), '(2, "ACAS operartional"), '(3, "Invalid")] +type TRuleContent559 = 'GContextFree TContent561 +type TVariation120 = 'GElement 0 2 TRuleContent559 +type TRuleVariation120 = 'GContextFree TVariation120 +type TNonSpare603 = 'GNonSpare "AC" "ACAS Capabilities" TRuleVariation120 +type TItem38 = 'GItem TNonSpare603 +type TContent575 = 'GContentTable '[ '(0, "Unknown"), '(1, "Multiple Navigation not operational"), '(2, "Multiple Navigation operartional"), '(3, "Invalid")] +type TRuleContent573 = 'GContextFree TContent575 +type TVariation613 = 'GElement 2 2 TRuleContent573 +type TRuleVariation601 = 'GContextFree TVariation613 +type TNonSpare1404 = 'GNonSpare "MN" "Multiple Navigation Aids" TRuleVariation601 +type TItem608 = 'GItem TNonSpare1404 +type TContent569 = 'GContentTable '[ '(0, "Unknown"), '(1, "Differential Correction"), '(2, "NO Differential Correction"), '(3, "Invalid")] +type TRuleContent567 = 'GContextFree TContent569 +type TVariation797 = 'GElement 4 2 TRuleContent567 +type TRuleVariation785 = 'GContextFree TVariation797 +type TNonSpare941 = 'GNonSpare "DC" "Differential Correction" TRuleVariation785 +type TItem267 = 'GItem TNonSpare941 +type TItem28 = 'GSpare 6 6 +type TContent649 = 'GContentQuantity 'GSigned ('GNumInt ('GZ 'GPlus 1)) "" +type TRuleContent647 = 'GContextFree TContent649 +type TVariation834 = 'GElement 4 4 TRuleContent647 +type TRuleVariation803 = 'GContextFree TVariation834 +type TNonSpare1536 = 'GNonSpare "PA" "Position Accuracy" TRuleVariation803 +type TItem729 = 'GItem TNonSpare1536 +type TVariation1089 = 'GGroup 0 '[ TItem38, TItem608, TItem267, TItem28, TItem729] +type TRuleVariation1055 = 'GContextFree TVariation1089 +type TNonSpare260 = 'GNonSpare "090" "Figure of Merit" TRuleVariation1055 +type TUapItem260 = 'GUapItem TNonSpare260 +type TContent566 = 'GContentTable '[ '(0, "Unknown"), '(1, "Aircraft equiped with CDTI")] +type TRuleContent564 = 'GContextFree TContent566 +type TVariation693 = 'GElement 3 1 TRuleContent564 +type TRuleVariation681 = 'GContextFree TVariation693 +type TNonSpare979 = 'GNonSpare "DTI" "Cockpit Display of Traffic Information" TRuleVariation681 +type TItem297 = 'GItem TNonSpare979 +type TContent423 = 'GContentTable '[ '(0, "Not used"), '(1, "Used")] +type TRuleContent421 = 'GContextFree TContent423 +type TVariation770 = 'GElement 4 1 TRuleContent421 +type TRuleVariation758 = 'GContextFree TVariation770 +type TNonSpare1369 = 'GNonSpare "MDS" "Mode-S Extended Squitter" TRuleVariation758 +type TItem589 = 'GItem TNonSpare1369 +type TVariation897 = 'GElement 5 1 TRuleContent421 +type TRuleVariation866 = 'GContextFree TVariation897 +type TNonSpare2154 = 'GNonSpare "UAT" "UAT" TRuleVariation866 +type TItem1181 = 'GItem TNonSpare2154 +type TVariation975 = 'GElement 6 1 TRuleContent421 +type TRuleVariation944 = 'GContextFree TVariation975 +type TNonSpare2219 = 'GNonSpare "VDL" "VDL Mode 4" TRuleVariation944 +type TItem1243 = 'GItem TNonSpare2219 +type TVariation1021 = 'GElement 7 1 TRuleContent421 +type TRuleVariation990 = 'GContextFree TVariation1021 +type TNonSpare1524 = 'GNonSpare "OTR" "Other Technology" TRuleVariation990 +type TItem718 = 'GItem TNonSpare1524 +type TVariation1052 = 'GGroup 0 '[ TItem2, TItem297, TItem589, TItem1181, TItem1243, TItem718] +type TRuleVariation1021 = 'GContextFree TVariation1052 +type TNonSpare438 = 'GNonSpare "210" "Link Technology Indicator" TRuleVariation1021 +type TUapItem438 = 'GUapItem TNonSpare438 +type TContent677 = 'GContentQuantity 'GSigned ('GNumDiv ('GNumInt ('GZ 'GPlus 1)) ('GNumInt ('GZ 'GPlus 100))) "°" +type TRuleContent675 = 'GContextFree TContent677 +type TVariation283 = 'GElement 0 16 TRuleContent675 +type TRuleVariation275 = 'GContextFree TVariation283 +type TNonSpare464 = 'GNonSpare "230" "Roll Angle" TRuleVariation275 +type TUapItem464 = 'GUapItem TNonSpare464 +type TContent682 = 'GContentQuantity 'GSigned ('GNumDiv ('GNumInt ('GZ 'GPlus 1)) ('GNumPow ('GZ 'GPlus 2) ('GZ 'GPlus 2))) "FL" +type TRuleContent680 = 'GContextFree TContent682 +type TVariation286 = 'GElement 0 16 TRuleContent680 +type TRuleVariation278 = 'GContextFree TVariation286 +type TNonSpare360 = 'GNonSpare "145" "Flight Level" TRuleVariation278 +type TUapItem360 = 'GUapItem TNonSpare360 +type TContent26 = 'GContentTable '[ '(0, "Air Speed = IAS, LSB (Bit-1) = 2 -14 NM/s"), '(1, "Air Speed = Mach, LSB (Bit-1) = 0.001")] +type TRuleContent26 = 'GContextFree TContent26 +type TVariation8 = 'GElement 0 1 TRuleContent26 +type TRuleVariation8 = 'GContextFree TVariation8 +type TNonSpare1199 = 'GNonSpare "IM" "" TRuleVariation8 +type TItem457 = 'GItem TNonSpare1199 +type TContent780 = 'GContentQuantity 'GUnsigned ('GNumDiv ('GNumInt ('GZ 'GPlus 1)) ('GNumInt ('GZ 'GPlus 1000))) "Mach" +type TRuleContent830 = 'GDependent '[ '[ "150", "IM"]] TContent0 '[ '( '[ 0], TContent808), '( '[ 1], TContent780)] +type TVariation522 = 'GElement 1 15 TRuleContent830 +type TRuleVariation510 = 'GContextFree TVariation522 +type TNonSpare686 = 'GNonSpare "AS" "Air Speed (IAS or Mach)" TRuleVariation510 +type TItem89 = 'GItem TNonSpare686 +type TVariation1177 = 'GGroup 0 '[ TItem457, TItem89] +type TRuleVariation1128 = 'GContextFree TVariation1177 +type TNonSpare366 = 'GNonSpare "150" "Air Speed" TRuleVariation1128 +type TUapItem366 = 'GUapItem TNonSpare366 +type TContent743 = 'GContentQuantity 'GUnsigned ('GNumInt ('GZ 'GPlus 1)) "kt" +type TRuleContent741 = 'GContextFree TContent743 +type TVariation315 = 'GElement 0 16 TRuleContent741 +type TRuleVariation307 = 'GContextFree TVariation315 +type TNonSpare371 = 'GNonSpare "151" "True Airspeed" TRuleVariation307 +type TUapItem371 = 'GUapItem TNonSpare371 +type TNonSpare373 = 'GNonSpare "152" "Magnetic Heading" TRuleVariation349 +type TUapItem373 = 'GUapItem TNonSpare373 +type TContent716 = 'GContentQuantity 'GSigned ('GNumDiv ('GNumInt ('GZ 'GPlus 25)) ('GNumPow ('GZ 'GPlus 2) ('GZ 'GPlus 2))) "ft/min" +type TRuleContent714 = 'GContextFree TContent716 +type TVariation307 = 'GElement 0 16 TRuleContent714 +type TRuleVariation299 = 'GContextFree TVariation307 +type TNonSpare375 = 'GNonSpare "155" "Barometric Vertical Rate" TRuleVariation299 +type TUapItem375 = 'GUapItem TNonSpare375 +type TNonSpare377 = 'GNonSpare "157" "Geometric Vertical Rate" TRuleVariation299 +type TUapItem377 = 'GUapItem TNonSpare377 +type TContent711 = 'GContentQuantity 'GSigned ('GNumDiv ('GNumInt ('GZ 'GPlus 1)) ('GNumPow ('GZ 'GPlus 2) ('GZ 'GPlus 14))) "NM/s" +type TRuleContent709 = 'GContextFree TContent711 +type TVariation303 = 'GElement 0 16 TRuleContent709 +type TRuleVariation295 = 'GContextFree TVariation303 +type TNonSpare1118 = 'GNonSpare "GS" "Ground Speed in Two's Complement Form Referenced to WGS84" TRuleVariation295 +type TItem396 = 'GItem TNonSpare1118 +type TNonSpare1981 = 'GNonSpare "TA" "Track Angle" TRuleVariation349 +type TItem1051 = 'GItem TNonSpare1981 +type TVariation1169 = 'GGroup 0 '[ TItem396, TItem1051] +type TRuleVariation1122 = 'GContextFree TVariation1169 +type TNonSpare380 = 'GNonSpare "160" "Ground Vector" TRuleVariation1122 +type TUapItem380 = 'GUapItem TNonSpare380 +type TContent413 = 'GContentTable '[ '(0, "Not available"), '(1, "Left"), '(2, "Right"), '(3, "Straight")] +type TRuleContent411 = 'GContextFree TContent413 +type TVariation111 = 'GElement 0 2 TRuleContent411 +type TRuleVariation111 = 'GContextFree TVariation111 +type TNonSpare2025 = 'GNonSpare "TI" "Turn Indicator" TRuleVariation111 +type TItem1081 = 'GItem TNonSpare2025 +type TContent695 = 'GContentQuantity 'GSigned ('GNumDiv ('GNumInt ('GZ 'GPlus 1)) ('GNumPow ('GZ 'GPlus 2) ('GZ 'GPlus 2))) "°/s" +type TRuleContent693 = 'GContextFree TContent695 +type TVariation171 = 'GElement 0 7 TRuleContent693 +type TRuleVariation164 = 'GContextFree TVariation171 +type TNonSpare1738 = 'GNonSpare "ROT" "Rate of Turn" TRuleVariation164 +type TItem887 = 'GItem TNonSpare1738 +type TVariation1461 = 'GExtended '[ 'Just TItem1081, 'Just TItem14, 'Nothing, 'Just TItem887, 'Nothing] +type TRuleVariation1377 = 'GContextFree TVariation1461 +type TNonSpare391 = 'GNonSpare "165" "Rate Of Turn" TRuleVariation1377 +type TUapItem391 = 'GUapItem TNonSpare391 +type TNonSpare396 = 'GNonSpare "170" "Target Identification" TRuleVariation396 +type TUapItem396 = 'GUapItem TNonSpare396 +type TNonSpare281 = 'GNonSpare "095" "Velocity Accuracy" TRuleVariation171 +type TUapItem281 = 'GUapItem TNonSpare281 +type TContent807 = 'GContentQuantity 'GUnsigned ('GNumDiv ('GNumInt ('GZ 'GPlus 1)) ('GNumPow ('GZ 'GPlus 2) ('GZ 'GPlus 8))) "s" +type TRuleContent804 = 'GContextFree TContent807 +type TVariation253 = 'GElement 0 8 TRuleContent804 +type TRuleVariation245 = 'GContextFree TVariation253 +type TNonSpare129 = 'GNonSpare "032" "Time of Day Accuracy" TRuleVariation245 +type TUapItem129 = 'GUapItem TNonSpare129 +type TContent372 = 'GContentTable '[ '(0, "No emergency / not reported"), '(1, "General emergency"), '(2, "Lifeguard / medical"), '(3, "Minimum fuel"), '(4, "No communications"), '(5, "Unlawful interference")] +type TRuleContent370 = 'GContextFree TContent372 +type TVariation185 = 'GElement 0 8 TRuleContent370 +type TRuleVariation178 = 'GContextFree TVariation185 +type TNonSpare424 = 'GNonSpare "200" "Target Status" TRuleVariation178 +type TUapItem424 = 'GUapItem TNonSpare424 +type TContent609 = 'GContentTable '[ '(1, "Light aircraft <= 7000 kg"), '(2, "Reserved"), '(3, "7000 kg < Medium aircraft < 136000 kg"), '(4, "Reserved"), '(5, "136000 kg <= Heavy aircraft"), '(6, "Highly manoeuvrable (5g acceleration capability) and high speed (>400 knots cruise)"), '(7, "Reserved"), '(8, "Reserved"), '(9, "Reserved"), '(10, "Rotocraft"), '(11, "Glider / sailplane"), '(12, "Lighter-than-air"), '(13, "Unmanned aerial vehicle"), '(14, "Space / transatmospheric vehicle"), '(15, "Ultralight / handglider / paraglider"), '(16, "Parachutist / skydiver"), '(17, "Reserved"), '(18, "Reserved"), '(19, "Reserved"), '(20, "Surface emergency vehicle"), '(21, "Surface service vehicle"), '(22, "Fixed ground or tethered obstruction"), '(23, "Reserved"), '(24, "Reserved")] +type TRuleContent607 = 'GContextFree TContent609 +type TVariation198 = 'GElement 0 8 TRuleContent607 +type TRuleVariation190 = 'GContextFree TVariation198 +type TNonSpare80 = 'GNonSpare "020" "Emitter Category" TRuleVariation190 +type TUapItem80 = 'GUapItem TNonSpare80 +type TContent744 = 'GContentQuantity 'GUnsigned ('GNumInt ('GZ 'GPlus 1)) "kt" +type TRuleContent742 = 'GContextFree TContent744 +type TVariation316 = 'GElement 0 16 TRuleContent742 +type TRuleVariation308 = 'GContextFree TVariation316 +type TNonSpare2254 = 'GNonSpare "WS" "Wind Speed" TRuleVariation308 +type TContent756 = 'GContentQuantity 'GUnsigned ('GNumInt ('GZ 'GPlus 1)) "°" +type TRuleContent754 = 'GContextFree TContent756 +type TVariation323 = 'GElement 0 16 TRuleContent754 +type TRuleVariation315 = 'GContextFree TVariation323 +type TNonSpare2247 = 'GNonSpare "WD" "Wind Direction" TRuleVariation315 +type TContent696 = 'GContentQuantity 'GSigned ('GNumDiv ('GNumInt ('GZ 'GPlus 1)) ('GNumPow ('GZ 'GPlus 2) ('GZ 'GPlus 2))) "°C" +type TRuleContent694 = 'GContextFree TContent696 +type TVariation295 = 'GElement 0 16 TRuleContent694 +type TRuleVariation287 = 'GContextFree TVariation295 +type TNonSpare2040 = 'GNonSpare "TMP" "Temperature" TRuleVariation287 +type TContent644 = 'GContentInteger 'GUnsigned +type TRuleContent642 = 'GContextFree TContent644 +type TVariation220 = 'GElement 0 8 TRuleContent642 +type TRuleVariation212 = 'GContextFree TVariation220 +type TNonSpare2079 = 'GNonSpare "TRB" "Turbulence" TRuleVariation212 +type TVariation1608 = 'GCompound '[ 'Just TNonSpare2254, 'Just TNonSpare2247, 'Just TNonSpare2040, 'Just TNonSpare2079] +type TRuleVariation1524 = 'GContextFree TVariation1608 +type TNonSpare452 = 'GNonSpare "220" "Met Information" TRuleVariation1524 +type TUapItem452 = 'GUapItem TNonSpare452 +type TContent391 = 'GContentTable '[ '(0, "No source information provided"), '(1, "Source Information provided")] +type TRuleContent389 = 'GContextFree TContent391 +type TVariation66 = 'GElement 0 1 TRuleContent389 +type TRuleVariation66 = 'GContextFree TVariation66 +type TNonSpare1805 = 'GNonSpare "SAS" "Source Availability" TRuleVariation66 +type TItem925 = 'GItem TNonSpare1805 +type TContent564 = 'GContentTable '[ '(0, "Unknown"), '(1, "Aircraft Altitude (Holding Altitude)"), '(2, "MCP/FCU Selected Altitude"), '(3, "FMS Selected Altitude")] +type TRuleContent562 = 'GContextFree TContent564 +type TVariation493 = 'GElement 1 2 TRuleContent562 +type TRuleVariation481 = 'GContextFree TVariation493 +type TNonSpare1908 = 'GNonSpare "SRC" "Source" TRuleVariation481 +type TItem1001 = 'GItem TNonSpare1908 +type TContent662 = 'GContentQuantity 'GSigned ('GNumInt ('GZ 'GPlus 25)) "ft" +type TRuleContent660 = 'GContextFree TContent662 +type TVariation722 = 'GElement 3 13 TRuleContent660 +type TRuleVariation710 = 'GContextFree TVariation722 +type TNonSpare644 = 'GNonSpare "ALT" "Altitude" TRuleVariation710 +type TItem63 = 'GItem TNonSpare644 +type TVariation1262 = 'GGroup 0 '[ TItem925, TItem1001, TItem63] +type TRuleVariation1201 = 'GContextFree TVariation1262 +type TNonSpare362 = 'GNonSpare "146" "Intermediate State Selected Altitude" TRuleVariation1201 +type TUapItem362 = 'GUapItem TNonSpare362 +type TContent409 = 'GContentTable '[ '(0, "Not active"), '(1, "Active")] +type TRuleContent407 = 'GContextFree TContent409 +type TVariation70 = 'GElement 0 1 TRuleContent407 +type TRuleVariation70 = 'GContextFree TVariation70 +type TNonSpare1451 = 'GNonSpare "MV" "Manage Vertical Mode" TRuleVariation70 +type TItem651 = 'GItem TNonSpare1451 +type TVariation458 = 'GElement 1 1 TRuleContent407 +type TRuleVariation446 = 'GContextFree TVariation458 +type TNonSpare635 = 'GNonSpare "AH" "Altitude Hold Mode" TRuleVariation446 +type TItem56 = 'GItem TNonSpare635 +type TVariation585 = 'GElement 2 1 TRuleContent407 +type TRuleVariation573 = 'GContextFree TVariation585 +type TNonSpare655 = 'GNonSpare "AM" "Approach Mode" TRuleVariation573 +type TItem70 = 'GItem TNonSpare655 +type TVariation1205 = 'GGroup 0 '[ TItem651, TItem56, TItem70, TItem63] +type TRuleVariation1153 = 'GContextFree TVariation1205 +type TNonSpare364 = 'GNonSpare "148" "Final State Selected Altitude" TRuleVariation1153 +type TUapItem364 = 'GUapItem TNonSpare364 +type TContent543 = 'GContentTable '[ '(0, "Trajectory Intent Data is available for this aircraft"), '(1, "Trajectory Intent Data is not available for this aircraft")] +type TRuleContent541 = 'GContextFree TContent543 +type TVariation96 = 'GElement 0 1 TRuleContent541 +type TRuleVariation96 = 'GContextFree TVariation96 +type TNonSpare1461 = 'GNonSpare "NAV" "" TRuleVariation96 +type TItem659 = 'GItem TNonSpare1461 +type TContent544 = 'GContentTable '[ '(0, "Trajectory Intent Data is valid"), '(1, "Trajectory Intent Data is not valid")] +type TRuleContent542 = 'GContextFree TContent544 +type TVariation475 = 'GElement 1 1 TRuleContent542 +type TRuleVariation463 = 'GContextFree TVariation475 +type TNonSpare1504 = 'GNonSpare "NVB" "" TRuleVariation463 +type TItem699 = 'GItem TNonSpare1504 +type TVariation1445 = 'GExtended '[ 'Just TItem659, 'Just TItem699, 'Just TItem14, 'Nothing] +type TRuleVariation1361 = 'GContextFree TVariation1445 +type TNonSpare2037 = 'GNonSpare "TIS" "Trajectory Intent Status" TRuleVariation1361 +type TContent489 = 'GContentTable '[ '(0, "TCP number available"), '(1, "TCP number not available")] +type TRuleContent487 = 'GContextFree TContent489 +type TVariation83 = 'GElement 0 1 TRuleContent487 +type TRuleVariation83 = 'GContextFree TVariation83 +type TNonSpare2001 = 'GNonSpare "TCA" "" TRuleVariation83 +type TItem1059 = 'GItem TNonSpare2001 +type TContent488 = 'GContentTable '[ '(0, "TCP compliance"), '(1, "TCP non-compliance")] +type TRuleContent486 = 'GContextFree TContent488 +type TVariation466 = 'GElement 1 1 TRuleContent486 +type TRuleVariation454 = 'GContextFree TVariation466 +type TNonSpare1473 = 'GNonSpare "NC" "" TRuleVariation454 +type TItem669 = 'GItem TNonSpare1473 +type TNonSpare2013 = 'GNonSpare "TCPN" "" TRuleVariation608 +type TItem1070 = 'GItem TNonSpare2013 +type TContent659 = 'GContentQuantity 'GSigned ('GNumInt ('GZ 'GPlus 10)) "ft" +type TRuleContent657 = 'GContextFree TContent659 +type TVariation275 = 'GElement 0 16 TRuleContent657 +type TRuleVariation267 = 'GContextFree TVariation275 +type TNonSpare645 = 'GNonSpare "ALT" "Altitude in Two's Complement Form" TRuleVariation267 +type TItem64 = 'GItem TNonSpare645 +type TNonSpare1229 = 'GNonSpare "LAT" "In WGS.84 in Two's Complement" TRuleVariation366 +type TItem485 = 'GItem TNonSpare1229 +type TNonSpare1261 = 'GNonSpare "LON" "In WGS.84 in Two's Complement" TRuleVariation364 +type TItem515 = 'GItem TNonSpare1261 +type TContent572 = 'GContentTable '[ '(0, "Unknown"), '(1, "Fly by waypoint (LT)"), '(2, "Fly over waypoint (LT)"), '(3, "Hold pattern (LT)"), '(4, "Procedure hold (LT)"), '(5, "Procedure turn (LT)"), '(6, "RF leg (LT)"), '(7, "Top of climb (VT)"), '(8, "Top of descent (VT)"), '(9, "Start of level (VT)"), '(10, "Cross-over altitude (VT)"), '(11, "Transition altitude (VT)")] +type TRuleContent570 = 'GContextFree TContent572 +type TVariation144 = 'GElement 0 4 TRuleContent570 +type TRuleVariation144 = 'GContextFree TVariation144 +type TNonSpare1607 = 'GNonSpare "PT" "Point Type" TRuleVariation144 +type TItem774 = 'GItem TNonSpare1607 +type TContent312 = 'GContentTable '[ '(0, "N/A"), '(1, "Turn right"), '(2, "Turn left"), '(3, "No turn")] +type TRuleContent310 = 'GContextFree TContent312 +type TVariation793 = 'GElement 4 2 TRuleContent310 +type TRuleVariation781 = 'GContextFree TVariation793 +type TNonSpare2015 = 'GNonSpare "TD" "" TRuleVariation781 +type TItem1072 = 'GItem TNonSpare2015 +type TContent491 = 'GContentTable '[ '(0, "TTR not available"), '(1, "TTR available")] +type TRuleContent489 = 'GContextFree TContent491 +type TVariation985 = 'GElement 6 1 TRuleContent489 +type TRuleVariation954 = 'GContextFree TVariation985 +type TNonSpare2069 = 'GNonSpare "TRA" "" TRuleVariation954 +type TItem1108 = 'GItem TNonSpare2069 +type TContent490 = 'GContentTable '[ '(0, "TOV available"), '(1, "TOV not available")] +type TRuleContent488 = 'GContextFree TContent490 +type TVariation1024 = 'GElement 7 1 TRuleContent488 +type TRuleVariation993 = 'GContextFree TVariation1024 +type TNonSpare2045 = 'GNonSpare "TOA" "" TRuleVariation993 +type TItem1091 = 'GItem TNonSpare2045 +type TVariation379 = 'GElement 0 24 TRuleContent751 +type TRuleVariation371 = 'GContextFree TVariation379 +type TNonSpare2057 = 'GNonSpare "TOV" "Time Over Point" TRuleVariation371 +type TItem1097 = 'GItem TNonSpare2057 +type TContent772 = 'GContentQuantity 'GUnsigned ('GNumDiv ('GNumInt ('GZ 'GPlus 1)) ('GNumInt ('GZ 'GPlus 100))) "NM" +type TRuleContent770 = 'GContextFree TContent772 +type TVariation328 = 'GElement 0 16 TRuleContent770 +type TRuleVariation320 = 'GContextFree TVariation328 +type TNonSpare2124 = 'GNonSpare "TTR" "TCP Turn Radius" TRuleVariation320 +type TItem1155 = 'GItem TNonSpare2124 +type TVariation1284 = 'GGroup 0 '[ TItem1059, TItem669, TItem1070, TItem64, TItem485, TItem515, TItem774, TItem1072, TItem1108, TItem1091, TItem1097, TItem1155] +type TVariation1515 = 'GRepetitive ('GRepetitiveRegular 1) TVariation1284 +type TRuleVariation1431 = 'GContextFree TVariation1515 +type TNonSpare2032 = 'GNonSpare "TID" "Trajectory Intent Data" TRuleVariation1431 +type TVariation1603 = 'GCompound '[ 'Just TNonSpare2037, 'Just TNonSpare2032] +type TRuleVariation1519 = 'GContextFree TVariation1603 +type TNonSpare310 = 'GNonSpare "110" "Trajectory Intent" TRuleVariation1519 +type TUapItem310 = 'GUapItem TNonSpare310 +type TRecord0 = 'GRecord '[ TUapItem29, TUapItem150, TUapItem113, TUapItem328, TUapItem248, TUapItem344, TUapItem260, TUapItem438, TUapItem464, TUapItem360, TUapItem366, TUapItem371, TUapItem373, TUapItem375, TUapItem377, TUapItem380, TUapItem391, TUapItem396, TUapItem281, TUapItem129, TUapItem424, TUapItem80, TUapItem452, TUapItem362, TUapItem364, TUapItem310, TUapItem598, TUapItem598, TUapItem598, TUapItem598, TUapItem598, TUapItem598, TUapItem598, TUapItem594, TUapItem596] +type TUap0 = 'GUap TRecord0 +type TAsterix26 = 'GAsterixBasic 21 ('GEdition 0 23) TUap0 +type TNonSpare330 = 'GNonSpare "130" "Position in WGS-84 Co-ordinates" TRuleVariation1135 +type TUapItem330 = 'GUapItem TNonSpare330 +type TRecord1 = 'GRecord '[ TUapItem29, TUapItem150, TUapItem113, TUapItem330, TUapItem248, TUapItem344, TUapItem260, TUapItem438, TUapItem464, TUapItem360, TUapItem366, TUapItem371, TUapItem373, TUapItem375, TUapItem377, TUapItem380, TUapItem391, TUapItem396, TUapItem281, TUapItem129, TUapItem424, TUapItem80, TUapItem452, TUapItem362, TUapItem364, TUapItem310, TUapItem598, TUapItem598, TUapItem598, TUapItem598, TUapItem598, TUapItem598, TUapItem598, TUapItem594, TUapItem596] +type TUap1 = 'GUap TRecord1 +type TAsterix27 = 'GAsterixBasic 21 ('GEdition 0 24) TUap1 +type TNonSpare345 = 'GNonSpare "140" "Geometric Altitude" TRuleVariation297 +type TUapItem345 = 'GUapItem TNonSpare345 +type TRecord3 = 'GRecord '[ TUapItem29, TUapItem150, TUapItem113, TUapItem330, TUapItem248, TUapItem345, TUapItem260, TUapItem438, TUapItem464, TUapItem360, TUapItem366, TUapItem371, TUapItem373, TUapItem375, TUapItem377, TUapItem380, TUapItem391, TUapItem396, TUapItem281, TUapItem129, TUapItem424, TUapItem80, TUapItem452, TUapItem362, TUapItem364, TUapItem310, TUapItem598, TUapItem598, TUapItem598, TUapItem598, TUapItem598, TUapItem598, TUapItem598, TUapItem594, TUapItem596] +type TUap3 = 'GUap TRecord3 +type TAsterix28 = 'GAsterixBasic 21 ('GEdition 0 25) TUap3 +type TContent301 = 'GContentTable '[ '(0, "Mode-3/A code derived during last update"), '(1, "Mode-3/A code not extracted during the last update")] +type TRuleContent299 = 'GContextFree TContent301 +type TVariation570 = 'GElement 2 1 TRuleContent299 +type TRuleVariation558 = 'GContextFree TVariation570 +type TNonSpare1220 = 'GNonSpare "L" "" TRuleVariation558 +type TItem476 = 'GItem TNonSpare1220 +type TVariation1327 = 'GGroup 0 '[ TItem1191, TItem377, TItem476, TItem16, TItem622] +type TRuleVariation1251 = 'GContextFree TVariation1327 +type TNonSpare219 = 'GNonSpare "070" "Mode 3/A Code in Octal Representation" TRuleVariation1251 +type TUapItem219 = 'GUapItem TNonSpare219 +type TNonSpare337 = 'GNonSpare "131" "Signal Amplitude" TRuleVariation171 +type TUapItem337 = 'GUapItem TNonSpare337 +type TRecord2 = 'GRecord '[ TUapItem29, TUapItem150, TUapItem113, TUapItem330, TUapItem248, TUapItem345, TUapItem260, TUapItem438, TUapItem464, TUapItem360, TUapItem366, TUapItem371, TUapItem373, TUapItem375, TUapItem377, TUapItem380, TUapItem391, TUapItem396, TUapItem281, TUapItem129, TUapItem424, TUapItem80, TUapItem452, TUapItem362, TUapItem364, TUapItem310, TUapItem219, TUapItem337, TUapItem598, TUapItem598, TUapItem598, TUapItem598, TUapItem598, TUapItem594, TUapItem596] +type TUap2 = 'GUap TRecord2 +type TAsterix29 = 'GAsterixBasic 21 ('GEdition 0 26) TUap2 +type TContent766 = 'GContentQuantity 'GUnsigned ('GNumDiv ('GNumInt ('GZ 'GPlus 1)) ('GNumInt ('GZ 'GPlus 10))) "hPa" +type TRuleContent764 = 'GContextFree TContent766 +type TVariation841 = 'GElement 4 12 TRuleContent764 +type TRuleVariation810 = 'GContextFree TVariation841 +type TNonSpare748 = 'GNonSpare "BPS" "Barometric Pressure Setting" TRuleVariation810 +type TItem137 = 'GItem TNonSpare748 +type TVariation1060 = 'GGroup 0 '[ TItem3, TItem137] +type TRuleVariation1029 = 'GContextFree TVariation1060 +type TNonSpare750 = 'GNonSpare "BPS" "Barometric Pressure Setting" TRuleVariation1029 +type TContent552 = 'GContentTable '[ '(0, "True North"), '(1, "Magnetic North")] +type TRuleContent550 = 'GContextFree TContent552 +type TVariation785 = 'GElement 4 1 TRuleContent550 +type TRuleVariation773 = 'GContextFree TVariation785 +type TNonSpare1140 = 'GNonSpare "HDR" "Horizontal Reference Direction" TRuleVariation773 +type TItem412 = 'GItem TNonSpare1140 +type TContent81 = 'GContentTable '[ '(0, "Data is either unavailable or invalid"), '(1, "Data is available and valid")] +type TRuleContent81 = 'GContextFree TContent81 +type TVariation857 = 'GElement 5 1 TRuleContent81 +type TRuleVariation826 = 'GContextFree TVariation857 +type TNonSpare1944 = 'GNonSpare "STAT" "Selected Heading Status" TRuleVariation826 +type TItem1024 = 'GItem TNonSpare1944 +type TContent816 = 'GContentQuantity 'GUnsigned ('GNumDiv ('GNumInt ('GZ 'GPlus 45)) ('GNumPow ('GZ 'GPlus 2) ('GZ 'GPlus 6))) "°" +type TRuleContent813 = 'GContextFree TContent816 +type TVariation1004 = 'GElement 6 10 TRuleContent813 +type TRuleVariation973 = 'GContextFree TVariation1004 +type TNonSpare1846 = 'GNonSpare "SH" "Selected Heading" TRuleVariation973 +type TItem947 = 'GItem TNonSpare1846 +type TVariation1063 = 'GGroup 0 '[ TItem3, TItem412, TItem1024, TItem947] +type TRuleVariation1031 = 'GContextFree TVariation1063 +type TNonSpare1847 = 'GNonSpare "SH" "Selected Heading" TRuleVariation1031 +type TContent46 = 'GContentTable '[ '(0, "Autopilot not engaged"), '(1, "Autopilot engaged")] +type TRuleContent46 = 'GContextFree TContent46 +type TVariation14 = 'GElement 0 1 TRuleContent46 +type TRuleVariation14 = 'GContextFree TVariation14 +type TNonSpare666 = 'GNonSpare "AP" "Autopilot" TRuleVariation14 +type TItem79 = 'GItem TNonSpare666 +type TContent588 = 'GContentTable '[ '(0, "Vertical Navigation not active"), '(1, "Vertical Navigation active")] +type TRuleContent586 = 'GContextFree TContent588 +type TVariation480 = 'GElement 1 1 TRuleContent586 +type TRuleVariation468 = 'GContextFree TVariation480 +type TNonSpare2224 = 'GNonSpare "VN" "Vertical Navigation" TRuleVariation468 +type TItem1248 = 'GItem TNonSpare2224 +type TContent36 = 'GContentTable '[ '(0, "Altitude Hold not engaged"), '(1, "Altitude Hold engaged")] +type TRuleContent36 = 'GContextFree TContent36 +type TVariation527 = 'GElement 2 1 TRuleContent36 +type TRuleVariation515 = 'GContextFree TVariation527 +type TNonSpare634 = 'GNonSpare "AH" "Altitude Hold" TRuleVariation515 +type TItem55 = 'GItem TNonSpare634 +type TContent39 = 'GContentTable '[ '(0, "Approach Mode not active"), '(1, "Approach Mode active")] +type TRuleContent39 = 'GContextFree TContent39 +type TVariation637 = 'GElement 3 1 TRuleContent39 +type TRuleVariation625 = 'GContextFree TVariation637 +type TNonSpare658 = 'GNonSpare "AM" "Approach Mode" TRuleVariation625 +type TItem73 = 'GItem TNonSpare658 +type TVariation1096 = 'GGroup 0 '[ TItem79, TItem1248, TItem55, TItem73, TItem22] +type TRuleVariation1062 = 'GContextFree TVariation1096 +type TNonSpare1462 = 'GNonSpare "NAV" "Navigation Mode" TRuleVariation1062 +type TNonSpare1099 = 'GNonSpare "GAO" "GPS Antenna Offset" TRuleVariation171 +type TContent31 = 'GContentTable '[ '(0, "Aircraft has not stopped"), '(1, "Aircraft has stopped")] +type TRuleContent31 = 'GContextFree TContent31 +type TVariation10 = 'GElement 0 1 TRuleContent31 +type TRuleVariation10 = 'GContextFree TVariation10 +type TNonSpare1957 = 'GNonSpare "STP" "" TRuleVariation10 +type TItem1036 = 'GItem TNonSpare1957 +type TContent230 = 'GContentTable '[ '(0, "Heading/Ground Track data is not valid"), '(1, "Heading/Ground Track data is valid")] +type TRuleContent230 = 'GContextFree TContent230 +type TVariation444 = 'GElement 1 1 TRuleContent230 +type TRuleVariation432 = 'GContextFree TVariation444 +type TNonSpare1160 = 'GNonSpare "HTS" "" TRuleVariation432 +type TItem427 = 'GItem TNonSpare1160 +type TContent229 = 'GContentTable '[ '(0, "Heading data provided"), '(1, "Ground Track provided")] +type TRuleContent229 = 'GContextFree TContent229 +type TVariation553 = 'GElement 2 1 TRuleContent229 +type TRuleVariation541 = 'GContextFree TVariation553 +type TNonSpare1161 = 'GNonSpare "HTT" "" TRuleVariation541 +type TItem428 = 'GItem TNonSpare1161 +type TVariation692 = 'GElement 3 1 TRuleContent550 +type TRuleVariation680 = 'GContextFree TVariation692 +type TNonSpare1159 = 'GNonSpare "HRD" "" TRuleVariation680 +type TItem426 = 'GItem TNonSpare1159 +type TContent792 = 'GContentQuantity 'GUnsigned ('GNumDiv ('GNumInt ('GZ 'GPlus 1)) ('GNumPow ('GZ 'GPlus 2) ('GZ 'GPlus 3))) "kt" +type TRuleContent789 = 'GContextFree TContent792 +type TVariation836 = 'GElement 4 11 TRuleContent789 +type TRuleVariation805 = 'GContextFree TVariation836 +type TNonSpare1122 = 'GNonSpare "GSS" "Ground Speed" TRuleVariation805 +type TItem399 = 'GItem TNonSpare1122 +type TContent815 = 'GContentQuantity 'GUnsigned ('GNumDiv ('GNumInt ('GZ 'GPlus 45)) ('GNumPow ('GZ 'GPlus 2) ('GZ 'GPlus 4))) "°" +type TRuleContent812 = 'GContextFree TContent815 +type TVariation176 = 'GElement 0 7 TRuleContent812 +type TRuleVariation169 = 'GContextFree TVariation176 +type TNonSpare1145 = 'GNonSpare "HGT" "Heading/Ground Track Information" TRuleVariation169 +type TItem415 = 'GItem TNonSpare1145 +type TVariation1459 = 'GExtended '[ 'Just TItem1036, 'Just TItem427, 'Just TItem428, 'Just TItem426, 'Just TItem399, 'Nothing, 'Just TItem415, 'Nothing] +type TRuleVariation1375 = 'GContextFree TVariation1459 +type TNonSpare1845 = 'GNonSpare "SGV" "Surface Ground Vector" TRuleVariation1375 +type TContent502 = 'GContentTable '[ '(0, "Target is not 1090 ES IN capable"), '(1, "Target is 1090 ES IN capable")] +type TRuleContent500 = 'GContextFree TContent502 +type TVariation85 = 'GElement 0 1 TRuleContent500 +type TRuleVariation85 = 'GContextFree TVariation85 +type TNonSpare1035 = 'GNonSpare "ES" "" TRuleVariation85 +type TItem341 = 'GItem TNonSpare1035 +type TContent503 = 'GContentTable '[ '(0, "Target is not UAT IN capable"), '(1, "Target is UAT IN capable")] +type TRuleContent501 = 'GContextFree TContent503 +type TVariation468 = 'GElement 1 1 TRuleContent501 +type TRuleVariation456 = 'GContextFree TVariation468 +type TNonSpare2150 = 'GNonSpare "UAT" "" TRuleVariation456 +type TItem1178 = 'GItem TNonSpare2150 +type TVariation1428 = 'GExtended '[ 'Just TItem341, 'Just TItem1178, 'Just TItem14, 'Nothing] +type TRuleVariation1344 = 'GContextFree TVariation1428 +type TNonSpare1930 = 'GNonSpare "STA" "Aircraft Status" TRuleVariation1344 +type TNonSpare2044 = 'GNonSpare "TNH" "True North Heading" TRuleVariation349 +type TContent344 = 'GContentTable '[ '(0, "No authenticated Mode 5 ID reply/report"), '(1, "Authenticated Mode 5 ID reply/report")] +type TRuleContent342 = 'GContextFree TContent344 +type TVariation457 = 'GElement 1 1 TRuleContent342 +type TRuleVariation445 = 'GContextFree TVariation457 +type TNonSpare1188 = 'GNonSpare "ID" "" TRuleVariation445 +type TItem450 = 'GItem TNonSpare1188 +type TContent284 = 'GContentTable '[ '(0, "Mode 1 code not present or not from Mode 5 reply/report"), '(1, "Mode 1 code from Mode 5 reply/report")] +type TRuleContent282 = 'GContextFree TContent284 +type TVariation667 = 'GElement 3 1 TRuleContent282 +type TRuleVariation655 = 'GContextFree TVariation667 +type TNonSpare1291 = 'GNonSpare "M1" "" TRuleVariation655 +type TItem543 = 'GItem TNonSpare1291 +type TContent286 = 'GContentTable '[ '(0, "Mode 2 code not present or not from Mode 5 reply/report"), '(1, "Mode 2 code from Mode 5 reply/report")] +type TRuleContent284 = 'GContextFree TContent286 +type TVariation759 = 'GElement 4 1 TRuleContent284 +type TRuleVariation747 = 'GContextFree TVariation759 +type TNonSpare1294 = 'GNonSpare "M2" "" TRuleVariation747 +type TItem546 = 'GItem TNonSpare1294 +type TContent288 = 'GContentTable '[ '(0, "Mode 3 code not present or not from Mode 5 reply/report"), '(1, "Mode 3 code from Mode 5 reply/report")] +type TRuleContent286 = 'GContextFree TContent288 +type TVariation891 = 'GElement 5 1 TRuleContent286 +type TRuleVariation860 = 'GContextFree TVariation891 +type TNonSpare1299 = 'GNonSpare "M3" "" TRuleVariation860 +type TItem550 = 'GItem TNonSpare1299 +type TContent220 = 'GContentTable '[ '(0, "Flightlevel not present or not from Mode 5 reply/report"), '(1, "Flightlevel from Mode 5 reply/report")] +type TRuleContent220 = 'GContextFree TContent220 +type TVariation958 = 'GElement 6 1 TRuleContent220 +type TRuleVariation927 = 'GContextFree TVariation958 +type TNonSpare1339 = 'GNonSpare "MC" "" TRuleVariation927 +type TItem576 = 'GItem TNonSpare1339 +type TContent452 = 'GContentTable '[ '(0, "Position not from Mode 5 report (ADS-B report)"), '(1, "Position from Mode 5 report")] +type TRuleContent450 = 'GContextFree TContent452 +type TVariation1023 = 'GElement 7 1 TRuleContent450 +type TRuleVariation992 = 'GContextFree TVariation1023 +type TNonSpare1559 = 'GNonSpare "PO" "" TRuleVariation992 +type TItem742 = 'GItem TNonSpare1559 +type TVariation1198 = 'GGroup 0 '[ TItem558, TItem450, TItem253, TItem543, TItem546, TItem550, TItem576, TItem742] +type TRuleVariation1149 = 'GContextFree TVariation1198 +type TNonSpare1971 = 'GNonSpare "SUM" "Mode 5 Summary" TRuleVariation1149 +type TVariation924 = 'GElement 5 11 TRuleContent0 +type TRuleVariation893 = 'GContextFree TVariation924 +type TNonSpare1478 = 'GNonSpare "NO" "National Origin Code" TRuleVariation893 +type TItem674 = 'GItem TNonSpare1478 +type TVariation1046 = 'GGroup 0 '[ TItem1, TItem739, TItem4, TItem674] +type TRuleVariation1015 = 'GContextFree TVariation1046 +type TNonSpare1558 = 'GNonSpare "PNO" "Mode 5 PIN / National Origin" TRuleVariation1015 +type TContent282 = 'GContentTable '[ '(0, "Mode 1 code as derived from the report of the transponder"), '(1, "Smoothed Mode 1 code as provided by a local tracker")] +type TRuleContent280 = 'GContextFree TContent282 +type TVariation561 = 'GElement 2 1 TRuleContent280 +type TRuleVariation549 = 'GContextFree TVariation561 +type TNonSpare1211 = 'GNonSpare "L" "" TRuleVariation549 +type TItem467 = 'GItem TNonSpare1211 +type TVariation1315 = 'GGroup 0 '[ TItem1191, TItem7, TItem467, TItem16, TItem307] +type TRuleVariation1239 = 'GContextFree TVariation1315 +type TNonSpare996 = 'GNonSpare "EM1" "Extended Mode 1 Code in Octal Representation" TRuleVariation1239 +type TContent591 = 'GContentTable '[ '(0, "X-Pulse not present"), '(1, "X-pulse present")] +type TRuleContent589 = 'GContextFree TContent591 +type TVariation602 = 'GElement 2 1 TRuleContent589 +type TRuleVariation590 = 'GContextFree TVariation602 +type TNonSpare2310 = 'GNonSpare "XP" "X-pulse from Mode 5 PIN Reply/report" TRuleVariation590 +type TItem1322 = 'GItem TNonSpare2310 +type TContent1 = 'GContentTable '[ '(0, "0 X-pulse set to zero or no Mode 2 reply"), '(1, "X-pulse set to one (present)")] +type TRuleContent1 = 'GContextFree TContent1 +type TVariation930 = 'GElement 6 1 TRuleContent1 +type TRuleVariation899 = 'GContextFree TVariation930 +type TNonSpare2297 = 'GNonSpare "X2" "X-pulse from Mode 2 Reply" TRuleVariation899 +type TItem1313 = 'GItem TNonSpare2297 +type TVariation1051 = 'GGroup 0 '[ TItem1, TItem1322, TItem1317, TItem1320, TItem1316, TItem1313, TItem1310] +type TRuleVariation1020 = 'GContextFree TVariation1051 +type TNonSpare2307 = 'GNonSpare "XP" "X Pulse Presence" TRuleVariation1020 +type TNonSpare1058 = 'GNonSpare "FOM" "Figure of Merit" TRuleVariation708 +type TItem359 = 'GItem TNonSpare1058 +type TVariation1054 = 'GGroup 0 '[ TItem2, TItem359] +type TRuleVariation1023 = 'GContextFree TVariation1054 +type TNonSpare1060 = 'GNonSpare "FOM" "Figure of Merit" TRuleVariation1023 +type TNonSpare1411 = 'GNonSpare "MODE2" "Mode 2 Code in Octal Representation" TRuleVariation807 +type TItem615 = 'GItem TNonSpare1411 +type TVariation1316 = 'GGroup 0 '[ TItem1191, TItem7, TItem473, TItem16, TItem615] +type TRuleVariation1240 = 'GContextFree TVariation1316 +type TNonSpare1297 = 'GNonSpare "M2" "Mode 2 Code in Octal Representation" TRuleVariation1240 +type TVariation1596 = 'GCompound '[ 'Just TNonSpare1971, 'Just TNonSpare1558, 'Just TNonSpare996, 'Just TNonSpare2307, 'Just TNonSpare1060, 'Just TNonSpare1297] +type TRuleVariation1512 = 'GContextFree TVariation1596 +type TNonSpare1377 = 'GNonSpare "MES" "Military Extended Squitter" TRuleVariation1512 +type TExpansion0 = 'GExpansion ('Just 1) '[ 'Just TNonSpare750, 'Just TNonSpare1847, 'Just TNonSpare1462, 'Just TNonSpare1099, 'Just TNonSpare1845, 'Just TNonSpare1930, 'Just TNonSpare2044, 'Just TNonSpare1377] +type TAsterix30 = 'GAsterixExpansion 21 ('GEdition 1 4) TExpansion0 +type TVariation746 = 'GElement 4 1 TRuleContent210 +type TRuleVariation734 = 'GContextFree TVariation746 +type TNonSpare1015 = 'GNonSpare "EP" "Element Populated Bit" TRuleVariation734 +type TItem323 = 'GItem TNonSpare1015 +type TContent270 = 'GContentTable '[ '(0, "MCP/FCU Mode Bits not populated"), '(1, "MCP/FCU Mode Bits populated")] +type TRuleContent268 = 'GContextFree TContent270 +type TVariation889 = 'GElement 5 1 TRuleContent268 +type TRuleVariation858 = 'GContextFree TVariation889 +type TNonSpare2204 = 'GNonSpare "VAL" "Value" TRuleVariation858 +type TItem1229 = 'GItem TNonSpare2204 +type TVariation1402 = 'GGroup 4 '[ TItem323, TItem1229] +type TRuleVariation1321 = 'GContextFree TVariation1402 +type TNonSpare1385 = 'GNonSpare "MFM" "Status of MCP/FCU Mode Bits" TRuleVariation1321 +type TItem595 = 'GItem TNonSpare1385 +type TVariation1097 = 'GGroup 0 '[ TItem79, TItem1248, TItem55, TItem73, TItem595, TItem27] +type TRuleVariation1063 = 'GContextFree TVariation1097 +type TNonSpare1463 = 'GNonSpare "NAV" "Navigation Mode" TRuleVariation1063 +type TNonSpare1098 = 'GNonSpare "GAO" "GPS Antenna Offset" TRuleVariation171 +type TNonSpare1037 = 'GNonSpare "ES" "ES IN Capability" TRuleVariation85 +type TItem342 = 'GItem TNonSpare1037 +type TNonSpare2155 = 'GNonSpare "UAT" "UAT IN Capability" TRuleVariation456 +type TItem1182 = 'GItem TNonSpare2155 +type TVariation551 = 'GElement 2 1 TRuleContent210 +type TRuleVariation539 = 'GContextFree TVariation551 +type TNonSpare1013 = 'GNonSpare "EP" "Element Populated Bit" TRuleVariation539 +type TItem321 = 'GItem TNonSpare1013 +type TContent408 = 'GContentTable '[ '(0, "Not RCE"), '(1, "TABS (see Note 2)"), '(2, "Reserved for future use"), '(3, "Other RCE")] +type TRuleContent406 = 'GContextFree TContent408 +type TVariation703 = 'GElement 3 2 TRuleContent406 +type TRuleVariation691 = 'GContextFree TVariation703 +type TNonSpare2198 = 'GNonSpare "VAL" "Value" TRuleVariation691 +type TItem1223 = 'GItem TNonSpare2198 +type TVariation1390 = 'GGroup 2 '[ TItem321, TItem1223] +type TRuleVariation1309 = 'GContextFree TVariation1390 +type TNonSpare1682 = 'GNonSpare "RCE" "Reduced Capability Equipment" TRuleVariation1309 +type TItem840 = 'GItem TNonSpare1682 +type TVariation877 = 'GElement 5 1 TRuleContent210 +type TRuleVariation846 = 'GContextFree TVariation877 +type TNonSpare1016 = 'GNonSpare "EP" "Element Populated Bit" TRuleVariation846 +type TItem324 = 'GItem TNonSpare1016 +type TContent461 = 'GContentTable '[ '(0, "Reply Rate Limiting is not active"), '(1, "Reply Rate Limiting is active")] +type TRuleContent459 = 'GContextFree TContent461 +type TVariation979 = 'GElement 6 1 TRuleContent459 +type TRuleVariation948 = 'GContextFree TVariation979 +type TNonSpare2208 = 'GNonSpare "VAL" "Value" TRuleVariation948 +type TItem1233 = 'GItem TNonSpare2208 +type TVariation1409 = 'GGroup 5 '[ TItem324, TItem1233] +type TRuleVariation1325 = 'GContextFree TVariation1409 +type TNonSpare1751 = 'GNonSpare "RRL" "Reply Rate Limiting" TRuleVariation1325 +type TItem893 = 'GItem TNonSpare1751 +type TContent374 = 'GContentTable '[ '(0, "No emergency / not reported"), '(1, "General emergency"), '(2, "UAS/RPAS - Lost link"), '(3, "Minimum fuel"), '(4, "No communications"), '(5, "Unlawful interference"), '(6, "Aircraft in Distress"), '(7, "Aircraft in Distress Manual Activation")] +type TRuleContent372 = 'GContextFree TContent374 +type TVariation500 = 'GElement 1 3 TRuleContent372 +type TRuleVariation488 = 'GContextFree TVariation500 +type TNonSpare2193 = 'GNonSpare "VAL" "Value" TRuleVariation488 +type TItem1218 = 'GItem TNonSpare2193 +type TVariation1152 = 'GGroup 0 '[ TItem320, TItem1218] +type TRuleVariation1105 = 'GContextFree TVariation1152 +type TNonSpare1595 = 'GNonSpare "PS3" "Priority Status for Version 3 ADS-B Systems" TRuleVariation1105 +type TItem768 = 'GItem TNonSpare1595 +type TContent557 = 'GContentTable '[ '(0, "Unavailable, Unknown, or less than 70 W"), '(1, "70 W"), '(2, "125 W"), '(3, "200 W")] +type TRuleContent555 = 'GContextFree TContent557 +type TVariation916 = 'GElement 5 2 TRuleContent555 +type TRuleVariation885 = 'GContextFree TVariation916 +type TNonSpare2205 = 'GNonSpare "VAL" "Value" TRuleVariation885 +type TItem1230 = 'GItem TNonSpare2205 +type TVariation1403 = 'GGroup 4 '[ TItem323, TItem1230] +type TRuleVariation1322 = 'GContextFree TVariation1403 +type TNonSpare2066 = 'GNonSpare "TPW" "Transmit Power" TRuleVariation1322 +type TItem1106 = 'GItem TNonSpare2066 +type TContent579 = 'GContentTable '[ '(0, "Unknown"), '(1, "Transponder #1 (left/pilot side or single)"), '(2, "Transponder #2 (right/co-pilot side)"), '(3, "Transponder #3 (auxiliary or Backup)")] +type TRuleContent577 = 'GContextFree TContent579 +type TVariation496 = 'GElement 1 2 TRuleContent577 +type TRuleVariation484 = 'GContextFree TVariation496 +type TNonSpare2191 = 'GNonSpare "VAL" "Value" TRuleVariation484 +type TItem1216 = 'GItem TNonSpare2191 +type TVariation1150 = 'GGroup 0 '[ TItem320, TItem1216] +type TRuleVariation1103 = 'GContextFree TVariation1150 +type TNonSpare2103 = 'GNonSpare "TSI" "Transponder Side Indication" TRuleVariation1103 +type TItem1136 = 'GItem TNonSpare2103 +type TVariation659 = 'GElement 3 1 TRuleContent210 +type TRuleVariation647 = 'GContextFree TVariation659 +type TNonSpare1014 = 'GNonSpare "EP" "Element Populated Bit" TRuleVariation647 +type TItem322 = 'GItem TNonSpare1014 +type TContent275 = 'GContentTable '[ '(0, "Manned Operation"), '(1, "Unmanned Operation")] +type TRuleContent273 = 'GContextFree TContent275 +type TVariation756 = 'GElement 4 1 TRuleContent273 +type TRuleVariation744 = 'GContextFree TVariation756 +type TNonSpare2199 = 'GNonSpare "VAL" "Value" TRuleVariation744 +type TItem1224 = 'GItem TNonSpare2199 +type TVariation1396 = 'GGroup 3 '[ TItem322, TItem1224] +type TRuleVariation1315 = 'GContextFree TVariation1396 +type TNonSpare1450 = 'GNonSpare "MUO" "Manned / Unmanned Operation" TRuleVariation1315 +type TItem650 = 'GItem TNonSpare1450 +type TContent458 = 'GContentTable '[ '(0, "RWC Corrective Alert not active"), '(1, "RWC Corrective Alert active")] +type TRuleContent456 = 'GContextFree TContent458 +type TVariation978 = 'GElement 6 1 TRuleContent456 +type TRuleVariation947 = 'GContextFree TVariation978 +type TNonSpare2207 = 'GNonSpare "VAL" "Value" TRuleVariation947 +type TItem1232 = 'GItem TNonSpare2207 +type TVariation1408 = 'GGroup 5 '[ TItem324, TItem1232] +type TRuleVariation1324 = 'GContextFree TVariation1408 +type TNonSpare1783 = 'GNonSpare "RWC" "Remain Well Clear Corrective Alert" TRuleVariation1324 +type TItem911 = 'GItem TNonSpare1783 +type TContent331 = 'GContentTable '[ '(0, "No RWC Capability"), '(1, "RWC/RA/OCM Capability"), '(2, "RWC/OCM Capability"), '(3, "Invalid ASTERIX Value")] +type TRuleContent329 = 'GContextFree TContent331 +type TVariation486 = 'GElement 1 2 TRuleContent329 +type TRuleVariation474 = 'GContextFree TVariation486 +type TNonSpare2188 = 'GNonSpare "VAL" "Value" TRuleVariation474 +type TItem1213 = 'GItem TNonSpare2188 +type TVariation1147 = 'GGroup 0 '[ TItem320, TItem1213] +type TRuleVariation1100 = 'GContextFree TVariation1147 +type TNonSpare929 = 'GNonSpare "DAA" "Detectand Avoid Capabilities" TRuleVariation1100 +type TItem256 = 'GItem TNonSpare929 +type TNonSpare2201 = 'GNonSpare "VAL" "Value" TRuleVariation789 +type TItem1226 = 'GItem TNonSpare2201 +type TVariation1398 = 'GGroup 3 '[ TItem322, TItem1226] +type TRuleVariation1317 = 'GContextFree TVariation1398 +type TNonSpare951 = 'GNonSpare "DF17CA" "Transponder Capability" TRuleVariation1317 +type TItem276 = 'GItem TNonSpare951 +type TContent589 = 'GContentTable '[ '(0, "Vertical Only"), '(1, "Horizontal Only"), '(2, "Blended"), '(3, "Vertical Only or Horizontal Only per intruder")] +type TRuleContent587 = 'GContextFree TContent589 +type TVariation497 = 'GElement 1 2 TRuleContent587 +type TRuleVariation485 = 'GContextFree TVariation497 +type TNonSpare2192 = 'GNonSpare "VAL" "Value" TRuleVariation485 +type TItem1217 = 'GItem TNonSpare2192 +type TVariation1151 = 'GGroup 0 '[ TItem320, TItem1217] +type TRuleVariation1104 = 'GContextFree TVariation1151 +type TNonSpare1976 = 'GNonSpare "SVH" "Sense Vertical & Horizontal" TRuleVariation1104 +type TItem1046 = 'GItem TNonSpare1976 +type TNonSpare1017 = 'GNonSpare "EP" "Element Population Bit" TRuleVariation647 +type TItem325 = 'GItem TNonSpare1017 +type TContent19 = 'GContentTable '[ '(0, "Active CAS (TCAS II) or no CAS"), '(1, "Active CAS (not TCAS II)"), '(2, "Active CAS (not TCAS II) with OCM transmit capability"), '(3, "Active CAS of Junior Status"), '(4, "Passive CAS with 1030TCAS Resolution Message receive capability"), '(5, "Passive CAS with only OCM receive capability"), '(6, "Reserved for future use"), '(7, "Reserved for future use")] +type TRuleContent19 = 'GContextFree TContent19 +type TVariation807 = 'GElement 4 3 TRuleContent19 +type TRuleVariation792 = 'GContextFree TVariation807 +type TNonSpare2203 = 'GNonSpare "VAL" "Value" TRuleVariation792 +type TItem1228 = 'GItem TNonSpare2203 +type TVariation1400 = 'GGroup 3 '[ TItem325, TItem1228] +type TRuleVariation1319 = 'GContextFree TVariation1400 +type TNonSpare771 = 'GNonSpare "CATC" "CAS Type & Capability" TRuleVariation1319 +type TItem149 = 'GItem TNonSpare771 +type TContent209 = 'GContentTable '[ '(0, "Element Not Populated"), '(1, "Element Populated")] +type TRuleContent209 = 'GContextFree TContent209 +type TVariation43 = 'GElement 0 1 TRuleContent209 +type TRuleVariation43 = 'GContextFree TVariation43 +type TNonSpare1011 = 'GNonSpare "EP" "Element Populated Bit" TRuleVariation43 +type TItem319 = 'GItem TNonSpare1011 +type TContent360 = 'GContentTable '[ '(0, "No data"), '(1, "0 ≤ TAO ≤ 1"), '(2, "1 < TAO ≤ 2"), '(3, "2 < TAO ≤ 4"), '(4, "4 < TAO ≤ 6"), '(5, "6 < TAO ≤ 8"), '(6, "8 < TAO ≤ 10"), '(7, "10 < TAO ≤ 12"), '(8, "12 < TAO ≤ 14"), '(9, "14 < TAO ≤ 16"), '(10, "16 < TAO ≤ 18"), '(11, "18 < TAO ≤ 20"), '(12, "20 < TAO ≤ 22"), '(13, "22 < TAO ≤ 24"), '(14, "24 < TAO ≤ 26"), '(15, "26 < TAO ≤ 28"), '(16, "28 < TAO ≤ 30"), '(17, "30 < TAO ≤ 32"), '(18, "32 < TAO ≤ 34"), '(19, "34 < TAO ≤ 36"), '(20, "36 < TAO ≤ 38"), '(21, "38 < TAO ≤ 40"), '(22, "40 < TAO ≤ 42"), '(23, "42 < TAO ≤ 44"), '(24, "44 < TAO ≤ 46"), '(25, "46 < TAO ≤ 48"), '(26, "48 < TAO ≤ 50"), '(27, "50 < TAO ≤ 52"), '(28, "52 < TAO ≤ 54"), '(29, "54 < TAO ≤ 56"), '(30, "56 < TAO ≤ 58"), '(31, "TAO > 58")] +type TRuleContent358 = 'GContextFree TContent360 +type TVariation507 = 'GElement 1 5 TRuleContent358 +type TRuleVariation495 = 'GContextFree TVariation507 +type TNonSpare2194 = 'GNonSpare "VAL" "Value" TRuleVariation495 +type TItem1219 = 'GItem TNonSpare2194 +type TVariation1143 = 'GGroup 0 '[ TItem319, TItem1219, TItem26] +type TRuleVariation1096 = 'GContextFree TVariation1143 +type TNonSpare1987 = 'GNonSpare "TAO" "Transponder Antenna Offset" TRuleVariation1096 +type TItem1053 = 'GItem TNonSpare1987 +type TVariation1429 = 'GExtended '[ 'Just TItem342, 'Just TItem1182, 'Just TItem840, 'Just TItem893, 'Nothing, 'Just TItem768, 'Just TItem1106, 'Nothing, 'Just TItem1136, 'Just TItem650, 'Just TItem911, 'Nothing, 'Just TItem256, 'Just TItem276, 'Nothing, 'Just TItem1046, 'Just TItem149, 'Nothing, 'Just TItem1053, 'Nothing] +type TRuleVariation1345 = 'GContextFree TVariation1429 +type TNonSpare1931 = 'GNonSpare "STA" "Aircraft Status" TRuleVariation1345 +type TExpansion1 = 'GExpansion ('Just 1) '[ 'Just TNonSpare750, 'Just TNonSpare1847, 'Just TNonSpare1463, 'Just TNonSpare1098, 'Just TNonSpare1845, 'Just TNonSpare1931, 'Just TNonSpare2044, 'Just TNonSpare1377] +type TAsterix31 = 'GAsterixExpansion 21 ('GEdition 1 5) TExpansion1 +type TContent6 = 'GContentTable '[ '(0, "24-Bit ICAO address"), '(1, "Duplicate address"), '(2, "Surface vehicle address"), '(3, "Anonymous address"), '(4, "Reserved for future use"), '(5, "Reserved for future use"), '(6, "Reserved for future use"), '(7, "Reserved for future use")] +type TRuleContent6 = 'GContextFree TContent6 +type TVariation129 = 'GElement 0 3 TRuleContent6 +type TRuleVariation129 = 'GContextFree TVariation129 +type TNonSpare697 = 'GNonSpare "ATP" "Address Type" TRuleVariation129 +type TItem93 = 'GItem TNonSpare697 +type TContent7 = 'GContentTable '[ '(0, "25 ft"), '(1, "100 ft"), '(2, "Unknown"), '(3, "Invalid")] +type TRuleContent7 = 'GContextFree TContent7 +type TVariation699 = 'GElement 3 2 TRuleContent7 +type TRuleVariation687 = 'GContextFree TVariation699 +type TNonSpare680 = 'GNonSpare "ARC" "Altitude Reporting Capability" TRuleVariation687 +type TItem85 = 'GItem TNonSpare680 +type TContent150 = 'GContentTable '[ '(0, "Default"), '(1, "Range Check passed, CPR Validation pending")] +type TRuleContent150 = 'GContextFree TContent150 +type TVariation864 = 'GElement 5 1 TRuleContent150 +type TRuleVariation833 = 'GContextFree TVariation864 +type TNonSpare1679 = 'GNonSpare "RC" "Range Check" TRuleVariation833 +type TItem837 = 'GItem TNonSpare1679 +type TVariation981 = 'GElement 6 1 TRuleContent463 +type TRuleVariation950 = 'GContextFree TVariation981 +type TNonSpare1668 = 'GNonSpare "RAB" "Report Type" TRuleVariation950 +type TItem828 = 'GItem TNonSpare1668 +type TVariation747 = 'GElement 4 1 TRuleContent216 +type TRuleVariation735 = 'GContextFree TVariation747 +type TNonSpare1790 = 'GNonSpare "SAA" "Selected Altitude Available" TRuleVariation735 +type TItem917 = 'GItem TNonSpare1790 +type TContent467 = 'GContentTable '[ '(0, "Report valid"), '(1, "Report suspect"), '(2, "No information"), '(3, "Reserved for future use")] +type TRuleContent465 = 'GContextFree TContent467 +type TVariation913 = 'GElement 5 2 TRuleContent465 +type TRuleVariation882 = 'GContextFree TVariation913 +type TNonSpare807 = 'GNonSpare "CL" "Confidence Level" TRuleVariation882 +type TItem174 = 'GItem TNonSpare807 +type TContent175 = 'GContentTable '[ '(0, "Default (see note)"), '(1, "Independent Position Check failed")] +type TRuleContent175 = 'GContextFree TContent175 +type TVariation543 = 'GElement 2 1 TRuleContent175 +type TRuleVariation531 = 'GContextFree TVariation543 +type TNonSpare1201 = 'GNonSpare "IPC" "Independent Position Check" TRuleVariation531 +type TItem459 = 'GItem TNonSpare1201 +type TContent313 = 'GContentTable '[ '(0, "NOGO-bit not set"), '(1, "NOGO-bit set")] +type TRuleContent311 = 'GContextFree TContent313 +type TVariation670 = 'GElement 3 1 TRuleContent311 +type TRuleVariation658 = 'GContextFree TVariation670 +type TNonSpare1483 = 'GNonSpare "NOGO" "No-go Bit Status" TRuleVariation658 +type TItem679 = 'GItem TNonSpare1483 +type TContent53 = 'GContentTable '[ '(0, "CPR Validation correct"), '(1, "CPR Validation failed")] +type TRuleContent53 = 'GContextFree TContent53 +type TVariation727 = 'GElement 4 1 TRuleContent53 +type TRuleVariation715 = 'GContextFree TVariation727 +type TNonSpare891 = 'GNonSpare "CPR" "Compact Position Reporting" TRuleVariation715 +type TItem227 = 'GItem TNonSpare891 +type TContent259 = 'GContentTable '[ '(0, "LDPJ not detected"), '(1, "LDPJ detected")] +type TRuleContent257 = 'GContextFree TContent259 +type TVariation888 = 'GElement 5 1 TRuleContent257 +type TRuleVariation857 = 'GContextFree TVariation888 +type TNonSpare1247 = 'GNonSpare "LDPJ" "Local Decoding Position Jump" TRuleVariation857 +type TItem502 = 'GItem TNonSpare1247 +type TContent149 = 'GContentTable '[ '(0, "Default"), '(1, "Range Check failed")] +type TRuleContent149 = 'GContextFree TContent149 +type TVariation948 = 'GElement 6 1 TRuleContent149 +type TRuleVariation917 = 'GContextFree TVariation948 +type TNonSpare1683 = 'GNonSpare "RCF" "Range Check" TRuleVariation917 +type TItem841 = 'GItem TNonSpare1683 +type TVariation1418 = 'GExtended '[ 'Just TItem93, 'Just TItem85, 'Just TItem837, 'Just TItem828, 'Nothing, 'Just TItem271, 'Just TItem391, 'Just TItem971, 'Just TItem1143, 'Just TItem917, 'Just TItem174, 'Nothing, 'Just TItem1, 'Just TItem459, 'Just TItem679, 'Just TItem227, 'Just TItem502, 'Just TItem841, 'Nothing] +type TRuleVariation1334 = 'GContextFree TVariation1418 +type TNonSpare154 = 'GNonSpare "040" "Target Report Descriptor" TRuleVariation1334 +type TUapItem154 = 'GUapItem TNonSpare154 +type TNonSpare2093 = 'GNonSpare "TRNUM" "Track Number" TRuleVariation806 +type TItem1127 = 'GItem TNonSpare2093 +type TVariation1078 = 'GGroup 0 '[ TItem3, TItem1127] +type TRuleVariation1045 = 'GContextFree TVariation1078 +type TNonSpare388 = 'GNonSpare "161" "Track Number" TRuleVariation1045 +type TUapItem388 = 'GUapItem TNonSpare388 +type TNonSpare64 = 'GNonSpare "015" "Service Identification" TRuleVariation171 +type TUapItem64 = 'GUapItem TNonSpare64 +type TNonSpare233 = 'GNonSpare "071" "Time of Applicability for Position" TRuleVariation376 +type TUapItem233 = 'GUapItem TNonSpare233 +type TNonSpare329 = 'GNonSpare "130" "Position in WGS-84 Co-ordinates" TRuleVariation1133 +type TUapItem329 = 'GUapItem TNonSpare329 +type TNonSpare335 = 'GNonSpare "131" "High-Resolution Position in WGS-84 Co-ordinates" TRuleVariation1136 +type TUapItem335 = 'GUapItem TNonSpare335 +type TNonSpare234 = 'GNonSpare "072" "Time of Applicability for Velocity" TRuleVariation376 +type TUapItem234 = 'GUapItem TNonSpare234 +type TContent587 = 'GContentTable '[ '(0, "Value in defined range"), '(1, "Value exceeds defined range")] +type TRuleContent585 = 'GContextFree TContent587 +type TVariation100 = 'GElement 0 1 TRuleContent585 +type TRuleVariation100 = 'GContextFree TVariation100 +type TNonSpare1700 = 'GNonSpare "RE" "Range Exceeded Indicator" TRuleVariation100 +type TItem853 = 'GItem TNonSpare1700 +type TVariation519 = 'GElement 1 15 TRuleContent741 +type TRuleVariation507 = 'GContextFree TVariation519 +type TNonSpare1993 = 'GNonSpare "TAS" "True Air Speed" TRuleVariation507 +type TItem1056 = 'GItem TNonSpare1993 +type TVariation1235 = 'GGroup 0 '[ TItem853, TItem1056] +type TRuleVariation1181 = 'GContextFree TVariation1235 +type TNonSpare372 = 'GNonSpare "151" "True Airspeed" TRuleVariation1181 +type TUapItem372 = 'GUapItem TNonSpare372 +type TNonSpare235 = 'GNonSpare "073" "Time of Message Reception for Position" TRuleVariation376 +type TUapItem235 = 'GUapItem TNonSpare235 +type TContent633 = 'GContentTable '[ '(3, "Reserved"), '(2, "TOMRp whole seconds = (I021/073) Whole seconds - 1"), '(1, "TOMRp whole seconds = (I021/073) Whole seconds + 1"), '(0, "TOMRp whole seconds = (I021/073) Whole seconds")] +type TRuleContent631 = 'GContextFree TContent633 +type TVariation125 = 'GElement 0 2 TRuleContent631 +type TRuleVariation125 = 'GContextFree TVariation125 +type TNonSpare1075 = 'GNonSpare "FSI" "Full Second Indication" TRuleVariation125 +type TItem370 = 'GItem TNonSpare1075 +type TContent811 = 'GContentQuantity 'GUnsigned ('GNumDiv ('GNumInt ('GZ 'GPlus 1)) ('GNumPow ('GZ 'GPlus 2) ('GZ 'GPlus 30))) "s" +type TRuleContent808 = 'GContextFree TContent811 +type TVariation632 = 'GElement 2 30 TRuleContent808 +type TRuleVariation620 = 'GContextFree TVariation632 +type TNonSpare2052 = 'GNonSpare "TOMRP" "Fractional Part of the Time of Message Reception for Position in the Ground Station" TRuleVariation620 +type TItem1095 = 'GItem TNonSpare2052 +type TVariation1162 = 'GGroup 0 '[ TItem370, TItem1095] +type TRuleVariation1115 = 'GContextFree TVariation1162 +type TNonSpare237 = 'GNonSpare "074" "Time of Message Reception of Position-High Precision" TRuleVariation1115 +type TUapItem237 = 'GUapItem TNonSpare237 +type TNonSpare238 = 'GNonSpare "075" "Time of Message Reception for Velocity" TRuleVariation376 +type TUapItem238 = 'GUapItem TNonSpare238 +type TContent634 = 'GContentTable '[ '(3, "Reserved"), '(2, "TOMRp whole seconds = (I021/075) Whole seconds - 1"), '(1, "TOMRp whole seconds = (I021/075) Whole seconds + 1"), '(0, "TOMRp whole seconds = (I021/075) Whole seconds")] +type TRuleContent632 = 'GContextFree TContent634 +type TVariation126 = 'GElement 0 2 TRuleContent632 +type TRuleVariation126 = 'GContextFree TVariation126 +type TNonSpare1076 = 'GNonSpare "FSI" "Full Second Indication" TRuleVariation126 +type TItem371 = 'GItem TNonSpare1076 +type TVariation1163 = 'GGroup 0 '[ TItem371, TItem1095] +type TRuleVariation1116 = 'GContextFree TVariation1163 +type TNonSpare240 = 'GNonSpare "076" "Time of Message Reception of Velocity-High Precision" TRuleVariation1116 +type TUapItem240 = 'GUapItem TNonSpare240 +type TNonSpare346 = 'GNonSpare "140" "Geometric Height" TRuleVariation297 +type TUapItem346 = 'GUapItem TNonSpare346 +type TVariation127 = 'GElement 0 3 TRuleContent0 +type TRuleVariation127 = 'GContextFree TVariation127 +type TNonSpare1503 = 'GNonSpare "NUCRNACV" "Navigation Uncertainty Category for Velocity NUCr or the Navigation Accuracy Category for Velocity NACv" TRuleVariation127 +type TItem698 = 'GItem TNonSpare1503 +type TVariation716 = 'GElement 3 4 TRuleContent0 +type TRuleVariation704 = 'GContextFree TVariation716 +type TNonSpare1502 = 'GNonSpare "NUCPNIC" "Navigation Uncertainty Category for Position NUCp or Navigation Integrity Category NIC" TRuleVariation704 +type TItem697 = 'GItem TNonSpare1502 +type TNonSpare1476 = 'GNonSpare "NICBARO" "Navigation Integrity Category for Barometric Altitude" TRuleVariation0 +type TItem672 = 'GItem TNonSpare1476 +type TVariation481 = 'GElement 1 2 TRuleContent0 +type TRuleVariation469 = 'GContextFree TVariation481 +type TNonSpare1865 = 'GNonSpare "SIL" "Surveillance (version 1) or Source (version 2) Integrity Level" TRuleVariation469 +type TItem963 = 'GItem TNonSpare1865 +type TNonSpare1457 = 'GNonSpare "NACP" "Navigation Accuracy Category for Position" TRuleVariation704 +type TItem655 = 'GItem TNonSpare1457 +type TContent276 = 'GContentTable '[ '(0, "Measured per flight-hour"), '(1, "Measured per sample")] +type TRuleContent274 = 'GContextFree TContent276 +type TVariation559 = 'GElement 2 1 TRuleContent274 +type TRuleVariation547 = 'GContextFree TVariation559 +type TNonSpare1866 = 'GNonSpare "SILS" "SIL-Supplement" TRuleVariation547 +type TItem964 = 'GItem TNonSpare1866 +type TVariation698 = 'GElement 3 2 TRuleContent0 +type TRuleVariation686 = 'GContextFree TVariation698 +type TNonSpare1814 = 'GNonSpare "SDA" "Horizontal Position System Design Assurance Level (as Defined in Version 2)" TRuleVariation686 +type TItem931 = 'GItem TNonSpare1814 +type TVariation907 = 'GElement 5 2 TRuleContent0 +type TRuleVariation876 = 'GContextFree TVariation907 +type TNonSpare1126 = 'GNonSpare "GVA" "Geometric Altitude Accuracy" TRuleVariation876 +type TItem402 = 'GItem TNonSpare1126 +type TNonSpare1546 = 'GNonSpare "PIC" "Position Integrity Category" TRuleVariation140 +type TItem735 = 'GItem TNonSpare1546 +type TVariation1449 = 'GExtended '[ 'Just TItem698, 'Just TItem697, 'Nothing, 'Just TItem672, 'Just TItem963, 'Just TItem655, 'Nothing, 'Just TItem1, 'Just TItem964, 'Just TItem931, 'Just TItem402, 'Nothing, 'Just TItem735, 'Just TItem21, 'Nothing] +type TRuleVariation1365 = 'GContextFree TVariation1449 +type TNonSpare269 = 'GNonSpare "090" "Quality Indicators" TRuleVariation1365 +type TUapItem269 = 'GUapItem TNonSpare269 +type TContent514 = 'GContentTable '[ '(0, "The MOPS Version is supported by the GS"), '(1, "The MOPS Version is not supported by the GS")] +type TRuleContent512 = 'GContextFree TContent514 +type TVariation471 = 'GElement 1 1 TRuleContent512 +type TRuleVariation459 = 'GContextFree TVariation471 +type TNonSpare2225 = 'GNonSpare "VNS" "Version Not Supported" TRuleVariation459 +type TItem1249 = 'GItem TNonSpare2225 +type TContent208 = 'GContentTable '[ '(0, "ED102/DO-260 [Ref. 8]"), '(1, "DO-260A [Ref. 9]"), '(2, "ED102A/DO-260B [Ref. 11]")] +type TRuleContent208 = 'GContextFree TContent208 +type TVariation617 = 'GElement 2 3 TRuleContent208 +type TRuleVariation605 = 'GContextFree TVariation617 +type TNonSpare2223 = 'GNonSpare "VN" "Version Number" TRuleVariation605 +type TItem1247 = 'GItem TNonSpare2223 +type TContent437 = 'GContentTable '[ '(0, "Other"), '(1, "UAT"), '(2, "1090 ES"), '(3, "VDL 4"), '(4, "Not assigned"), '(5, "Not assigned"), '(6, "Not assigned"), '(7, "Not assigned")] +type TRuleContent435 = 'GContextFree TContent437 +type TVariation922 = 'GElement 5 3 TRuleContent435 +type TRuleVariation891 = 'GContextFree TVariation922 +type TNonSpare1285 = 'GNonSpare "LTT" "Link Technology Type" TRuleVariation891 +type TItem537 = 'GItem TNonSpare1285 +type TVariation1039 = 'GGroup 0 '[ TItem0, TItem1249, TItem1247, TItem537] +type TRuleVariation1008 = 'GContextFree TVariation1039 +type TNonSpare440 = 'GNonSpare "210" "MOPS Version" TRuleVariation1008 +type TUapItem440 = 'GUapItem TNonSpare440 +type TVariation1069 = 'GGroup 0 '[ TItem3, TItem622] +type TRuleVariation1037 = 'GContextFree TVariation1069 +type TNonSpare218 = 'GNonSpare "070" "Mode 3/A Code in Octal Representation" TRuleVariation1037 +type TUapItem218 = 'GUapItem TNonSpare218 +type TNonSpare463 = 'GNonSpare "230" "Roll Angle" TRuleVariation275 +type TUapItem463 = 'GUapItem TNonSpare463 +type TNonSpare374 = 'GNonSpare "152" "Magnetic Heading" TRuleVariation349 +type TUapItem374 = 'GUapItem TNonSpare374 +type TContent383 = 'GContentTable '[ '(0, "No intent change active"), '(1, "Intent change flag raised")] +type TRuleContent381 = 'GContextFree TContent383 +type TVariation64 = 'GElement 0 1 TRuleContent381 +type TRuleVariation64 = 'GContextFree TVariation64 +type TNonSpare1185 = 'GNonSpare "ICF" "Intent Change Flag (see Note)" TRuleVariation64 +type TItem447 = 'GItem TNonSpare1185 +type TContent261 = 'GContentTable '[ '(0, "LNAV Mode engaged"), '(1, "LNAV Mode not engaged")] +type TRuleContent259 = 'GContextFree TContent261 +type TVariation448 = 'GElement 1 1 TRuleContent259 +type TRuleVariation436 = 'GContextFree TVariation448 +type TNonSpare1254 = 'GNonSpare "LNAV" "LNAV Mode" TRuleVariation436 +type TItem508 = 'GItem TNonSpare1254 +type TItem11 = 'GSpare 2 1 +type TContent373 = 'GContentTable '[ '(0, "No emergency / not reported"), '(1, "General emergency"), '(2, "Lifeguard / medical emergency"), '(3, "Minimum fuel"), '(4, "No communications"), '(5, "Unlawful interference"), '(6, "DOWNED Aircraft")] +type TRuleContent371 = 'GContextFree TContent373 +type TVariation713 = 'GElement 3 3 TRuleContent371 +type TRuleVariation701 = 'GContextFree TVariation713 +type TNonSpare1594 = 'GNonSpare "PS" "Priority Status" TRuleVariation701 +type TItem767 = 'GItem TNonSpare1594 +type TContent358 = 'GContentTable '[ '(0, "No condition reported"), '(1, "Permanent Alert (Emergency condition)"), '(2, "Temporary Alert (change in Mode 3/A Code other than emergency)"), '(3, "SPI set")] +type TRuleContent356 = 'GContextFree TContent358 +type TVariation995 = 'GElement 6 2 TRuleContent356 +type TRuleVariation964 = 'GContextFree TVariation995 +type TNonSpare1916 = 'GNonSpare "SS" "Surveillance Status" TRuleVariation964 +type TItem1005 = 'GItem TNonSpare1916 +type TVariation1174 = 'GGroup 0 '[ TItem447, TItem508, TItem11, TItem767, TItem1005] +type TRuleVariation1126 = 'GContextFree TVariation1174 +type TNonSpare425 = 'GNonSpare "200" "Target Status" TRuleVariation1126 +type TUapItem425 = 'GUapItem TNonSpare425 +type TVariation518 = 'GElement 1 15 TRuleContent714 +type TRuleVariation506 = 'GContextFree TVariation518 +type TNonSpare754 = 'GNonSpare "BVR" "Barometric Vertical Rate" TRuleVariation506 +type TItem138 = 'GItem TNonSpare754 +type TVariation1232 = 'GGroup 0 '[ TItem853, TItem138] +type TRuleVariation1178 = 'GContextFree TVariation1232 +type TNonSpare376 = 'GNonSpare "155" "Barometric Vertical Rate" TRuleVariation1178 +type TUapItem376 = 'GUapItem TNonSpare376 +type TNonSpare1128 = 'GNonSpare "GVR" "Geometric Vertical Rate" TRuleVariation506 +type TItem403 = 'GItem TNonSpare1128 +type TVariation1234 = 'GGroup 0 '[ TItem853, TItem403] +type TRuleVariation1180 = 'GContextFree TVariation1234 +type TNonSpare378 = 'GNonSpare "157" "Geometric Vertical Rate" TRuleVariation1180 +type TUapItem378 = 'GUapItem TNonSpare378 +type TContent809 = 'GContentQuantity 'GUnsigned ('GNumDiv ('GNumInt ('GZ 'GPlus 1)) ('GNumPow ('GZ 'GPlus 2) ('GZ 'GPlus 14))) "NM/s" +type TRuleContent806 = 'GContextFree TContent809 +type TVariation521 = 'GElement 1 15 TRuleContent806 +type TRuleVariation509 = 'GContextFree TVariation521 +type TNonSpare1117 = 'GNonSpare "GS" "Ground Speed Referenced to WGS-84" TRuleVariation509 +type TItem395 = 'GItem TNonSpare1117 +type TNonSpare1982 = 'GNonSpare "TA" "Track Angle Clockwise Reference to True North" TRuleVariation349 +type TItem1052 = 'GItem TNonSpare1982 +type TVariation1233 = 'GGroup 0 '[ TItem853, TItem395, TItem1052] +type TRuleVariation1179 = 'GContextFree TVariation1233 +type TNonSpare379 = 'GNonSpare "160" "Airborne Ground Vector" TRuleVariation1179 +type TUapItem379 = 'GUapItem TNonSpare379 +type TContent700 = 'GContentQuantity 'GSigned ('GNumDiv ('GNumInt ('GZ 'GPlus 1)) ('GNumPow ('GZ 'GPlus 2) ('GZ 'GPlus 5))) "°/s" +type TRuleContent698 = 'GContextFree TContent700 +type TVariation1003 = 'GElement 6 10 TRuleContent698 +type TRuleVariation972 = 'GContextFree TVariation1003 +type TNonSpare1989 = 'GNonSpare "TAR" "Track Angle Rate" TRuleVariation972 +type TItem1055 = 'GItem TNonSpare1989 +type TVariation1084 = 'GGroup 0 '[ TItem5, TItem1055] +type TRuleVariation1051 = 'GContextFree TVariation1084 +type TNonSpare392 = 'GNonSpare "165" "Track Angle Rate" TRuleVariation1051 +type TUapItem392 = 'GUapItem TNonSpare392 +type TNonSpare242 = 'GNonSpare "077" "Time of ASTERIX Report Transmission" TRuleVariation376 +type TUapItem242 = 'GUapItem TNonSpare242 +type TContent317 = 'GContentTable '[ '(0, "No ADS-B Emitter Category Information"), '(1, "Light aircraft <= 15500 lbs"), '(2, "15500 lbs < small aircraft <75000 lbs"), '(3, "75000 lbs < medium a/c < 300000 lbs"), '(4, "High Vortex Large"), '(5, "300000 lbs <= heavy aircraft"), '(6, "Highly manoeuvrable (5g acceleration capability) and high speed (>400 knots cruise)"), '(7, "Reserved"), '(8, "Reserved"), '(9, "Reserved"), '(10, "Rotocraft"), '(11, "Glider / sailplane"), '(12, "Lighter-than-air"), '(13, "Unmanned aerial vehicle"), '(14, "Space / transatmospheric vehicle"), '(15, "Ultralight / handglider / paraglider"), '(16, "Parachutist / skydiver"), '(17, "Reserved"), '(18, "Reserved"), '(19, "Reserved"), '(20, "Surface emergency vehicle"), '(21, "Surface service vehicle"), '(22, "Fixed ground or tethered obstruction"), '(23, "Cluster obstacle"), '(24, "Line obstacle")] +type TRuleContent315 = 'GContextFree TContent317 +type TVariation184 = 'GElement 0 8 TRuleContent315 +type TRuleVariation177 = 'GContextFree TVariation184 +type TNonSpare79 = 'GNonSpare "020" "Emitter Category" TRuleVariation177 +type TUapItem79 = 'GUapItem TNonSpare79 +type TNonSpare1788 = 'GNonSpare "S" "Source" TRuleVariation481 +type TItem915 = 'GItem TNonSpare1788 +type TVariation1261 = 'GGroup 0 '[ TItem925, TItem915, TItem63] +type TRuleVariation1200 = 'GContextFree TVariation1261 +type TNonSpare363 = 'GNonSpare "146" "Selected Altitude" TRuleVariation1200 +type TUapItem363 = 'GUapItem TNonSpare363 +type TContent410 = 'GContentTable '[ '(0, "Not active or unknown"), '(1, "Active")] +type TRuleContent408 = 'GContextFree TContent410 +type TVariation71 = 'GElement 0 1 TRuleContent408 +type TRuleVariation71 = 'GContextFree TVariation71 +type TNonSpare1453 = 'GNonSpare "MV" "Manage Vertical Mode" TRuleVariation71 +type TItem653 = 'GItem TNonSpare1453 +type TVariation459 = 'GElement 1 1 TRuleContent408 +type TRuleVariation447 = 'GContextFree TVariation459 +type TNonSpare636 = 'GNonSpare "AH" "Altitude Hold Mode" TRuleVariation447 +type TItem57 = 'GItem TNonSpare636 +type TVariation586 = 'GElement 2 1 TRuleContent408 +type TRuleVariation574 = 'GContextFree TVariation586 +type TNonSpare657 = 'GNonSpare "AM" "Approach Mode" TRuleVariation574 +type TItem72 = 'GItem TNonSpare657 +type TVariation1207 = 'GGroup 0 '[ TItem653, TItem57, TItem72, TItem63] +type TRuleVariation1155 = 'GContextFree TVariation1207 +type TNonSpare365 = 'GNonSpare "148" "Final State Selected Altitude" TRuleVariation1155 +type TUapItem365 = 'GUapItem TNonSpare365 +type TContent764 = 'GContentQuantity 'GUnsigned ('GNumDiv ('GNumInt ('GZ 'GPlus 1)) ('GNumInt ('GZ 'GPlus 2))) "s" +type TRuleContent762 = 'GContextFree TContent764 +type TVariation241 = 'GElement 0 8 TRuleContent762 +type TRuleVariation233 = 'GContextFree TVariation241 +type TNonSpare72 = 'GNonSpare "016" "Service Management" TRuleVariation233 +type TUapItem72 = 'GUapItem TNonSpare72 +type TContent486 = 'GContentTable '[ '(0, "TCAS II or ACAS RA not active"), '(1, "TCAS RA active")] +type TRuleContent484 = 'GContextFree TContent486 +type TVariation82 = 'GElement 0 1 TRuleContent484 +type TRuleVariation82 = 'GContextFree TVariation82 +type TNonSpare1661 = 'GNonSpare "RA" "TCAS Resolution Advisory Active" TRuleVariation82 +type TItem821 = 'GItem TNonSpare1661 +type TContent345 = 'GContentTable '[ '(0, "No capability for Trajectory Change Reports"), '(1, "Support for TC+0 reports only"), '(2, "Support for multiple TC reports"), '(3, "Reserved")] +type TRuleContent343 = 'GContextFree TContent345 +type TVariation487 = 'GElement 1 2 TRuleContent343 +type TRuleVariation475 = 'GContextFree TVariation487 +type TNonSpare1998 = 'GNonSpare "TC" "Target Trajectory Change Report Capability" TRuleVariation475 +type TItem1058 = 'GItem TNonSpare1998 +type TContent347 = 'GContentTable '[ '(0, "No capability to support Target State Reports"), '(1, "Capable of supporting target State Reports")] +type TRuleContent345 = 'GContextFree TContent347 +type TVariation671 = 'GElement 3 1 TRuleContent345 +type TRuleVariation659 = 'GContextFree TVariation671 +type TNonSpare2094 = 'GNonSpare "TS" "Target State Report Capability" TRuleVariation659 +type TItem1128 = 'GItem TNonSpare2094 +type TContent346 = 'GContentTable '[ '(0, "No capability to generate ARV-reports"), '(1, "Capable of generate ARV-reports")] +type TRuleContent344 = 'GContextFree TContent346 +type TVariation763 = 'GElement 4 1 TRuleContent344 +type TRuleVariation751 = 'GContextFree TVariation763 +type TNonSpare685 = 'GNonSpare "ARV" "Air-Referenced Velocity Report Capability" TRuleVariation751 +type TItem88 = 'GItem TNonSpare685 +type TContent52 = 'GContentTable '[ '(0, "CDTI not operational"), '(1, "CDTI operational")] +type TRuleContent52 = 'GContextFree TContent52 +type TVariation854 = 'GElement 5 1 TRuleContent52 +type TRuleVariation823 = 'GContextFree TVariation854 +type TNonSpare781 = 'GNonSpare "CDTIA" "Cockpit Display of Traffic Information Airborne" TRuleVariation823 +type TItem155 = 'GItem TNonSpare781 +type TContent487 = 'GContentTable '[ '(0, "TCAS operational"), '(1, "TCAS not operational")] +type TRuleContent485 = 'GContextFree TContent487 +type TVariation984 = 'GElement 6 1 TRuleContent485 +type TRuleVariation953 = 'GContextFree TVariation984 +type TNonSpare1494 = 'GNonSpare "NOTTCAS" "TCAS System Status" TRuleVariation953 +type TItem690 = 'GItem TNonSpare1494 +type TContent38 = 'GContentTable '[ '(0, "Antenna Diversity"), '(1, "Single Antenna only")] +type TRuleContent38 = 'GContextFree TContent38 +type TVariation1007 = 'GElement 7 1 TRuleContent38 +type TRuleVariation976 = 'GContextFree TVariation1007 +type TNonSpare1789 = 'GNonSpare "SA" "Single Antenna" TRuleVariation976 +type TItem916 = 'GItem TNonSpare1789 +type TVariation1229 = 'GGroup 0 '[ TItem821, TItem1058, TItem1128, TItem88, TItem155, TItem690, TItem916] +type TRuleVariation1175 = 'GContextFree TVariation1229 +type TNonSpare27 = 'GNonSpare "008" "Aircraft Operational Status" TRuleVariation1175 +type TUapItem27 = 'GUapItem TNonSpare27 +type TContent453 = 'GContentTable '[ '(0, "Position transmitted is not ADS-B position reference point"), '(1, "Position transmitted is the ADS-B position reference point")] +type TRuleContent451 = 'GContextFree TContent453 +type TVariation591 = 'GElement 2 1 TRuleContent451 +type TRuleVariation579 = 'GContextFree TVariation591 +type TNonSpare1560 = 'GNonSpare "POA" "Position Offset Applied" TRuleVariation579 +type TItem743 = 'GItem TNonSpare1560 +type TVariation640 = 'GElement 3 1 TRuleContent52 +type TRuleVariation628 = 'GContextFree TVariation640 +type TNonSpare782 = 'GNonSpare "CDTIS" "Cockpit Display of Traffic Information Surface" TRuleVariation628 +type TItem156 = 'GItem TNonSpare782 +type TContent8 = 'GContentTable '[ '(0, ">= 70 Watts"), '(1, "< 70 Watts")] +type TRuleContent8 = 'GContextFree TContent8 +type TVariation725 = 'GElement 4 1 TRuleContent8 +type TRuleVariation713 = 'GContextFree TVariation725 +type TNonSpare726 = 'GNonSpare "B2LOW" "Class B2 Transmit Power Less Than 70 Watts" TRuleVariation713 +type TItem116 = 'GItem TNonSpare726 +type TContent34 = 'GContentTable '[ '(0, "Aircraft not receiving ATC-services"), '(1, "Aircraft receiving ATC services")] +type TRuleContent34 = 'GContextFree TContent34 +type TVariation851 = 'GElement 5 1 TRuleContent34 +type TRuleVariation820 = 'GContextFree TVariation851 +type TNonSpare1677 = 'GNonSpare "RAS" "Receiving ATC Services" TRuleVariation820 +type TItem835 = 'GItem TNonSpare1677 +type TContent243 = 'GContentTable '[ '(0, "IDENT switch not active"), '(1, "IDENT switch active")] +type TRuleContent243 = 'GContextFree TContent243 +type TVariation964 = 'GElement 6 1 TRuleContent243 +type TRuleVariation933 = 'GContextFree TVariation964 +type TNonSpare1192 = 'GNonSpare "IDENT" "Setting of IDENT Switch" TRuleVariation933 +type TItem453 = 'GItem TNonSpare1192 +type TNonSpare1288 = 'GNonSpare "LW" "Length and Width of the Aircraft" TRuleVariation796 +type TItem540 = 'GItem TNonSpare1288 +type TVariation1412 = 'GExtended '[ 'Just TItem1, 'Just TItem743, 'Just TItem156, 'Just TItem116, 'Just TItem835, 'Just TItem453, 'Nothing, 'Just TItem3, 'Just TItem540] +type TRuleVariation1328 = 'GContextFree TVariation1412 +type TNonSpare501 = 'GNonSpare "271" "Surface Capabilities and Characteristics" TRuleVariation1328 +type TUapItem501 = 'GUapItem TNonSpare501 +type TNonSpare338 = 'GNonSpare "132" "Message Amplitude" TRuleVariation214 +type TUapItem338 = 'GUapItem TNonSpare338 +type TNonSpare480 = 'GNonSpare "250" "Mode S MB Data" TRuleVariation1395 +type TUapItem480 = 'GUapItem TNonSpare480 +type TVariation150 = 'GElement 0 5 TRuleContent0 +type TRuleVariation150 = 'GContextFree TVariation150 +type TNonSpare2139 = 'GNonSpare "TYP" "Message Type (= 28 for 1090 ES, Version 2)" TRuleVariation150 +type TItem1168 = 'GItem TNonSpare2139 +type TNonSpare1965 = 'GNonSpare "STYP" "Message Sub-type (= 2 for 1090 ES, Version 2)" TRuleVariation888 +type TItem1040 = 'GItem TNonSpare1965 +type TVariation264 = 'GElement 0 14 TRuleContent0 +type TRuleVariation256 = 'GContextFree TVariation264 +type TNonSpare678 = 'GNonSpare "ARA" "Active Resolution Advisories" TRuleVariation256 +type TItem83 = 'GItem TNonSpare678 +type TVariation1000 = 'GElement 6 4 TRuleContent0 +type TRuleVariation969 = 'GContextFree TVariation1000 +type TNonSpare1669 = 'GNonSpare "RAC" "RAC (RA Complement) Record" TRuleVariation969 +type TItem829 = 'GItem TNonSpare1669 +type TNonSpare1678 = 'GNonSpare "RAT" "RA Terminated" TRuleVariation512 +type TItem836 = 'GItem TNonSpare1678 +type TNonSpare1447 = 'GNonSpare "MTE" "Multiple Threat Encounter" TRuleVariation622 +type TItem648 = 'GItem TNonSpare1447 +type TVariation790 = 'GElement 4 2 TRuleContent0 +type TRuleVariation778 = 'GContextFree TVariation790 +type TNonSpare2122 = 'GNonSpare "TTI" "Threat Type Indicator" TRuleVariation778 +type TItem1153 = 'GItem TNonSpare2122 +type TVariation1005 = 'GElement 6 26 TRuleContent0 +type TRuleVariation974 = 'GContextFree TVariation1005 +type TNonSpare2030 = 'GNonSpare "TID" "Threat Identity Data" TRuleVariation974 +type TItem1084 = 'GItem TNonSpare2030 +type TVariation1301 = 'GGroup 0 '[ TItem1168, TItem1040, TItem83, TItem829, TItem836, TItem648, TItem1153, TItem1084] +type TRuleVariation1232 = 'GContextFree TVariation1301 +type TNonSpare495 = 'GNonSpare "260" "ACAS Resolution Advisory Report" TRuleVariation1232 +type TUapItem495 = 'GUapItem TNonSpare495 +type TNonSpare543 = 'GNonSpare "400" "Receiver ID" TRuleVariation171 +type TUapItem541 = 'GUapItem TNonSpare543 +type TContent771 = 'GContentQuantity 'GUnsigned ('GNumDiv ('GNumInt ('GZ 'GPlus 1)) ('GNumInt ('GZ 'GPlus 10))) "s" +type TRuleContent769 = 'GContextFree TContent771 +type TVariation243 = 'GElement 0 8 TRuleContent769 +type TRuleVariation235 = 'GContextFree TVariation243 +type TNonSpare665 = 'GNonSpare "AOS" "Aircraft Operational Status Age" TRuleVariation235 +type TNonSpare2082 = 'GNonSpare "TRD" "Target Report Descriptor Age" TRuleVariation235 +type TNonSpare1304 = 'GNonSpare "M3A" "Mode 3/A Age" TRuleVariation235 +type TNonSpare1653 = 'GNonSpare "QI" "Quality Indicators Age" TRuleVariation235 +type TNonSpare2026 = 'GNonSpare "TI1" "Trajectory Intent Age" TRuleVariation235 +type TNonSpare1327 = 'GNonSpare "MAM" "Message Amplitude Age" TRuleVariation235 +type TNonSpare1112 = 'GNonSpare "GH" "Geometric Height Age" TRuleVariation235 +type TNonSpare1050 = 'GNonSpare "FL" "Flight Level Age" TRuleVariation235 +type TNonSpare1207 = 'GNonSpare "ISA" "Intermediate State Selected Altitude Age" TRuleVariation235 +type TNonSpare1074 = 'GNonSpare "FSA" "Final State Selected Altitude Age" TRuleVariation235 +type TNonSpare687 = 'GNonSpare "AS" "Air Speed Age" TRuleVariation235 +type TNonSpare1994 = 'GNonSpare "TAS" "True Air Speed Age" TRuleVariation235 +type TNonSpare1386 = 'GNonSpare "MH" "Magnetic Heading Age" TRuleVariation235 +type TNonSpare755 = 'GNonSpare "BVR" "Barometric Vertical Rate Age" TRuleVariation235 +type TNonSpare1129 = 'GNonSpare "GVR" "Geometric Vertical Rate Age" TRuleVariation235 +type TNonSpare1125 = 'GNonSpare "GV" "Ground Vector Age" TRuleVariation235 +type TNonSpare1991 = 'GNonSpare "TAR" "Track Angle Rate Age" TRuleVariation235 +type TNonSpare2027 = 'GNonSpare "TI2" "Target Identification Age" TRuleVariation235 +type TNonSpare2095 = 'GNonSpare "TS" "Target Status Age" TRuleVariation235 +type TNonSpare1378 = 'GNonSpare "MET" "Met Information Age" TRuleVariation235 +type TNonSpare1737 = 'GNonSpare "ROA" "Roll Angle Age" TRuleVariation235 +type TNonSpare677 = 'GNonSpare "ARA" "ACAS Resolution Advisory Age" TRuleVariation235 +type TNonSpare1808 = 'GNonSpare "SCC" "Surface Capabilities and Characteristics Age" TRuleVariation235 +type TVariation1556 = 'GCompound '[ 'Just TNonSpare665, 'Just TNonSpare2082, 'Just TNonSpare1304, 'Just TNonSpare1653, 'Just TNonSpare2026, 'Just TNonSpare1327, 'Just TNonSpare1112, 'Just TNonSpare1050, 'Just TNonSpare1207, 'Just TNonSpare1074, 'Just TNonSpare687, 'Just TNonSpare1994, 'Just TNonSpare1386, 'Just TNonSpare755, 'Just TNonSpare1129, 'Just TNonSpare1125, 'Just TNonSpare1991, 'Just TNonSpare2027, 'Just TNonSpare2095, 'Just TNonSpare1378, 'Just TNonSpare1737, 'Just TNonSpare677, 'Just TNonSpare1808] +type TRuleVariation1472 = 'GContextFree TVariation1556 +type TNonSpare510 = 'GNonSpare "295" "Data Ages" TRuleVariation1472 +type TUapItem510 = 'GUapItem TNonSpare510 +type TRecord8 = 'GRecord '[ TUapItem29, TUapItem154, TUapItem388, TUapItem64, TUapItem233, TUapItem329, TUapItem335, TUapItem234, TUapItem366, TUapItem372, TUapItem248, TUapItem235, TUapItem237, TUapItem238, TUapItem240, TUapItem346, TUapItem269, TUapItem440, TUapItem218, TUapItem463, TUapItem360, TUapItem374, TUapItem425, TUapItem376, TUapItem378, TUapItem379, TUapItem392, TUapItem242, TUapItem396, TUapItem79, TUapItem452, TUapItem363, TUapItem365, TUapItem310, TUapItem72, TUapItem27, TUapItem501, TUapItem338, TUapItem480, TUapItem495, TUapItem541, TUapItem510, TUapItem598, TUapItem598, TUapItem598, TUapItem598, TUapItem598, TUapItem594, TUapItem596] +type TUap8 = 'GUap TRecord8 +type TAsterix32 = 'GAsterixBasic 21 ('GEdition 2 1) TUap8 +type TNonSpare270 = 'GNonSpare "090" "Quality Indicators" TRuleVariation1365 +type TUapItem270 = 'GUapItem TNonSpare270 +type TVariation581 = 'GElement 2 1 TRuleContent383 +type TRuleVariation569 = 'GContextFree TVariation581 +type TNonSpare1376 = 'GNonSpare "ME" "Military Emergency" TRuleVariation569 +type TItem594 = 'GItem TNonSpare1376 +type TVariation1175 = 'GGroup 0 '[ TItem447, TItem508, TItem594, TItem767, TItem1005] +type TRuleVariation1127 = 'GContextFree TVariation1175 +type TNonSpare426 = 'GNonSpare "200" "Target Status" TRuleVariation1127 +type TUapItem426 = 'GUapItem TNonSpare426 +type TNonSpare1287 = 'GNonSpare "LW" "Length and Width of the Aircraft" TRuleVariation140 +type TItem539 = 'GItem TNonSpare1287 +type TVariation1413 = 'GExtended '[ 'Just TItem1, 'Just TItem743, 'Just TItem156, 'Just TItem116, 'Just TItem835, 'Just TItem453, 'Nothing, 'Just TItem539, 'Just TItem21, 'Nothing] +type TRuleVariation1329 = 'GContextFree TVariation1413 +type TNonSpare502 = 'GNonSpare "271" "Surface Capabilities and Characteristics" TRuleVariation1329 +type TUapItem502 = 'GUapItem TNonSpare502 +type TNonSpare492 = 'GNonSpare "260" "ACAS Resolution Advisory Report" TRuleVariation1232 +type TUapItem492 = 'GUapItem TNonSpare492 +type TRecord9 = 'GRecord '[ TUapItem29, TUapItem154, TUapItem388, TUapItem64, TUapItem233, TUapItem329, TUapItem335, TUapItem234, TUapItem366, TUapItem372, TUapItem248, TUapItem235, TUapItem237, TUapItem238, TUapItem240, TUapItem346, TUapItem270, TUapItem440, TUapItem218, TUapItem463, TUapItem360, TUapItem374, TUapItem426, TUapItem376, TUapItem378, TUapItem379, TUapItem392, TUapItem242, TUapItem396, TUapItem79, TUapItem452, TUapItem363, TUapItem365, TUapItem310, TUapItem72, TUapItem27, TUapItem502, TUapItem338, TUapItem480, TUapItem492, TUapItem541, TUapItem510, TUapItem598, TUapItem598, TUapItem598, TUapItem598, TUapItem598, TUapItem594, TUapItem596] +type TUap9 = 'GUap TRecord9 +type TAsterix33 = 'GAsterixBasic 21 ('GEdition 2 2) TUap9 +type TContent118 = 'GContentTable '[ '(0, "Default"), '(1, "List Lookup failed (see note)")] +type TRuleContent118 = 'GContextFree TContent118 +type TVariation426 = 'GElement 1 1 TRuleContent118 +type TRuleVariation414 = 'GContextFree TVariation426 +type TNonSpare1252 = 'GNonSpare "LLC" "List Lookup Check" TRuleVariation414 +type TItem506 = 'GItem TNonSpare1252 +type TVariation1416 = 'GExtended '[ 'Just TItem93, 'Just TItem85, 'Just TItem837, 'Just TItem828, 'Nothing, 'Just TItem271, 'Just TItem391, 'Just TItem971, 'Just TItem1143, 'Just TItem917, 'Just TItem174, 'Nothing, 'Just TItem0, 'Just TItem506, 'Just TItem459, 'Just TItem679, 'Just TItem227, 'Just TItem502, 'Just TItem841, 'Nothing] +type TRuleVariation1332 = 'GContextFree TVariation1416 +type TNonSpare152 = 'GNonSpare "040" "Target Report Descriptor" TRuleVariation1332 +type TUapItem152 = 'GUapItem TNonSpare152 +type TRecord5 = 'GRecord '[ TUapItem29, TUapItem152, TUapItem388, TUapItem64, TUapItem233, TUapItem329, TUapItem335, TUapItem234, TUapItem366, TUapItem372, TUapItem248, TUapItem235, TUapItem237, TUapItem238, TUapItem240, TUapItem346, TUapItem270, TUapItem440, TUapItem218, TUapItem463, TUapItem360, TUapItem374, TUapItem426, TUapItem376, TUapItem378, TUapItem379, TUapItem392, TUapItem242, TUapItem396, TUapItem79, TUapItem452, TUapItem363, TUapItem365, TUapItem310, TUapItem72, TUapItem27, TUapItem502, TUapItem338, TUapItem480, TUapItem492, TUapItem541, TUapItem510, TUapItem598, TUapItem598, TUapItem598, TUapItem598, TUapItem598, TUapItem594, TUapItem596] +type TUap5 = 'GUap TRecord5 +type TAsterix34 = 'GAsterixBasic 21 ('GEdition 2 3) TUap5 +type TAsterix35 = 'GAsterixBasic 21 ('GEdition 2 4) TUap5 +type TNonSpare151 = 'GNonSpare "040" "Target Report Descriptor" TRuleVariation1332 +type TUapItem151 = 'GUapItem TNonSpare151 +type TNonSpare249 = 'GNonSpare "080" "Target Address" TRuleVariation355 +type TUapItem249 = 'GUapItem TNonSpare249 +type TContent207 = 'GContentTable '[ '(0, "ED102/DO-260 [Ref. 7]"), '(1, "DO-260A [Ref. 8]"), '(2, "ED102A/DO-260B [Ref. 10]"), '(3, "ED-102B/DO-260C [Ref. 11]")] +type TRuleContent207 = 'GContextFree TContent207 +type TVariation616 = 'GElement 2 3 TRuleContent207 +type TRuleVariation604 = 'GContextFree TVariation616 +type TNonSpare2222 = 'GNonSpare "VN" "Version Number" TRuleVariation604 +type TItem1246 = 'GItem TNonSpare2222 +type TVariation1038 = 'GGroup 0 '[ TItem0, TItem1249, TItem1246, TItem537] +type TRuleVariation1007 = 'GContextFree TVariation1038 +type TNonSpare439 = 'GNonSpare "210" "MOPS Version" TRuleVariation1007 +type TUapItem439 = 'GUapItem TNonSpare439 +type TNonSpare427 = 'GNonSpare "200" "Target Status" TRuleVariation1127 +type TUapItem427 = 'GUapItem TNonSpare427 +type TNonSpare493 = 'GNonSpare "260" "ACAS Resolution Advisory Report" TRuleVariation1232 +type TUapItem493 = 'GUapItem TNonSpare493 +type TRecord4 = 'GRecord '[ TUapItem29, TUapItem151, TUapItem388, TUapItem64, TUapItem233, TUapItem329, TUapItem335, TUapItem234, TUapItem366, TUapItem372, TUapItem249, TUapItem235, TUapItem237, TUapItem238, TUapItem240, TUapItem346, TUapItem270, TUapItem439, TUapItem218, TUapItem463, TUapItem360, TUapItem374, TUapItem427, TUapItem376, TUapItem378, TUapItem379, TUapItem392, TUapItem242, TUapItem396, TUapItem79, TUapItem452, TUapItem363, TUapItem365, TUapItem310, TUapItem72, TUapItem27, TUapItem502, TUapItem338, TUapItem480, TUapItem493, TUapItem541, TUapItem510, TUapItem598, TUapItem598, TUapItem598, TUapItem598, TUapItem598, TUapItem594, TUapItem596] +type TUap4 = 'GUap TRecord4 +type TAsterix36 = 'GAsterixBasic 21 ('GEdition 2 5) TUap4 +type TVariation510 = 'GElement 1 6 TRuleContent638 +type TRuleVariation498 = 'GContextFree TVariation510 +type TNonSpare2196 = 'GNonSpare "VAL" "Value" TRuleVariation498 +type TItem1221 = 'GItem TNonSpare2196 +type TVariation1154 = 'GGroup 0 '[ TItem320, TItem1221] +type TRuleVariation1107 = 'GContextFree TVariation1154 +type TNonSpare1997 = 'GNonSpare "TBC" "Total Bits Corrected" TRuleVariation1107 +type TItem1057 = 'GItem TNonSpare1997 +type TNonSpare2195 = 'GNonSpare "VAL" "Value" TRuleVariation498 +type TItem1220 = 'GItem TNonSpare2195 +type TVariation1153 = 'GGroup 0 '[ TItem320, TItem1220] +type TRuleVariation1106 = 'GContextFree TVariation1153 +type TNonSpare1335 = 'GNonSpare "MBC" "Maximum Bits Corrected" TRuleVariation1106 +type TItem572 = 'GItem TNonSpare1335 +type TVariation1417 = 'GExtended '[ 'Just TItem93, 'Just TItem85, 'Just TItem837, 'Just TItem828, 'Nothing, 'Just TItem271, 'Just TItem391, 'Just TItem971, 'Just TItem1143, 'Just TItem917, 'Just TItem174, 'Nothing, 'Just TItem0, 'Just TItem506, 'Just TItem459, 'Just TItem679, 'Just TItem227, 'Just TItem502, 'Just TItem841, 'Nothing, 'Just TItem1057, 'Nothing, 'Just TItem572, 'Nothing] +type TRuleVariation1333 = 'GContextFree TVariation1417 +type TNonSpare153 = 'GNonSpare "040" "Target Report Descriptor" TRuleVariation1333 +type TUapItem153 = 'GUapItem TNonSpare153 +type TNonSpare428 = 'GNonSpare "200" "Target Status" TRuleVariation1127 +type TUapItem428 = 'GUapItem TNonSpare428 +type TNonSpare504 = 'GNonSpare "271" "Surface Capabilities and Characteristics" TRuleVariation1329 +type TUapItem504 = 'GUapItem TNonSpare504 +type TNonSpare494 = 'GNonSpare "260" "ACAS Resolution Advisory Report" TRuleVariation1232 +type TUapItem494 = 'GUapItem TNonSpare494 +type TNonSpare1799 = 'GNonSpare "SAL" "Selected Altitude Age" TRuleVariation235 +type TVariation1557 = 'GCompound '[ 'Just TNonSpare665, 'Just TNonSpare2082, 'Just TNonSpare1304, 'Just TNonSpare1653, 'Just TNonSpare2026, 'Just TNonSpare1327, 'Just TNonSpare1112, 'Just TNonSpare1050, 'Just TNonSpare1799, 'Just TNonSpare1074, 'Just TNonSpare687, 'Just TNonSpare1994, 'Just TNonSpare1386, 'Just TNonSpare755, 'Just TNonSpare1129, 'Just TNonSpare1125, 'Just TNonSpare1991, 'Just TNonSpare2027, 'Just TNonSpare2095, 'Just TNonSpare1378, 'Just TNonSpare1737, 'Just TNonSpare677, 'Just TNonSpare1808] +type TRuleVariation1473 = 'GContextFree TVariation1557 +type TNonSpare511 = 'GNonSpare "295" "Data Ages" TRuleVariation1473 +type TUapItem511 = 'GUapItem TNonSpare511 +type TRecord6 = 'GRecord '[ TUapItem29, TUapItem153, TUapItem388, TUapItem64, TUapItem233, TUapItem329, TUapItem335, TUapItem234, TUapItem366, TUapItem372, TUapItem249, TUapItem235, TUapItem237, TUapItem238, TUapItem240, TUapItem346, TUapItem270, TUapItem439, TUapItem218, TUapItem463, TUapItem360, TUapItem374, TUapItem428, TUapItem376, TUapItem378, TUapItem379, TUapItem392, TUapItem242, TUapItem396, TUapItem79, TUapItem452, TUapItem363, TUapItem365, TUapItem310, TUapItem72, TUapItem27, TUapItem504, TUapItem338, TUapItem480, TUapItem494, TUapItem541, TUapItem511, TUapItem598, TUapItem598, TUapItem598, TUapItem598, TUapItem598, TUapItem594, TUapItem596] +type TUap6 = 'GUap TRecord6 +type TAsterix37 = 'GAsterixBasic 21 ('GEdition 2 6) TUap6 +type TNonSpare1547 = 'GNonSpare "PIC" "Position Integrity Category" TRuleVariation140 +type TItem736 = 'GItem TNonSpare1547 +type TContent440 = 'GContentTable '[ '(0, "PIC mapped from FTC and NIC Supplements"), '(1, "1 PIC directly received in HVA or Phase Overlay")] +type TRuleContent438 = 'GContextFree TContent440 +type TVariation772 = 'GElement 4 1 TRuleContent438 +type TRuleVariation760 = 'GContextFree TVariation772 +type TNonSpare1910 = 'GNonSpare "SRC" "Source of the PIC" TRuleVariation760 +type TItem1003 = 'GItem TNonSpare1910 +type TNonSpare1027 = 'GNonSpare "EP" "VAL_STATE Element Populated Bit" TRuleVariation539 +type TItem335 = 'GItem TNonSpare1027 +type TContent586 = 'GContentTable '[ '(0, "Validation not performed"), '(1, "Validation performed without Pass/Fail (see Note)"), '(2, "Validation Pass (see Note)"), '(3, "Validation Fail (see Note)")] +type TRuleContent584 = 'GContextFree TContent586 +type TVariation707 = 'GElement 3 2 TRuleContent584 +type TRuleVariation695 = 'GContextFree TVariation707 +type TNonSpare2186 = 'GNonSpare "VAL" "VAL_STATE Value" TRuleVariation695 +type TItem1211 = 'GItem TNonSpare2186 +type TVariation1394 = 'GGroup 2 '[ TItem335, TItem1211] +type TRuleVariation1313 = 'GContextFree TVariation1394 +type TNonSpare2214 = 'GNonSpare "VALSTATE" "Position Validation State" TRuleVariation1313 +type TItem1239 = 'GItem TNonSpare2214 +type TContent258 = 'GContentTable '[ '(0, "Item not available"), '(1, "Item available")] +type TRuleContent256 = 'GContextFree TContent258 +type TVariation887 = 'GElement 5 1 TRuleContent256 +type TRuleVariation856 = 'GContextFree TVariation887 +type TNonSpare2216 = 'GNonSpare "VD" "Validation Distance Availability" TRuleVariation856 +type TItem1241 = 'GItem TNonSpare2216 +type TVariation966 = 'GElement 6 1 TRuleContent256 +type TRuleVariation935 = 'GContextFree TVariation966 +type TNonSpare2227 = 'GNonSpare "VQ" "Validation Distance Quality Availability" TRuleVariation935 +type TItem1251 = 'GItem TNonSpare2227 +type TContent760 = 'GContentQuantity 'GUnsigned ('GNumInt ('GZ 'GPlus 128)) "m" +type TRuleContent758 = 'GContextFree TContent760 +type TVariation175 = 'GElement 0 7 TRuleContent758 +type TRuleVariation168 = 'GContextFree TVariation175 +type TNonSpare2210 = 'GNonSpare "VALDISTP1" "Position Validation Distance P1" TRuleVariation168 +type TItem1235 = 'GItem TNonSpare2210 +type TContent748 = 'GContentQuantity 'GUnsigned ('GNumInt ('GZ 'GPlus 1)) "m" +type TRuleContent746 = 'GContextFree TContent748 +type TVariation173 = 'GElement 0 7 TRuleContent746 +type TRuleVariation166 = 'GContextFree TVariation173 +type TNonSpare2211 = 'GNonSpare "VALDISTP2" "Position Validation Distance P2" TRuleVariation166 +type TItem1236 = 'GItem TNonSpare2211 +type TNonSpare2212 = 'GNonSpare "VALDISTQUALP1" "Position Validation Distance Quality P1" TRuleVariation168 +type TItem1237 = 'GItem TNonSpare2212 +type TNonSpare2213 = 'GNonSpare "VALDISTQUALP2" "Position Validation Distance Quality P2" TRuleVariation166 +type TItem1238 = 'GItem TNonSpare2213 +type TVariation1450 = 'GExtended '[ 'Just TItem698, 'Just TItem697, 'Nothing, 'Just TItem672, 'Just TItem963, 'Just TItem655, 'Nothing, 'Just TItem1, 'Just TItem964, 'Just TItem931, 'Just TItem402, 'Nothing, 'Just TItem736, 'Just TItem1003, 'Just TItem24, 'Nothing, 'Just TItem1, 'Just TItem1239, 'Just TItem1241, 'Just TItem1251, 'Nothing, 'Just TItem1235, 'Nothing, 'Just TItem1236, 'Nothing, 'Just TItem1237, 'Nothing, 'Just TItem1238, 'Nothing] +type TRuleVariation1366 = 'GContextFree TVariation1450 +type TNonSpare271 = 'GNonSpare "090" "Quality Indicators" TRuleVariation1366 +type TUapItem271 = 'GUapItem TNonSpare271 +type TNonSpare503 = 'GNonSpare "271" "Surface Capabilities and Characteristics" TRuleVariation1329 +type TUapItem503 = 'GUapItem TNonSpare503 +type TRecord7 = 'GRecord '[ TUapItem29, TUapItem153, TUapItem388, TUapItem64, TUapItem233, TUapItem329, TUapItem335, TUapItem234, TUapItem366, TUapItem372, TUapItem249, TUapItem235, TUapItem237, TUapItem238, TUapItem240, TUapItem346, TUapItem271, TUapItem439, TUapItem218, TUapItem463, TUapItem360, TUapItem374, TUapItem428, TUapItem376, TUapItem378, TUapItem379, TUapItem392, TUapItem242, TUapItem396, TUapItem79, TUapItem452, TUapItem363, TUapItem365, TUapItem310, TUapItem72, TUapItem27, TUapItem503, TUapItem338, TUapItem480, TUapItem494, TUapItem541, TUapItem511, TUapItem598, TUapItem598, TUapItem598, TUapItem598, TUapItem598, TUapItem594, TUapItem596] +type TUap7 = 'GUap TRecord7 +type TAsterix38 = 'GAsterixBasic 21 ('GEdition 2 7) TUap7 +type TNonSpare30 = 'GNonSpare "010" "Data Source Identifier" TRuleVariation1196 +type TUapItem30 = 'GUapItem TNonSpare30 +type TContent606 = 'GContentTable '[ '(1, "Ground station status report"), '(2, "Service status report"), '(3, "Service statistics report")] +type TRuleContent604 = 'GContextFree TContent606 +type TVariation196 = 'GElement 0 8 TRuleContent604 +type TRuleVariation188 = 'GContextFree TVariation196 +type TNonSpare18 = 'GNonSpare "000" "Report Type" TRuleVariation188 +type TUapItem18 = 'GUapItem TNonSpare18 +type TNonSpare1855 = 'GNonSpare "SID" "Service Identification" TRuleVariation140 +type TItem954 = 'GItem TNonSpare1855 +type TContent601 = 'GContentTable '[ '(1, "ADS-B VDL4"), '(2, "ADS-B Ext Squitter"), '(3, "ADS-B UAT"), '(4, "TIS-B VDL4"), '(5, "TIS-B Ext Squitter"), '(6, "TIS-B UAT"), '(7, "FIS-B VDL4"), '(8, "GRAS VDL4"), '(9, "MLT")] +type TRuleContent599 = 'GContextFree TContent601 +type TVariation830 = 'GElement 4 4 TRuleContent599 +type TRuleVariation799 = 'GContextFree TVariation830 +type TNonSpare1966 = 'GNonSpare "STYP" "Type of Service" TRuleVariation799 +type TItem1041 = 'GItem TNonSpare1966 +type TVariation1271 = 'GGroup 0 '[ TItem954, TItem1041] +type TRuleVariation1210 = 'GContextFree TVariation1271 +type TNonSpare69 = 'GNonSpare "015" "Service Type and Identification" TRuleVariation1210 +type TUapItem69 = 'GUapItem TNonSpare69 +type TNonSpare231 = 'GNonSpare "070" "Time of Day" TRuleVariation376 +type TUapItem231 = 'GUapItem TNonSpare231 +type TContent82 = 'GContentTable '[ '(0, "Data is released for operational use"), '(1, "Data must not be used operationally")] +type TRuleContent82 = 'GContextFree TContent82 +type TVariation23 = 'GElement 0 1 TRuleContent82 +type TRuleVariation23 = 'GContextFree TVariation23 +type TNonSpare1484 = 'GNonSpare "NOGO" "Operational Release Status of the Data" TRuleVariation23 +type TItem680 = 'GItem TNonSpare1484 +type TContent203 = 'GContentTable '[ '(0, "Default, no overload"), '(1, "Overload in DP")] +type TRuleContent203 = 'GContextFree TContent203 +type TVariation439 = 'GElement 1 1 TRuleContent203 +type TRuleVariation427 = 'GContextFree TVariation439 +type TNonSpare1512 = 'GNonSpare "ODP" "Data Processor Overload Indicator" TRuleVariation427 +type TItem707 = 'GItem TNonSpare1512 +type TContent205 = 'GContentTable '[ '(0, "Default, no overload"), '(1, "Overload in transmission subsystem")] +type TRuleContent205 = 'GContextFree TContent205 +type TVariation550 = 'GElement 2 1 TRuleContent205 +type TRuleVariation538 = 'GContextFree TVariation550 +type TNonSpare1533 = 'GNonSpare "OXT" "Ground Interface Data Communications Overload" TRuleVariation538 +type TItem727 = 'GItem TNonSpare1533 +type TContent308 = 'GContentTable '[ '(0, "Monitoring system not connected or unknown"), '(1, "Monitoring system connected")] +type TRuleContent306 = 'GContextFree TContent308 +type TVariation669 = 'GElement 3 1 TRuleContent306 +type TRuleVariation657 = 'GContextFree TVariation669 +type TNonSpare1436 = 'GNonSpare "MSC" "Monitoring System Connected Status" TRuleVariation657 +type TItem637 = 'GItem TNonSpare1436 +type TVariation787 = 'GElement 4 1 TRuleContent583 +type TRuleVariation775 = 'GContextFree TVariation787 +type TNonSpare2113 = 'GNonSpare "TSV" "Time Source Validity" TRuleVariation775 +type TItem1146 = 'GItem TNonSpare2113 +type TContent393 = 'GContentTable '[ '(0, "No spoofing detected"), '(1, "Potential spoofing attack")] +type TRuleContent391 = 'GContextFree TContent393 +type TVariation894 = 'GElement 5 1 TRuleContent391 +type TRuleVariation863 = 'GContextFree TVariation894 +type TNonSpare1900 = 'GNonSpare "SPO" "Indication of Spoofing Attack" TRuleVariation863 +type TItem994 = 'GItem TNonSpare1900 +type TContent163 = 'GContentTable '[ '(0, "Default"), '(1, "Track numbering has restarted")] +type TRuleContent163 = 'GContextFree TContent163 +type TVariation951 = 'GElement 6 1 TRuleContent163 +type TRuleVariation920 = 'GContextFree TVariation951 +type TNonSpare1734 = 'GNonSpare "RN" "Renumbering Indication for Track ID" TRuleVariation920 +type TItem884 = 'GItem TNonSpare1734 +type TContent755 = 'GContentQuantity 'GUnsigned ('GNumInt ('GZ 'GPlus 1)) "s" +type TRuleContent753 = 'GContextFree TContent755 +type TVariation174 = 'GElement 0 7 TRuleContent753 +type TRuleVariation167 = 'GContextFree TVariation174 +type TNonSpare1123 = 'GNonSpare "GSSP" "Ground Station Status Reporting Period" TRuleVariation167 +type TItem400 = 'GItem TNonSpare1123 +type TVariation1448 = 'GExtended '[ 'Just TItem680, 'Just TItem707, 'Just TItem727, 'Just TItem637, 'Just TItem1146, 'Just TItem994, 'Just TItem884, 'Nothing, 'Just TItem400, 'Nothing] +type TRuleVariation1364 = 'GContextFree TVariation1448 +type TNonSpare286 = 'GNonSpare "100" "Ground Station Status" TRuleVariation1364 +type TUapItem286 = 'GUapItem TNonSpare286 +type TNonSpare1740 = 'GNonSpare "RP" "Report Period for Category 021 Reports" TRuleVariation233 +type TItem889 = 'GItem TNonSpare1740 +type TContent382 = 'GContentTable '[ '(0, "No information"), '(1, "NRA class"), '(2, "Reserved for future use"), '(3, "Reserved for future use"), '(4, "Reserved for future use"), '(5, "Reserved for future use"), '(6, "Reserved for future use"), '(7, "Reserved for future use")] +type TRuleContent380 = 'GContextFree TContent382 +type TVariation136 = 'GElement 0 3 TRuleContent380 +type TRuleVariation136 = 'GContextFree TVariation136 +type TNonSpare1807 = 'GNonSpare "SC" "Service Class" TRuleVariation136 +type TItem926 = 'GItem TNonSpare1807 +type TItem18 = 'GSpare 3 4 +type TNonSpare1927 = 'GNonSpare "SSRP" "Service Status Reporting Period" TRuleVariation167 +type TItem1011 = 'GItem TNonSpare1927 +type TVariation1454 = 'GExtended '[ 'Just TItem889, 'Just TItem926, 'Just TItem18, 'Nothing, 'Just TItem1011, 'Nothing] +type TRuleVariation1370 = 'GContextFree TVariation1454 +type TNonSpare295 = 'GNonSpare "101" "Service Configuration" TRuleVariation1370 +type TUapItem295 = 'GUapItem TNonSpare295 +type TContent741 = 'GContentQuantity 'GUnsigned ('GNumInt ('GZ 'GPlus 1)) "NM" +type TRuleContent739 = 'GContextFree TContent741 +type TVariation236 = 'GElement 0 8 TRuleContent739 +type TRuleVariation228 = 'GContextFree TVariation236 +type TNonSpare421 = 'GNonSpare "200" "Operational Range" TRuleVariation228 +type TUapItem421 = 'GUapItem TNonSpare421 +type TContent571 = 'GContentTable '[ '(0, "Unknown"), '(1, "Failed"), '(2, "Disabled"), '(3, "Degraded"), '(4, "Normal"), '(5, "Initialisation")] +type TRuleContent569 = 'GContextFree TContent571 +type TVariation822 = 'GElement 4 3 TRuleContent569 +type TRuleVariation795 = 'GContextFree TVariation822 +type TNonSpare1946 = 'GNonSpare "STAT" "Status of the Service" TRuleVariation795 +type TItem1026 = 'GItem TNonSpare1946 +type TVariation1414 = 'GExtended '[ 'Just TItem3, 'Just TItem1026, 'Nothing] +type TRuleVariation1330 = 'GContextFree TVariation1414 +type TNonSpare307 = 'GNonSpare "110" "Service Status" TRuleVariation1330 +type TUapItem307 = 'GUapItem TNonSpare307 +type TContent428 = 'GContentTable '[ '(0, "Number of unknown messages received"), '(1, "Number of too old messages received"), '(2, "Number of failed message conversions"), '(3, "Total Number of messages received"), '(4, "Total Number of messages transmitted"), '(20, "Number of TIS-B management messages received"), '(21, "Number of Basic messages received"), '(22, "Number of High Dynamic messages received"), '(23, "Number of Full Position messages received"), '(24, "Number of Basic Ground messages received"), '(25, "Number of TCP messages received"), '(26, "Number of UTC time messages received"), '(27, "Number of Data messages received"), '(28, "Number of High Resolution messages received"), '(29, "Number of Aircraft Target Airborne messages received"), '(30, "Number of Aircraft Target Ground messages received"), '(31, "Number of Ground Vehicle Target messages received"), '(32, "Number of 2 slots TCP messages received")] +type TRuleContent426 = 'GContextFree TContent428 +type TVariation187 = 'GElement 0 8 TRuleContent426 +type TRuleVariation179 = 'GContextFree TVariation187 +type TNonSpare2146 = 'GNonSpare "TYPE" "Type of Report Counter" TRuleVariation179 +type TItem1175 = 'GItem TNonSpare2146 +type TContent223 = 'GContentTable '[ '(0, "From midnight"), '(1, "From the last report")] +type TRuleContent223 = 'GContextFree TContent223 +type TVariation47 = 'GElement 0 1 TRuleContent223 +type TRuleVariation47 = 'GContextFree TVariation47 +type TNonSpare1710 = 'GNonSpare "REF" "Reference from which the Messages Are Countered" TRuleVariation47 +type TItem862 = 'GItem TNonSpare1710 +type TItem10 = 'GSpare 1 7 +type TNonSpare920 = 'GNonSpare "CV" "32-bit Counter Value" TRuleVariation379 +type TItem249 = 'GItem TNonSpare920 +type TVariation1308 = 'GGroup 0 '[ TItem1175, TItem862, TItem10, TItem249] +type TVariation1526 = 'GRepetitive ('GRepetitiveRegular 1) TVariation1308 +type TRuleVariation1442 = 'GContextFree TVariation1526 +type TNonSpare322 = 'GNonSpare "120" "Service Statistics" TRuleVariation1442 +type TUapItem322 = 'GUapItem TNonSpare322 +type TRecord10 = 'GRecord '[ TUapItem30, TUapItem18, TUapItem69, TUapItem231, TUapItem286, TUapItem295, TUapItem421, TUapItem307, TUapItem322, TUapItem598, TUapItem598, TUapItem598, TUapItem594, TUapItem596] +type TUap10 = 'GUap TRecord10 +type TAsterix39 = 'GAsterixBasic 23 ('GEdition 1 2) TUap10 +type TAsterix40 = 'GAsterixBasic 23 ('GEdition 1 3) TUap10 +type TNonSpare32 = 'GNonSpare "010" "Data Source Identifier" TRuleVariation1196 +type TUapItem32 = 'GUapItem TNonSpare32 +type TRuleVariation160 = 'GContextFree TVariation160 +type TNonSpare1773 = 'GNonSpare "RTYP" "Report Type" TRuleVariation160 +type TItem903 = 'GItem TNonSpare1773 +type TVariation1249 = 'GGroup 0 '[ TItem903, TItem872] +type TRuleVariation1193 = 'GContextFree TVariation1249 +type TNonSpare19 = 'GNonSpare "000" "Report Type" TRuleVariation1193 +type TUapItem19 = 'GUapItem TNonSpare19 +type TNonSpare418 = 'GNonSpare "200" "Message Identification" TRuleVariation357 +type TUapItem418 = 'GUapItem TNonSpare418 +type TNonSpare68 = 'GNonSpare "015" "Service Identification" TRuleVariation171 +type TUapItem68 = 'GUapItem TNonSpare68 +type TNonSpare83 = 'GNonSpare "020" "Service Designator" TRuleVariation396 +type TUapItem83 = 'GUapItem TNonSpare83 +type TNonSpare230 = 'GNonSpare "070" "Time of Day" TRuleVariation376 +type TUapItem230 = 'GUapItem TNonSpare230 +type TNonSpare1481 = 'GNonSpare "NOGO" "" TRuleVariation23 +type TItem677 = 'GItem TNonSpare1481 +type TContent436 = 'GContentTable '[ '(0, "Operational"), '(1, "Operational but in Standby"), '(2, "Maintenance"), '(3, "Reserved for future use")] +type TRuleContent434 = 'GContextFree TContent436 +type TVariation492 = 'GElement 1 2 TRuleContent434 +type TRuleVariation480 = 'GContextFree TVariation492 +type TNonSpare1517 = 'GNonSpare "OPS" "" TRuleVariation480 +type TItem712 = 'GItem TNonSpare1517 +type TContent468 = 'GContentTable '[ '(0, "Running"), '(1, "Failed"), '(2, "Degraded"), '(3, "Undefined"), '(4, "Reserved for future use"), '(5, "Reserved for future use"), '(6, "Reserved for future use"), '(7, "Reserved for future use"), '(8, "Reserved for future use"), '(9, "Reserved for future use"), '(10, "Reserved for future use"), '(11, "Reserved for future use"), '(12, "Reserved for future use"), '(13, "Reserved for future use"), '(14, "Reserved for future use"), '(15, "Reserved for future use")] +type TRuleContent466 = 'GContextFree TContent468 +type TVariation719 = 'GElement 3 4 TRuleContent466 +type TRuleVariation707 = 'GContextFree TVariation719 +type TNonSpare1929 = 'GNonSpare "SSTAT" "" TRuleVariation707 +type TItem1013 = 'GItem TNonSpare1929 +type TContent470 = 'GContentTable '[ '(0, "Running / OK"), '(1, "Failed"), '(2, "Degraded"), '(3, "Undefined"), '(4, "Reserved for future use"), '(5, "Reserved for future use"), '(6, "Reserved for future use"), '(7, "Reserved for future use")] +type TRuleContent468 = 'GContextFree TContent470 +type TVariation503 = 'GElement 1 3 TRuleContent468 +type TRuleVariation491 = 'GContextFree TVariation503 +type TNonSpare1978 = 'GNonSpare "SYSTAT" "" TRuleVariation491 +type TItem1048 = 'GItem TNonSpare1978 +type TContent430 = 'GContentTable '[ '(0, "OK"), '(1, "Failed"), '(2, "Degraded"), '(3, "Undefined"), '(4, "Reserved for future use"), '(5, "Reserved for future use"), '(6, "Reserved for future use"), '(7, "Reserved for future use")] +type TRuleContent428 = 'GContextFree TContent430 +type TVariation816 = 'GElement 4 3 TRuleContent428 +type TRuleVariation794 = 'GContextFree TVariation816 +type TNonSpare1843 = 'GNonSpare "SESTAT" "" TRuleVariation794 +type TItem945 = 'GItem TNonSpare1843 +type TVariation1447 = 'GExtended '[ 'Just TItem677, 'Just TItem712, 'Just TItem1013, 'Nothing, 'Just TItem0, 'Just TItem1048, 'Just TItem945, 'Nothing] +type TRuleVariation1363 = 'GContextFree TVariation1447 +type TNonSpare292 = 'GNonSpare "100" "System and Service Status" TRuleVariation1363 +type TUapItem292 = 'GUapItem TNonSpare292 +type TContent376 = 'GContentTable '[ '(0, "No error detected (shall not be sent)"), '(1, "Error Code Undefined"), '(2, "Time Source Invalid"), '(3, "Time Source Coasting"), '(4, "Track ID numbering has restarted"), '(5, "Data Processor Overload"), '(6, "Ground Interface Data Communications Overload"), '(7, "System stopped by operator"), '(8, "CBIT failed"), '(9, "Test Target Failure"), '(10, "Reserved for allocation by the AMG"), '(11, "Reserved for allocation by the AMG"), '(12, "Reserved for allocation by the AMG"), '(13, "Reserved for allocation by the AMG"), '(14, "Reserved for allocation by the AMG"), '(15, "Reserved for allocation by the AMG"), '(16, "Reserved for allocation by the AMG"), '(17, "Reserved for allocation by the AMG"), '(18, "Reserved for allocation by the AMG"), '(19, "Reserved for allocation by the AMG"), '(20, "Reserved for allocation by the AMG"), '(21, "Reserved for allocation by the AMG"), '(22, "Reserved for allocation by the AMG"), '(23, "Reserved for allocation by the AMG"), '(24, "Reserved for allocation by the AMG"), '(25, "Reserved for allocation by the AMG"), '(26, "Reserved for allocation by the AMG"), '(27, "Reserved for allocation by the AMG"), '(28, "Reserved for allocation by the AMG"), '(29, "Reserved for allocation by the AMG"), '(30, "Reserved for allocation by the AMG"), '(31, "Reserved for allocation by the AMG"), '(32, "Reserved for allocation by system manufacturers"), '(33, "Reserved for allocation by system manufacturers"), '(34, "Reserved for allocation by system manufacturers"), '(35, "Reserved for allocation by system manufacturers"), '(36, "Reserved for allocation by system manufacturers"), '(37, "Reserved for allocation by system manufacturers"), '(38, "Reserved for allocation by system manufacturers"), '(39, "Reserved for allocation by system manufacturers"), '(40, "Reserved for allocation by system manufacturers"), '(41, "Reserved for allocation by system manufacturers"), '(42, "Reserved for allocation by system manufacturers"), '(43, "Reserved for allocation by system manufacturers"), '(44, "Reserved for allocation by system manufacturers"), '(45, "Reserved for allocation by system manufacturers"), '(46, "Reserved for allocation by system manufacturers"), '(47, "Reserved for allocation by system manufacturers"), '(48, "Reserved for allocation by system manufacturers"), '(49, "Reserved for allocation by system manufacturers"), '(50, "Reserved for allocation by system manufacturers"), '(51, "Reserved for allocation by system manufacturers"), '(52, "Reserved for allocation by system manufacturers"), '(53, "Reserved for allocation by system manufacturers"), '(54, "Reserved for allocation by system manufacturers"), '(55, "Reserved for allocation by system manufacturers"), '(56, "Reserved for allocation by system manufacturers"), '(57, "Reserved for allocation by system manufacturers"), '(58, "Reserved for allocation by system manufacturers"), '(59, "Reserved for allocation by system manufacturers"), '(60, "Reserved for allocation by system manufacturers"), '(61, "Reserved for allocation by system manufacturers"), '(62, "Reserved for allocation by system manufacturers"), '(63, "Reserved for allocation by system manufacturers"), '(64, "Reserved for allocation by system manufacturers"), '(65, "Reserved for allocation by system manufacturers"), '(66, "Reserved for allocation by system manufacturers"), '(67, "Reserved for allocation by system manufacturers"), '(68, "Reserved for allocation by system manufacturers"), '(69, "Reserved for allocation by system manufacturers"), '(70, "Reserved for allocation by system manufacturers"), '(71, "Reserved for allocation by system manufacturers"), '(72, "Reserved for allocation by system manufacturers"), '(73, "Reserved for allocation by system manufacturers"), '(74, "Reserved for allocation by system manufacturers"), '(75, "Reserved for allocation by system manufacturers"), '(76, "Reserved for allocation by system manufacturers"), '(77, "Reserved for allocation by system manufacturers"), '(78, "Reserved for allocation by system manufacturers"), '(79, "Reserved for allocation by system manufacturers"), '(80, "Reserved for allocation by system manufacturers"), '(81, "Reserved for allocation by system manufacturers"), '(82, "Reserved for allocation by system manufacturers"), '(83, "Reserved for allocation by system manufacturers"), '(84, "Reserved for allocation by system manufacturers"), '(85, "Reserved for allocation by system manufacturers"), '(86, "Reserved for allocation by system manufacturers"), '(87, "Reserved for allocation by system manufacturers"), '(88, "Reserved for allocation by system manufacturers"), '(89, "Reserved for allocation by system manufacturers"), '(90, "Reserved for allocation by system manufacturers"), '(91, "Reserved for allocation by system manufacturers"), '(92, "Reserved for allocation by system manufacturers"), '(93, "Reserved for allocation by system manufacturers"), '(94, "Reserved for allocation by system manufacturers"), '(95, "Reserved for allocation by system manufacturers"), '(96, "Reserved for allocation by system manufacturers"), '(97, "Reserved for allocation by system manufacturers"), '(98, "Reserved for allocation by system manufacturers"), '(99, "Reserved for allocation by system manufacturers"), '(100, "Reserved for allocation by system manufacturers"), '(101, "Reserved for allocation by system manufacturers"), '(102, "Reserved for allocation by system manufacturers"), '(103, "Reserved for allocation by system manufacturers"), '(104, "Reserved for allocation by system manufacturers"), '(105, "Reserved for allocation by system manufacturers"), '(106, "Reserved for allocation by system manufacturers"), '(107, "Reserved for allocation by system manufacturers"), '(108, "Reserved for allocation by system manufacturers"), '(109, "Reserved for allocation by system manufacturers"), '(110, "Reserved for allocation by system manufacturers"), '(111, "Reserved for allocation by system manufacturers"), '(112, "Reserved for allocation by system manufacturers"), '(113, "Reserved for allocation by system manufacturers"), '(114, "Reserved for allocation by system manufacturers"), '(115, "Reserved for allocation by system manufacturers"), '(116, "Reserved for allocation by system manufacturers"), '(117, "Reserved for allocation by system manufacturers"), '(118, "Reserved for allocation by system manufacturers"), '(119, "Reserved for allocation by system manufacturers"), '(120, "Reserved for allocation by system manufacturers"), '(121, "Reserved for allocation by system manufacturers"), '(122, "Reserved for allocation by system manufacturers"), '(123, "Reserved for allocation by system manufacturers"), '(124, "Reserved for allocation by system manufacturers"), '(125, "Reserved for allocation by system manufacturers"), '(126, "Reserved for allocation by system manufacturers"), '(127, "Reserved for allocation by system manufacturers"), '(128, "Reserved for allocation by system manufacturers"), '(129, "Reserved for allocation by system manufacturers"), '(130, "Reserved for allocation by system manufacturers"), '(131, "Reserved for allocation by system manufacturers"), '(132, "Reserved for allocation by system manufacturers"), '(133, "Reserved for allocation by system manufacturers"), '(134, "Reserved for allocation by system manufacturers"), '(135, "Reserved for allocation by system manufacturers"), '(136, "Reserved for allocation by system manufacturers"), '(137, "Reserved for allocation by system manufacturers"), '(138, "Reserved for allocation by system manufacturers"), '(139, "Reserved for allocation by system manufacturers"), '(140, "Reserved for allocation by system manufacturers"), '(141, "Reserved for allocation by system manufacturers"), '(142, "Reserved for allocation by system manufacturers"), '(143, "Reserved for allocation by system manufacturers"), '(144, "Reserved for allocation by system manufacturers"), '(145, "Reserved for allocation by system manufacturers"), '(146, "Reserved for allocation by system manufacturers"), '(147, "Reserved for allocation by system manufacturers"), '(148, "Reserved for allocation by system manufacturers"), '(149, "Reserved for allocation by system manufacturers"), '(150, "Reserved for allocation by system manufacturers"), '(151, "Reserved for allocation by system manufacturers"), '(152, "Reserved for allocation by system manufacturers"), '(153, "Reserved for allocation by system manufacturers"), '(154, "Reserved for allocation by system manufacturers"), '(155, "Reserved for allocation by system manufacturers"), '(156, "Reserved for allocation by system manufacturers"), '(157, "Reserved for allocation by system manufacturers"), '(158, "Reserved for allocation by system manufacturers"), '(159, "Reserved for allocation by system manufacturers"), '(160, "Reserved for allocation by system manufacturers"), '(161, "Reserved for allocation by system manufacturers"), '(162, "Reserved for allocation by system manufacturers"), '(163, "Reserved for allocation by system manufacturers"), '(164, "Reserved for allocation by system manufacturers"), '(165, "Reserved for allocation by system manufacturers"), '(166, "Reserved for allocation by system manufacturers"), '(167, "Reserved for allocation by system manufacturers"), '(168, "Reserved for allocation by system manufacturers"), '(169, "Reserved for allocation by system manufacturers"), '(170, "Reserved for allocation by system manufacturers"), '(171, "Reserved for allocation by system manufacturers"), '(172, "Reserved for allocation by system manufacturers"), '(173, "Reserved for allocation by system manufacturers"), '(174, "Reserved for allocation by system manufacturers"), '(175, "Reserved for allocation by system manufacturers"), '(176, "Reserved for allocation by system manufacturers"), '(177, "Reserved for allocation by system manufacturers"), '(178, "Reserved for allocation by system manufacturers"), '(179, "Reserved for allocation by system manufacturers"), '(180, "Reserved for allocation by system manufacturers"), '(181, "Reserved for allocation by system manufacturers"), '(182, "Reserved for allocation by system manufacturers"), '(183, "Reserved for allocation by system manufacturers"), '(184, "Reserved for allocation by system manufacturers"), '(185, "Reserved for allocation by system manufacturers"), '(186, "Reserved for allocation by system manufacturers"), '(187, "Reserved for allocation by system manufacturers"), '(188, "Reserved for allocation by system manufacturers"), '(189, "Reserved for allocation by system manufacturers"), '(190, "Reserved for allocation by system manufacturers"), '(191, "Reserved for allocation by system manufacturers"), '(192, "Reserved for allocation by system manufacturers"), '(193, "Reserved for allocation by system manufacturers"), '(194, "Reserved for allocation by system manufacturers"), '(195, "Reserved for allocation by system manufacturers"), '(196, "Reserved for allocation by system manufacturers"), '(197, "Reserved for allocation by system manufacturers"), '(198, "Reserved for allocation by system manufacturers"), '(199, "Reserved for allocation by system manufacturers"), '(200, "Reserved for allocation by system manufacturers"), '(201, "Reserved for allocation by system manufacturers"), '(202, "Reserved for allocation by system manufacturers"), '(203, "Reserved for allocation by system manufacturers"), '(204, "Reserved for allocation by system manufacturers"), '(205, "Reserved for allocation by system manufacturers"), '(206, "Reserved for allocation by system manufacturers"), '(207, "Reserved for allocation by system manufacturers"), '(208, "Reserved for allocation by system manufacturers"), '(209, "Reserved for allocation by system manufacturers"), '(210, "Reserved for allocation by system manufacturers"), '(211, "Reserved for allocation by system manufacturers"), '(212, "Reserved for allocation by system manufacturers"), '(213, "Reserved for allocation by system manufacturers"), '(214, "Reserved for allocation by system manufacturers"), '(215, "Reserved for allocation by system manufacturers"), '(216, "Reserved for allocation by system manufacturers"), '(217, "Reserved for allocation by system manufacturers"), '(218, "Reserved for allocation by system manufacturers"), '(219, "Reserved for allocation by system manufacturers"), '(220, "Reserved for allocation by system manufacturers"), '(221, "Reserved for allocation by system manufacturers"), '(222, "Reserved for allocation by system manufacturers"), '(223, "Reserved for allocation by system manufacturers"), '(224, "Reserved for allocation by system manufacturers"), '(225, "Reserved for allocation by system manufacturers"), '(226, "Reserved for allocation by system manufacturers"), '(227, "Reserved for allocation by system manufacturers"), '(228, "Reserved for allocation by system manufacturers"), '(229, "Reserved for allocation by system manufacturers"), '(230, "Reserved for allocation by system manufacturers"), '(231, "Reserved for allocation by system manufacturers"), '(232, "Reserved for allocation by system manufacturers"), '(233, "Reserved for allocation by system manufacturers"), '(234, "Reserved for allocation by system manufacturers"), '(235, "Reserved for allocation by system manufacturers"), '(236, "Reserved for allocation by system manufacturers"), '(237, "Reserved for allocation by system manufacturers"), '(238, "Reserved for allocation by system manufacturers"), '(239, "Reserved for allocation by system manufacturers"), '(240, "Reserved for allocation by system manufacturers"), '(241, "Reserved for allocation by system manufacturers"), '(242, "Reserved for allocation by system manufacturers"), '(243, "Reserved for allocation by system manufacturers"), '(244, "Reserved for allocation by system manufacturers"), '(245, "Reserved for allocation by system manufacturers"), '(246, "Reserved for allocation by system manufacturers"), '(247, "Reserved for allocation by system manufacturers"), '(248, "Reserved for allocation by system manufacturers"), '(249, "Reserved for allocation by system manufacturers"), '(250, "Reserved for allocation by system manufacturers"), '(251, "Reserved for allocation by system manufacturers"), '(252, "Reserved for allocation by system manufacturers"), '(253, "Reserved for allocation by system manufacturers"), '(254, "Reserved for allocation by system manufacturers"), '(255, "Reserved for allocation by system manufacturers")] +type TRuleContent374 = 'GContextFree TContent376 +type TVariation186 = 'GElement 0 8 TRuleContent374 +type TVariation1470 = 'GRepetitive ('GRepetitiveRegular 1) TVariation186 +type TRuleVariation1386 = 'GContextFree TVariation1470 +type TNonSpare299 = 'GNonSpare "105" "System and Service Error Codes" TRuleVariation1386 +type TUapItem299 = 'GUapItem TNonSpare299 +type TNonSpare806 = 'GNonSpare "CID" "Component ID" TRuleVariation259 +type TItem173 = 'GItem TNonSpare806 +type TContent320 = 'GContentTable '[ '(0, "No Error Detected"), '(1, "Error Code Undefined"), '(2, "Reserved for allocation by the AMG"), '(3, "Reserved for allocation by the AMG"), '(4, "Reserved for allocation by the AMG"), '(5, "Reserved for allocation by the AMG"), '(6, "Reserved for allocation by the AMG"), '(7, "Reserved for allocation by the AMG"), '(8, "Reserved for allocation by the AMG"), '(9, "Reserved for allocation by the AMG"), '(10, "Reserved for allocation by the AMG"), '(11, "Reserved for allocation by the AMG"), '(12, "Reserved for allocation by the AMG"), '(13, "Reserved for allocation by the AMG"), '(14, "Reserved for allocation by the AMG"), '(15, "Reserved for allocation by the AMG"), '(16, "Reserved for allocation by system manufacturers"), '(17, "Reserved for allocation by system manufacturers"), '(18, "Reserved for allocation by system manufacturers"), '(19, "Reserved for allocation by system manufacturers"), '(20, "Reserved for allocation by system manufacturers"), '(21, "Reserved for allocation by system manufacturers"), '(22, "Reserved for allocation by system manufacturers"), '(23, "Reserved for allocation by system manufacturers"), '(24, "Reserved for allocation by system manufacturers"), '(25, "Reserved for allocation by system manufacturers"), '(26, "Reserved for allocation by system manufacturers"), '(27, "Reserved for allocation by system manufacturers"), '(28, "Reserved for allocation by system manufacturers"), '(29, "Reserved for allocation by system manufacturers"), '(30, "Reserved for allocation by system manufacturers"), '(31, "Reserved for allocation by system manufacturers"), '(32, "Reserved for allocation by system manufacturers"), '(33, "Reserved for allocation by system manufacturers"), '(34, "Reserved for allocation by system manufacturers"), '(35, "Reserved for allocation by system manufacturers"), '(36, "Reserved for allocation by system manufacturers"), '(37, "Reserved for allocation by system manufacturers"), '(38, "Reserved for allocation by system manufacturers"), '(39, "Reserved for allocation by system manufacturers"), '(40, "Reserved for allocation by system manufacturers"), '(41, "Reserved for allocation by system manufacturers"), '(42, "Reserved for allocation by system manufacturers"), '(43, "Reserved for allocation by system manufacturers"), '(44, "Reserved for allocation by system manufacturers"), '(45, "Reserved for allocation by system manufacturers"), '(46, "Reserved for allocation by system manufacturers"), '(47, "Reserved for allocation by system manufacturers"), '(48, "Reserved for allocation by system manufacturers"), '(49, "Reserved for allocation by system manufacturers"), '(50, "Reserved for allocation by system manufacturers"), '(51, "Reserved for allocation by system manufacturers"), '(52, "Reserved for allocation by system manufacturers"), '(53, "Reserved for allocation by system manufacturers"), '(54, "Reserved for allocation by system manufacturers"), '(55, "Reserved for allocation by system manufacturers"), '(56, "Reserved for allocation by system manufacturers"), '(57, "Reserved for allocation by system manufacturers"), '(58, "Reserved for allocation by system manufacturers"), '(59, "Reserved for allocation by system manufacturers"), '(60, "Reserved for allocation by system manufacturers"), '(61, "Reserved for allocation by system manufacturers"), '(62, "Reserved for allocation by system manufacturers"), '(63, "Reserved for allocation by system manufacturers")] +type TRuleContent318 = 'GContextFree TContent320 +type TVariation158 = 'GElement 0 6 TRuleContent318 +type TRuleVariation158 = 'GContextFree TVariation158 +type TNonSpare1034 = 'GNonSpare "ERRC" "Error Code" TRuleVariation158 +type TItem340 = 'GItem TNonSpare1034 +type TContent469 = 'GContentTable '[ '(0, "Running"), '(1, "Failed"), '(2, "Maintenance"), '(3, "Reserved")] +type TRuleContent467 = 'GContextFree TContent469 +type TVariation997 = 'GElement 6 2 TRuleContent467 +type TRuleVariation966 = 'GContextFree TVariation997 +type TNonSpare901 = 'GNonSpare "CS" "Component State/Mode" TRuleVariation966 +type TItem234 = 'GItem TNonSpare901 +type TVariation1118 = 'GGroup 0 '[ TItem173, TItem340, TItem234] +type TVariation1494 = 'GRepetitive ('GRepetitiveRegular 1) TVariation1118 +type TRuleVariation1410 = 'GContextFree TVariation1494 +type TNonSpare314 = 'GNonSpare "120" "Component Status" TRuleVariation1410 +type TUapItem314 = 'GUapItem TNonSpare314 +type TContent429 = 'GContentTable '[ '(0, "Number of unknown messages received"), '(1, "Number of too old messages received"), '(2, "Number of failed message conversions"), '(3, "Total Number of messages received"), '(4, "Total number of messages transmitted"), '(5, "Reserved for AMG"), '(6, "Reserved for AMG"), '(7, "Reserved for AMG"), '(8, "Reserved for AMG"), '(9, "Reserved for AMG"), '(10, "Reserved for AMG"), '(11, "Reserved for AMG"), '(12, "Reserved for AMG"), '(13, "Reserved for AMG"), '(14, "Reserved for AMG"), '(15, "Reserved for AMG"), '(16, "Reserved for AMG"), '(17, "Reserved for AMG"), '(18, "Reserved for AMG"), '(19, "Reserved for AMG"), '(20, "Implementation specific"), '(21, "Implementation specific"), '(22, "Implementation specific"), '(23, "Implementation specific"), '(24, "Implementation specific"), '(25, "Implementation specific"), '(26, "Implementation specific"), '(27, "Implementation specific"), '(28, "Implementation specific"), '(29, "Implementation specific"), '(30, "Implementation specific"), '(31, "Implementation specific"), '(32, "Implementation specific"), '(33, "Implementation specific"), '(34, "Implementation specific"), '(35, "Implementation specific"), '(36, "Implementation specific"), '(37, "Implementation specific"), '(38, "Implementation specific"), '(39, "Implementation specific"), '(40, "Implementation specific"), '(41, "Implementation specific"), '(42, "Implementation specific"), '(43, "Implementation specific"), '(44, "Implementation specific"), '(45, "Implementation specific"), '(46, "Implementation specific"), '(47, "Implementation specific"), '(48, "Implementation specific"), '(49, "Implementation specific"), '(50, "Implementation specific"), '(51, "Implementation specific"), '(52, "Implementation specific"), '(53, "Implementation specific"), '(54, "Implementation specific"), '(55, "Implementation specific"), '(56, "Implementation specific"), '(57, "Implementation specific"), '(58, "Implementation specific"), '(59, "Implementation specific"), '(60, "Implementation specific"), '(61, "Implementation specific"), '(62, "Implementation specific"), '(63, "Implementation specific"), '(64, "Implementation specific"), '(65, "Implementation specific"), '(66, "Implementation specific"), '(67, "Implementation specific"), '(68, "Implementation specific"), '(69, "Implementation specific"), '(70, "Implementation specific"), '(71, "Implementation specific"), '(72, "Implementation specific"), '(73, "Implementation specific"), '(74, "Implementation specific"), '(75, "Implementation specific"), '(76, "Implementation specific"), '(77, "Implementation specific"), '(78, "Implementation specific"), '(79, "Implementation specific"), '(80, "Implementation specific"), '(81, "Implementation specific"), '(82, "Implementation specific"), '(83, "Implementation specific"), '(84, "Implementation specific"), '(85, "Implementation specific"), '(86, "Implementation specific"), '(87, "Implementation specific"), '(88, "Implementation specific"), '(89, "Implementation specific"), '(90, "Implementation specific"), '(91, "Implementation specific"), '(92, "Implementation specific"), '(93, "Implementation specific"), '(94, "Implementation specific"), '(95, "Implementation specific"), '(96, "Implementation specific"), '(97, "Implementation specific"), '(98, "Implementation specific"), '(99, "Implementation specific"), '(100, "Implementation specific"), '(101, "Implementation specific"), '(102, "Implementation specific"), '(103, "Implementation specific"), '(104, "Implementation specific"), '(105, "Implementation specific"), '(106, "Implementation specific"), '(107, "Implementation specific"), '(108, "Implementation specific"), '(109, "Implementation specific"), '(110, "Implementation specific"), '(111, "Implementation specific"), '(112, "Implementation specific"), '(113, "Implementation specific"), '(114, "Implementation specific"), '(115, "Implementation specific"), '(116, "Implementation specific"), '(117, "Implementation specific"), '(118, "Implementation specific"), '(119, "Implementation specific"), '(120, "Implementation specific"), '(121, "Implementation specific"), '(122, "Implementation specific"), '(123, "Implementation specific"), '(124, "Implementation specific"), '(125, "Implementation specific"), '(126, "Implementation specific"), '(127, "Implementation specific"), '(128, "Implementation specific"), '(129, "Implementation specific"), '(130, "Implementation specific"), '(131, "Implementation specific"), '(132, "Implementation specific"), '(133, "Implementation specific"), '(134, "Implementation specific"), '(135, "Implementation specific"), '(136, "Implementation specific"), '(137, "Implementation specific"), '(138, "Implementation specific"), '(139, "Implementation specific"), '(140, "Implementation specific"), '(141, "Implementation specific"), '(142, "Implementation specific"), '(143, "Implementation specific"), '(144, "Implementation specific"), '(145, "Implementation specific"), '(146, "Implementation specific"), '(147, "Implementation specific"), '(148, "Implementation specific"), '(149, "Implementation specific"), '(150, "Implementation specific"), '(151, "Implementation specific"), '(152, "Implementation specific"), '(153, "Implementation specific"), '(154, "Implementation specific"), '(155, "Implementation specific"), '(156, "Implementation specific"), '(157, "Implementation specific"), '(158, "Implementation specific"), '(159, "Implementation specific"), '(160, "Implementation specific"), '(161, "Implementation specific"), '(162, "Implementation specific"), '(163, "Implementation specific"), '(164, "Implementation specific"), '(165, "Implementation specific"), '(166, "Implementation specific"), '(167, "Implementation specific"), '(168, "Implementation specific"), '(169, "Implementation specific"), '(170, "Implementation specific"), '(171, "Implementation specific"), '(172, "Implementation specific"), '(173, "Implementation specific"), '(174, "Implementation specific"), '(175, "Implementation specific"), '(176, "Implementation specific"), '(177, "Implementation specific"), '(178, "Implementation specific"), '(179, "Implementation specific"), '(180, "Implementation specific"), '(181, "Implementation specific"), '(182, "Implementation specific"), '(183, "Implementation specific"), '(184, "Implementation specific"), '(185, "Implementation specific"), '(186, "Implementation specific"), '(187, "Implementation specific"), '(188, "Implementation specific"), '(189, "Implementation specific"), '(190, "Implementation specific"), '(191, "Implementation specific"), '(192, "Implementation specific"), '(193, "Implementation specific"), '(194, "Implementation specific"), '(195, "Implementation specific"), '(196, "Implementation specific"), '(197, "Implementation specific"), '(198, "Implementation specific"), '(199, "Implementation specific"), '(200, "Implementation specific"), '(201, "Implementation specific"), '(202, "Implementation specific"), '(203, "Implementation specific"), '(204, "Implementation specific"), '(205, "Implementation specific"), '(206, "Implementation specific"), '(207, "Implementation specific"), '(208, "Implementation specific"), '(209, "Implementation specific"), '(210, "Implementation specific"), '(211, "Implementation specific"), '(212, "Implementation specific"), '(213, "Implementation specific"), '(214, "Implementation specific"), '(215, "Implementation specific"), '(216, "Implementation specific"), '(217, "Implementation specific"), '(218, "Implementation specific"), '(219, "Implementation specific"), '(220, "Implementation specific"), '(221, "Implementation specific"), '(222, "Implementation specific"), '(223, "Implementation specific"), '(224, "Implementation specific"), '(225, "Implementation specific"), '(226, "Implementation specific"), '(227, "Implementation specific"), '(228, "Implementation specific"), '(229, "Implementation specific"), '(230, "Implementation specific"), '(231, "Implementation specific"), '(232, "Implementation specific"), '(233, "Implementation specific"), '(234, "Implementation specific"), '(235, "Implementation specific"), '(236, "Implementation specific"), '(237, "Implementation specific"), '(238, "Implementation specific"), '(239, "Implementation specific"), '(240, "Implementation specific"), '(241, "Implementation specific"), '(242, "Implementation specific"), '(243, "Implementation specific"), '(244, "Implementation specific"), '(245, "Implementation specific"), '(246, "Implementation specific"), '(247, "Implementation specific"), '(248, "Implementation specific"), '(249, "Implementation specific"), '(250, "Implementation specific"), '(251, "Implementation specific"), '(252, "Implementation specific"), '(253, "Implementation specific"), '(254, "Implementation specific"), '(255, "Implementation specific")] +type TRuleContent427 = 'GContextFree TContent429 +type TVariation188 = 'GElement 0 8 TRuleContent427 +type TRuleVariation180 = 'GContextFree TVariation188 +type TNonSpare2147 = 'GNonSpare "TYPE" "Type of Report Counter" TRuleVariation180 +type TItem1176 = 'GItem TNonSpare2147 +type TContent222 = 'GContentTable '[ '(0, "From UTC midnight"), '(1, "From the previous report")] +type TRuleContent222 = 'GContextFree TContent222 +type TVariation46 = 'GElement 0 1 TRuleContent222 +type TRuleVariation46 = 'GContextFree TVariation46 +type TNonSpare1709 = 'GNonSpare "REF" "Reference from which the Messages Are Counted" TRuleVariation46 +type TItem861 = 'GItem TNonSpare1709 +type TNonSpare868 = 'GNonSpare "COUNT" "Counter Value" TRuleVariation381 +type TItem215 = 'GItem TNonSpare868 +type TVariation1309 = 'GGroup 0 '[ TItem1176, TItem861, TItem10, TItem215] +type TVariation1527 = 'GRepetitive ('GRepetitiveRegular 1) TVariation1309 +type TRuleVariation1443 = 'GContextFree TVariation1527 +type TNonSpare348 = 'GNonSpare "140" "Service Statistics" TRuleVariation1443 +type TUapItem348 = 'GUapItem TNonSpare348 +type TContent735 = 'GContentQuantity 'GSigned ('GNumDiv ('GNumInt ('GZ 'GPlus 180)) ('GNumPow ('GZ 'GPlus 2) ('GZ 'GPlus 32))) "°" +type TRuleContent733 = 'GContextFree TContent735 +type TVariation399 = 'GElement 0 32 TRuleContent733 +type TRuleVariation391 = 'GContextFree TVariation399 +type TNonSpare1235 = 'GNonSpare "LAT" "Latitude" TRuleVariation391 +type TItem491 = 'GItem TNonSpare1235 +type TContent734 = 'GContentQuantity 'GSigned ('GNumDiv ('GNumInt ('GZ 'GPlus 180)) ('GNumPow ('GZ 'GPlus 2) ('GZ 'GPlus 32))) "°" +type TRuleContent732 = 'GContextFree TContent734 +type TVariation398 = 'GElement 0 32 TRuleContent732 +type TRuleVariation390 = 'GContextFree TVariation398 +type TNonSpare1268 = 'GNonSpare "LON" "Longitude" TRuleVariation390 +type TItem522 = 'GItem TNonSpare1268 +type TVariation1187 = 'GGroup 0 '[ TItem491, TItem522] +type TRuleVariation1138 = 'GContextFree TVariation1187 +type TNonSpare579 = 'GNonSpare "600" "Position of the System Reference Point" TRuleVariation1138 +type TUapItem577 = 'GUapItem TNonSpare579 +type TContent689 = 'GContentQuantity 'GSigned ('GNumDiv ('GNumInt ('GZ 'GPlus 1)) ('GNumPow ('GZ 'GPlus 2) ('GZ 'GPlus 2))) "m" +type TRuleContent687 = 'GContextFree TContent689 +type TVariation292 = 'GElement 0 16 TRuleContent687 +type TRuleVariation284 = 'GContextFree TVariation292 +type TNonSpare587 = 'GNonSpare "610" "Height of the System Reference Point" TRuleVariation284 +type TUapItem585 = 'GUapItem TNonSpare587 +type TRecord13 = 'GRecord '[ TUapItem32, TUapItem19, TUapItem418, TUapItem68, TUapItem83, TUapItem230, TUapItem292, TUapItem299, TUapItem314, TUapItem348, TUapItem596, TUapItem577, TUapItem585] +type TUap13 = 'GUap TRecord13 +type TAsterix41 = 'GAsterixBasic 25 ('GEdition 1 5) TUap13 +type TContent319 = 'GContentTable '[ '(0, "No Error Detected"), '(1, "Error Code Undefined"), '(2, "Alert"), '(3, "Alarm"), '(4, "Reserved for allocation by the AMG"), '(5, "Reserved for allocation by the AMG"), '(6, "Reserved for allocation by the AMG"), '(7, "Reserved for allocation by the AMG"), '(8, "Reserved for allocation by the AMG"), '(9, "Reserved for allocation by the AMG"), '(10, "Reserved for allocation by the AMG"), '(11, "Reserved for allocation by the AMG"), '(12, "Reserved for allocation by the AMG"), '(13, "Reserved for allocation by the AMG"), '(14, "Reserved for allocation by the AMG"), '(15, "Reserved for allocation by the AMG"), '(16, "Reserved for allocation by system manufacturers"), '(17, "Reserved for allocation by system manufacturers"), '(18, "Reserved for allocation by system manufacturers"), '(19, "Reserved for allocation by system manufacturers"), '(20, "Reserved for allocation by system manufacturers"), '(21, "Reserved for allocation by system manufacturers"), '(22, "Reserved for allocation by system manufacturers"), '(23, "Reserved for allocation by system manufacturers"), '(24, "Reserved for allocation by system manufacturers"), '(25, "Reserved for allocation by system manufacturers"), '(26, "Reserved for allocation by system manufacturers"), '(27, "Reserved for allocation by system manufacturers"), '(28, "Reserved for allocation by system manufacturers"), '(29, "Reserved for allocation by system manufacturers"), '(30, "Reserved for allocation by system manufacturers"), '(31, "Reserved for allocation by system manufacturers"), '(32, "Reserved for allocation by system manufacturers"), '(33, "Reserved for allocation by system manufacturers"), '(34, "Reserved for allocation by system manufacturers"), '(35, "Reserved for allocation by system manufacturers"), '(36, "Reserved for allocation by system manufacturers"), '(37, "Reserved for allocation by system manufacturers"), '(38, "Reserved for allocation by system manufacturers"), '(39, "Reserved for allocation by system manufacturers"), '(40, "Reserved for allocation by system manufacturers"), '(41, "Reserved for allocation by system manufacturers"), '(42, "Reserved for allocation by system manufacturers"), '(43, "Reserved for allocation by system manufacturers"), '(44, "Reserved for allocation by system manufacturers"), '(45, "Reserved for allocation by system manufacturers"), '(46, "Reserved for allocation by system manufacturers"), '(47, "Reserved for allocation by system manufacturers"), '(48, "Reserved for allocation by system manufacturers"), '(49, "Reserved for allocation by system manufacturers"), '(50, "Reserved for allocation by system manufacturers"), '(51, "Reserved for allocation by system manufacturers"), '(52, "Reserved for allocation by system manufacturers"), '(53, "Reserved for allocation by system manufacturers"), '(54, "Reserved for allocation by system manufacturers"), '(55, "Reserved for allocation by system manufacturers"), '(56, "Reserved for allocation by system manufacturers"), '(57, "Reserved for allocation by system manufacturers"), '(58, "Reserved for allocation by system manufacturers"), '(59, "Reserved for allocation by system manufacturers"), '(60, "Reserved for allocation by system manufacturers"), '(61, "Reserved for allocation by system manufacturers"), '(62, "Reserved for allocation by system manufacturers"), '(63, "Reserved for allocation by system manufacturers")] +type TRuleContent317 = 'GContextFree TContent319 +type TVariation157 = 'GElement 0 6 TRuleContent317 +type TRuleVariation157 = 'GContextFree TVariation157 +type TNonSpare1033 = 'GNonSpare "ERRC" "Error Code" TRuleVariation157 +type TItem339 = 'GItem TNonSpare1033 +type TVariation1117 = 'GGroup 0 '[ TItem173, TItem339, TItem234] +type TVariation1493 = 'GRepetitive ('GRepetitiveRegular 1) TVariation1117 +type TRuleVariation1409 = 'GContextFree TVariation1493 +type TNonSpare313 = 'GNonSpare "120" "Component Status" TRuleVariation1409 +type TUapItem313 = 'GUapItem TNonSpare313 +type TRecord12 = 'GRecord '[ TUapItem32, TUapItem19, TUapItem418, TUapItem68, TUapItem83, TUapItem230, TUapItem292, TUapItem299, TUapItem313, TUapItem348, TUapItem596, TUapItem577, TUapItem585] +type TUap12 = 'GUap TRecord12 +type TAsterix42 = 'GAsterixBasic 25 ('GEdition 1 6) TUap12 +type TNonSpare50 = 'GNonSpare "010" "Server Identification Tag" TRuleVariation1196 +type TUapItem50 = 'GUapItem TNonSpare50 +type TNonSpare70 = 'GNonSpare "015" "User Number" TRuleVariation262 +type TUapItem70 = 'GUapItem TNonSpare70 +type TNonSpare74 = 'GNonSpare "018" "Data Source Identification Tag" TRuleVariation1196 +type TUapItem74 = 'GUapItem TNonSpare74 +type TContent607 = 'GContentTable '[ '(1, "Information sent by an FPPS")] +type TRuleContent605 = 'GContextFree TContent607 +type TVariation145 = 'GElement 0 4 TRuleContent605 +type TRuleVariation145 = 'GContextFree TVariation145 +type TNonSpare1044 = 'GNonSpare "FAMILY" "" TRuleVariation145 +type TItem349 = 'GItem TNonSpare1044 +type TContent604 = 'GContentTable '[ '(1, "Flight Plan to track initial correlation"), '(2, "Miniplan update"), '(3, "End of correlation"), '(4, "Miniplan Cancellation"), '(5, "Retained Miniplan")] +type TRuleContent602 = 'GContextFree TContent604 +type TVariation831 = 'GElement 4 4 TRuleContent602 +type TRuleVariation800 = 'GContextFree TVariation831 +type TNonSpare1459 = 'GNonSpare "NATURE" "" TRuleVariation800 +type TItem657 = 'GItem TNonSpare1459 +type TVariation1160 = 'GGroup 0 '[ TItem349, TItem657] +type TRuleVariation1113 = 'GContextFree TVariation1160 +type TNonSpare136 = 'GNonSpare "035" "Type of Message" TRuleVariation1113 +type TUapItem136 = 'GUapItem TNonSpare136 +type TNonSpare93 = 'GNonSpare "020" "Time of ASTERIX Report Generation" TRuleVariation376 +type TUapItem93 = 'GUapItem TNonSpare93 +type TNonSpare156 = 'GNonSpare "040" "Track Number" TRuleVariation262 +type TUapItem156 = 'GUapItem TNonSpare156 +type TNonSpare1969 = 'GNonSpare "SUI" "System Unit Identification" TRuleVariation211 +type TItem1044 = 'GItem TNonSpare1969 +type TVariation266 = 'GElement 0 15 TRuleContent638 +type TRuleVariation258 = 'GContextFree TVariation266 +type TNonSpare1955 = 'GNonSpare "STN" "System Track Number" TRuleVariation258 +type TItem1034 = 'GItem TNonSpare1955 +type TVariation1460 = 'GExtended '[ 'Just TItem1044, 'Just TItem1034, 'Nothing] +type TRuleVariation1376 = 'GContextFree TVariation1460 +type TNonSpare176 = 'GNonSpare "050" "Composed Track Number" TRuleVariation1376 +type TUapItem176 = 'GUapItem TNonSpare176 +type TNonSpare1414 = 'GNonSpare "MODE3A" "(Mode 3/A Code) 4 Digits, Octal Representation" TRuleVariation807 +type TItem618 = 'GItem TNonSpare1414 +type TVariation1066 = 'GGroup 0 '[ TItem3, TItem618] +type TRuleVariation1034 = 'GContextFree TVariation1066 +type TNonSpare210 = 'GNonSpare "060" "Track Mode 3/A" TRuleVariation1034 +type TUapItem210 = 'GUapItem TNonSpare210 +type TNonSpare538 = 'GNonSpare "400" "Callsign" TRuleVariation398 +type TUapItem536 = 'GUapItem TNonSpare538 +type TNonSpare546 = 'GNonSpare "410" "Plan Number" TRuleVariation262 +type TUapItem544 = 'GUapItem TNonSpare546 +type TNonSpare1101 = 'GNonSpare "GATOAT" "" TRuleVariation122 +type TItem384 = 'GItem TNonSpare1101 +type TNonSpare1068 = 'GNonSpare "FR1FR2" "" TRuleVariation598 +type TItem364 = 'GItem TNonSpare1068 +type TNonSpare1891 = 'GNonSpare "SP3" "" TRuleVariation712 +type TItem986 = 'GItem TNonSpare1891 +type TNonSpare1890 = 'GNonSpare "SP2" "" TRuleVariation815 +type TItem985 = 'GItem TNonSpare1890 +type TNonSpare1889 = 'GNonSpare "SP1" "" TRuleVariation898 +type TItem984 = 'GItem TNonSpare1889 +type TVariation1166 = 'GGroup 0 '[ TItem384, TItem364, TItem986, TItem985, TItem984, TItem29] +type TRuleVariation1119 = 'GContextFree TVariation1166 +type TNonSpare550 = 'GNonSpare "420" "Flight Category" TRuleVariation1119 +type TUapItem548 = 'GUapItem TNonSpare550 +type TNonSpare555 = 'GNonSpare "440" "Departure Aerodrome" TRuleVariation380 +type TUapItem553 = 'GUapItem TNonSpare555 +type TNonSpare557 = 'GNonSpare "450" "Destination Aerodrome" TRuleVariation380 +type TUapItem555 = 'GUapItem TNonSpare557 +type TContent783 = 'GContentQuantity 'GUnsigned ('GNumDiv ('GNumInt ('GZ 'GPlus 1)) ('GNumPow ('GZ 'GPlus 2) ('GZ 'GPlus 2))) "FL" +type TRuleContent780 = 'GContextFree TContent783 +type TVariation336 = 'GElement 0 16 TRuleContent780 +type TRuleVariation328 = 'GContextFree TVariation336 +type TNonSpare561 = 'GNonSpare "480" "Current Cleared Flight Level" TRuleVariation328 +type TUapItem559 = 'GUapItem TNonSpare561 +type TNonSpare786 = 'GNonSpare "CEN" "Centre" TRuleVariation171 +type TItem160 = 'GItem TNonSpare786 +type TNonSpare1569 = 'GNonSpare "POS" "Position" TRuleVariation171 +type TItem748 = 'GItem TNonSpare1569 +type TVariation1114 = 'GGroup 0 '[ TItem160, TItem748] +type TRuleVariation1072 = 'GContextFree TVariation1114 +type TNonSpare562 = 'GNonSpare "490" "Current Control Position" TRuleVariation1072 +type TUapItem560 = 'GUapItem TNonSpare562 +type TNonSpare553 = 'GNonSpare "430" "Type of Aircraft" TRuleVariation380 +type TUapItem551 = 'GUapItem TNonSpare553 +type TNonSpare554 = 'GNonSpare "435" "Wake Turbulence Category" TRuleVariation208 +type TUapItem552 = 'GUapItem TNonSpare554 +type TNonSpare1508 = 'GNonSpare "OCT1" "1st Octal Digit" TRuleVariation789 +type TItem703 = 'GItem TNonSpare1508 +type TVariation1028 = 'GElement 7 3 TRuleContent0 +type TRuleVariation997 = 'GContextFree TVariation1028 +type TNonSpare1509 = 'GNonSpare "OCT2" "2nd Octal Digit" TRuleVariation997 +type TItem704 = 'GItem TNonSpare1509 +type TVariation615 = 'GElement 2 3 TRuleContent0 +type TRuleVariation603 = 'GContextFree TVariation615 +type TNonSpare1510 = 'GNonSpare "OCT3" "3rd Octal Digit" TRuleVariation603 +type TItem705 = 'GItem TNonSpare1510 +type TNonSpare1511 = 'GNonSpare "OCT4" "4th Octal Digit" TRuleVariation888 +type TItem706 = 'GItem TNonSpare1511 +type TVariation1071 = 'GGroup 0 '[ TItem3, TItem703, TItem704, TItem705, TItem706] +type TVariation1483 = 'GRepetitive ('GRepetitiveRegular 1) TVariation1071 +type TRuleVariation1399 = 'GContextFree TVariation1483 +type TNonSpare559 = 'GNonSpare "460" "Allocated SSR Codes" TRuleVariation1399 +type TUapItem557 = 'GUapItem TNonSpare559 +type TContent449 = 'GContentTable '[ '(0, "Plan Number"), '(1, "Unit 1 internal flight number"), '(2, "Unit 2 internal flight number"), '(3, "Unit 3 internal flight number")] +type TRuleContent447 = 'GContextFree TContent449 +type TVariation116 = 'GElement 0 2 TRuleContent447 +type TRuleVariation116 = 'GContextFree TVariation116 +type TNonSpare2130 = 'GNonSpare "TYP" "" TRuleVariation116 +type TItem1160 = 'GItem TNonSpare2130 +type TContent647 = 'GContentInteger 'GUnsigned +type TRuleContent645 = 'GContextFree TContent647 +type TVariation927 = 'GElement 5 27 TRuleContent645 +type TRuleVariation896 = 'GContextFree TVariation927 +type TNonSpare1468 = 'GNonSpare "NBR" "" TRuleVariation896 +type TItem664 = 'GItem TNonSpare1468 +type TVariation1296 = 'GGroup 0 '[ TItem1160, TItem13, TItem664] +type TRuleVariation1229 = 'GContextFree TVariation1296 +type TNonSpare1195 = 'GNonSpare "IFI" "IFPS FLIGHT ID" TRuleVariation1229 +type TContent568 = 'GContentTable '[ '(0, "Unknown"), '(1, "Approved"), '(2, "Exempt"), '(3, "Not approved")] +type TRuleContent566 = 'GContextFree TContent568 +type TVariation918 = 'GElement 5 2 TRuleContent566 +type TRuleVariation887 = 'GContextFree TVariation918 +type TNonSpare1778 = 'GNonSpare "RVSM" "" TRuleVariation887 +type TItem907 = 'GItem TNonSpare1778 +type TVariation1020 = 'GElement 7 1 TRuleContent401 +type TRuleVariation989 = 'GContextFree TVariation1020 +type TNonSpare1156 = 'GNonSpare "HPR" "" TRuleVariation989 +type TItem424 = 'GItem TNonSpare1156 +type TVariation1082 = 'GGroup 0 '[ TItem4, TItem907, TItem424] +type TRuleVariation1049 = 'GContextFree TVariation1082 +type TNonSpare1775 = 'GNonSpare "RVP" "RVSM & Flight Priority" TRuleVariation1049 +type TVariation217 = 'GElement 0 8 TRuleContent634 +type TRuleVariation209 = 'GContextFree TVariation217 +type TNonSpare1500 = 'GNonSpare "NU1" "First Number" TRuleVariation209 +type TItem695 = 'GItem TNonSpare1500 +type TNonSpare1501 = 'GNonSpare "NU2" "Second Number" TRuleVariation209 +type TItem696 = 'GItem TNonSpare1501 +type TNonSpare1284 = 'GNonSpare "LTR" "Letter" TRuleVariation209 +type TItem536 = 'GItem TNonSpare1284 +type TVariation1214 = 'GGroup 0 '[ TItem695, TItem696, TItem536] +type TRuleVariation1162 = 'GContextFree TVariation1214 +type TNonSpare1696 = 'GNonSpare "RDS" "Runway Designation" TRuleVariation1162 +type TContent477 = 'GContentTable '[ '(0, "Scheduled Off-Block Time"), '(1, "Estimated Off-Block Time"), '(2, "Estimated Take-Off Time"), '(3, "Actual Off-Block Time"), '(4, "Predicted Time at Runway Hold"), '(5, "Actual Time at Runway Hold"), '(6, "Actual Line-Up Time"), '(7, "Actual Take-Off Time"), '(8, "Estimated Time of Arrival"), '(9, "Predicted Landing Time"), '(10, "Actual Landing Time"), '(11, "Actual Time off Runway"), '(12, "Predicted Time to Gate"), '(13, "Actual On-Block Time")] +type TRuleContent475 = 'GContextFree TContent477 +type TVariation153 = 'GElement 0 5 TRuleContent475 +type TRuleVariation153 = 'GContextFree TVariation153 +type TNonSpare2134 = 'GNonSpare "TYP" "" TRuleVariation153 +type TItem1164 = 'GItem TNonSpare2134 +type TContent534 = 'GContentTable '[ '(0, "Today"), '(1, "Yesterday"), '(2, "Tomorrow"), '(3, "Invalid")] +type TRuleContent532 = 'GContextFree TContent534 +type TVariation915 = 'GElement 5 2 TRuleContent532 +type TRuleVariation884 = 'GContextFree TVariation915 +type TNonSpare932 = 'GNonSpare "DAY" "" TRuleVariation884 +type TItem258 = 'GItem TNonSpare932 +type TNonSpare1151 = 'GNonSpare "HOR" "" TRuleVariation709 +type TItem420 = 'GItem TNonSpare1151 +type TNonSpare1395 = 'GNonSpare "MIN" "" TRuleVariation609 +type TItem601 = 'GItem TNonSpare1395 +type TNonSpare704 = 'GNonSpare "AVS" "" TRuleVariation78 +type TItem98 = 'GItem TNonSpare704 +type TNonSpare1840 = 'GNonSpare "SEC" "" TRuleVariation609 +type TItem942 = 'GItem TNonSpare1840 +type TVariation1298 = 'GGroup 0 '[ TItem1164, TItem258, TItem30, TItem420, TItem1, TItem601, TItem98, TItem7, TItem942] +type TVariation1519 = 'GRepetitive ('GRepetitiveRegular 1) TVariation1298 +type TRuleVariation1435 = 'GContextFree TVariation1519 +type TNonSpare2049 = 'GNonSpare "TOD" "Time of Departure / Arrival" TRuleVariation1435 +type TContent212 = 'GContentTable '[ '(0, "Empty"), '(1, "Occupied"), '(2, "Unknown"), '(3, "Invalid")] +type TRuleContent212 = 'GContextFree TContent212 +type TVariation108 = 'GElement 0 2 TRuleContent212 +type TRuleVariation108 = 'GContextFree TVariation108 +type TNonSpare1001 = 'GNonSpare "EMP" "" TRuleVariation108 +type TItem309 = 'GItem TNonSpare1001 +type TContent48 = 'GContentTable '[ '(0, "Available"), '(1, "Not available"), '(2, "Unknown"), '(3, "Invalid")] +type TRuleContent48 = 'GContextFree TContent48 +type TVariation607 = 'GElement 2 2 TRuleContent48 +type TRuleVariation595 = 'GContextFree TVariation607 +type TNonSpare702 = 'GNonSpare "AVL" "" TRuleVariation595 +type TItem96 = 'GItem TNonSpare702 +type TVariation1138 = 'GGroup 0 '[ TItem309, TItem96, TItem22] +type TRuleVariation1091 = 'GContextFree TVariation1138 +type TNonSpare1960 = 'GNonSpare "STS" "Stand Status" TRuleVariation1091 +type TNonSpare1856 = 'GNonSpare "SID" "Standard Instrument Departure" TRuleVariation398 +type TNonSpare1933 = 'GNonSpare "STAR" "Standard Instrument Arrival" TRuleVariation398 +type TVariation1576 = 'GCompound '[ 'Just TNonSpare1195, 'Just TNonSpare1775, 'Just TNonSpare1696, 'Just TNonSpare2049, 'Just TNonSpare692, 'Just TNonSpare1960, 'Just TNonSpare1856, 'Just TNonSpare1933] +type TRuleVariation1492 = 'GContextFree TVariation1576 +type TNonSpare567 = 'GNonSpare "500" "Supplementary Flight Data" TRuleVariation1492 +type TUapItem565 = 'GUapItem TNonSpare567 +type TRecord59 = 'GRecord '[ TUapItem50, TUapItem70, TUapItem74, TUapItem136, TUapItem93, TUapItem156, TUapItem176, TUapItem210, TUapItem536, TUapItem544, TUapItem548, TUapItem553, TUapItem555, TUapItem559, TUapItem560, TUapItem551, TUapItem552, TUapItem557, TUapItem565, TUapItem598, TUapItem594] +type TUap53 = 'GUap TRecord59 +type TAsterix43 = 'GAsterixBasic 32 ('GEdition 1 1) TUap53 +type TContent255 = 'GContentTable '[ '(0, "Invalid ASTERIX value"), '(1, "Information sent by an FPPS"), '(2, "SUC information sent by an FDPS")] +type TRuleContent254 = 'GContextFree TContent255 +type TVariation142 = 'GElement 0 4 TRuleContent254 +type TRuleVariation142 = 'GContextFree TVariation142 +type TNonSpare1043 = 'GNonSpare "FAMILY" "" TRuleVariation142 +type TItem348 = 'GItem TNonSpare1043 +type TContent254 = 'GContentTable '[ '(0, "Invalid ASTERIX value"), '(1, "Flight Plan to track initial correlation"), '(2, "Miniplan update"), '(3, "End of correlation"), '(4, "Miniplan Cancellation"), '(5, "Retained Miniplan")] +type TContent256 = 'GContentTable '[ '(0, "Invalid ASTERIX value"), '(1, "Initial SUC correlation"), '(2, "End of SUC correlation"), '(3, "Change of SUC correlation information")] +type TRuleContent829 = 'GDependent '[ '[ "035", "FAMILY"]] TContent0 '[ '( '[ 1], TContent254), '( '[ 2], TContent256)] +type TVariation835 = 'GElement 4 4 TRuleContent829 +type TRuleVariation804 = 'GContextFree TVariation835 +type TNonSpare1460 = 'GNonSpare "NATURE" "" TRuleVariation804 +type TItem658 = 'GItem TNonSpare1460 +type TVariation1159 = 'GGroup 0 '[ TItem348, TItem658] +type TRuleVariation1112 = 'GContextFree TVariation1159 +type TNonSpare135 = 'GNonSpare "035" "Type of Message" TRuleVariation1112 +type TUapItem135 = 'GUapItem TNonSpare135 +type TRecord58 = 'GRecord '[ TUapItem50, TUapItem70, TUapItem74, TUapItem135, TUapItem93, TUapItem156, TUapItem176, TUapItem210, TUapItem536, TUapItem544, TUapItem548, TUapItem553, TUapItem555, TUapItem559, TUapItem560, TUapItem551, TUapItem552, TUapItem557, TUapItem565, TUapItem598, TUapItem594] +type TUap52 = 'GUap TRecord58 +type TAsterix44 = 'GAsterixBasic 32 ('GEdition 1 2) TUap52 +type TNonSpare35 = 'GNonSpare "010" "Data Source Identifier" TRuleVariation1196 +type TUapItem35 = 'GUapItem TNonSpare35 +type TContent614 = 'GContentTable '[ '(1, "North marker message"), '(2, "Sector crossing message"), '(3, "Geographical filtering message"), '(4, "Jamming strobe message")] +type TRuleContent612 = 'GContextFree TContent614 +type TVariation201 = 'GElement 0 8 TRuleContent612 +type TRuleVariation193 = 'GContextFree TVariation201 +type TNonSpare4 = 'GNonSpare "000" "Message Type" TRuleVariation193 +type TUapItem4 = 'GUapItem TNonSpare4 +type TNonSpare111 = 'GNonSpare "030" "Time of Day" TRuleVariation376 +type TUapItem111 = 'GUapItem TNonSpare111 +type TNonSpare82 = 'GNonSpare "020" "Sector Number" TRuleVariation249 +type TUapItem82 = 'GUapItem TNonSpare82 +type TNonSpare159 = 'GNonSpare "041" "Antenna Rotation Speed" TRuleVariation340 +type TUapItem159 = 'GUapItem TNonSpare159 +type TContent485 = 'GContentTable '[ '(0, "System is released for operational use"), '(1, "Operational use of System is inhibited, i.e. the data shall be discarded by an operational SDPS")] +type TRuleContent483 = 'GContextFree TContent485 +type TVariation81 = 'GElement 0 1 TRuleContent483 +type TRuleVariation81 = 'GContextFree TVariation81 +type TNonSpare1485 = 'GNonSpare "NOGO" "Operational Release Status of the System" TRuleVariation81 +type TItem681 = 'GItem TNonSpare1485 +type TContent457 = 'GContentTable '[ '(0, "RDPC-1 selected"), '(1, "RDPC-2 selected")] +type TRuleContent455 = 'GContextFree TContent457 +type TVariation465 = 'GElement 1 1 TRuleContent455 +type TRuleVariation453 = 'GContextFree TVariation465 +type TNonSpare1693 = 'GNonSpare "RDPC" "Radar Data Processor Chain Selection Status" TRuleVariation453 +type TItem849 = 'GItem TNonSpare1693 +type TContent176 = 'GContentTable '[ '(0, "Default situation"), '(1, "Reset of RDPC")] +type TRuleContent176 = 'GContextFree TContent176 +type TVariation544 = 'GElement 2 1 TRuleContent176 +type TRuleVariation532 = 'GContextFree TVariation544 +type TNonSpare1694 = 'GNonSpare "RDPR" "Event to Signal a Reset/restart of the Selected Radar Data Processor Chain, I.e. Expect a New Assignment of Track Numbers" TRuleVariation532 +type TItem850 = 'GItem TNonSpare1694 +type TContent204 = 'GContentTable '[ '(0, "Default, no overload"), '(1, "Overload in RDP")] +type TRuleContent204 = 'GContextFree TContent204 +type TVariation658 = 'GElement 3 1 TRuleContent204 +type TRuleVariation646 = 'GContextFree TVariation658 +type TNonSpare1529 = 'GNonSpare "OVLRDP" "Radar Data Processor Overload Indicator" TRuleVariation646 +type TItem723 = 'GItem TNonSpare1529 +type TVariation745 = 'GElement 4 1 TRuleContent205 +type TRuleVariation733 = 'GContextFree TVariation745 +type TNonSpare1532 = 'GNonSpare "OVLXMT" "Transmission Subsystem Overload Status" TRuleVariation733 +type TItem726 = 'GItem TNonSpare1532 +type TContent307 = 'GContentTable '[ '(0, "Monitoring system connected"), '(1, "Monitoring system disconnected")] +type TRuleContent305 = 'GContextFree TContent307 +type TVariation892 = 'GElement 5 1 TRuleContent305 +type TRuleVariation861 = 'GContextFree TVariation892 +type TNonSpare1438 = 'GNonSpare "MSC" "Monitoring System Connected Status" TRuleVariation861 +type TItem639 = 'GItem TNonSpare1438 +type TVariation990 = 'GElement 6 1 TRuleContent583 +type TRuleVariation959 = 'GContextFree TVariation990 +type TNonSpare2114 = 'GNonSpare "TSV" "Time Source Validity" TRuleVariation959 +type TItem1147 = 'GItem TNonSpare2114 +type TVariation1211 = 'GGroup 0 '[ TItem681, TItem849, TItem850, TItem723, TItem726, TItem639, TItem1147, TItem29] +type TRuleVariation1159 = 'GContextFree TVariation1211 +type TNonSpare849 = 'GNonSpare "COM" "Common Part" TRuleVariation1159 +type TContent37 = 'GContentTable '[ '(0, "Antenna 1"), '(1, "Antenna 2")] +type TRuleContent37 = 'GContextFree TContent37 +type TVariation13 = 'GElement 0 1 TRuleContent37 +type TRuleVariation13 = 'GContextFree TVariation13 +type TNonSpare664 = 'GNonSpare "ANT" "Selected Antenna" TRuleVariation13 +type TItem78 = 'GItem TNonSpare664 +type TContent349 = 'GContentTable '[ '(0, "No channel selected"), '(1, "Channel A only selected"), '(2, "Channel B only selected"), '(3, "Diversity mode ; Channel A and B selected")] +type TRuleContent347 = 'GContextFree TContent349 +type TVariation488 = 'GElement 1 2 TRuleContent347 +type TRuleVariation476 = 'GContextFree TVariation488 +type TNonSpare795 = 'GNonSpare "CHAB" "Channel A/B Selection Status" TRuleVariation476 +type TItem165 = 'GItem TNonSpare795 +type TVariation674 = 'GElement 3 1 TRuleContent385 +type TRuleVariation662 = 'GContextFree TVariation674 +type TNonSpare1526 = 'GNonSpare "OVL" "Overload Condition" TRuleVariation662 +type TItem720 = 'GItem TNonSpare1526 +type TVariation760 = 'GElement 4 1 TRuleContent305 +type TRuleVariation748 = 'GContextFree TVariation760 +type TNonSpare1437 = 'GNonSpare "MSC" "Monitoring System Connected Status" TRuleVariation748 +type TItem638 = 'GItem TNonSpare1437 +type TVariation1093 = 'GGroup 0 '[ TItem78, TItem165, TItem720, TItem638, TItem25] +type TRuleVariation1059 = 'GContextFree TVariation1093 +type TNonSpare1604 = 'GNonSpare "PSR" "Specific Status Information for a PSR Sensor" TRuleVariation1059 +type TContent351 = 'GContentTable '[ '(0, "No channel selected"), '(1, "Channel A only selected"), '(2, "Channel B only selected"), '(3, "Invalid combination")] +type TRuleContent349 = 'GContextFree TContent351 +type TVariation490 = 'GElement 1 2 TRuleContent349 +type TRuleVariation478 = 'GContextFree TVariation490 +type TNonSpare797 = 'GNonSpare "CHAB" "Channel A/B Selection Status" TRuleVariation478 +type TItem167 = 'GItem TNonSpare797 +type TNonSpare1439 = 'GNonSpare "MSC" "Monitoring System Connected Status:" TRuleVariation748 +type TItem640 = 'GItem TNonSpare1439 +type TVariation1095 = 'GGroup 0 '[ TItem78, TItem167, TItem720, TItem640, TItem25] +type TRuleVariation1061 = 'GContextFree TVariation1095 +type TNonSpare1926 = 'GNonSpare "SSR" "Specific Status Information for a SSR Sensor" TRuleVariation1061 +type TContent350 = 'GContentTable '[ '(0, "No channel selected"), '(1, "Channel A only selected"), '(2, "Channel B only selected"), '(3, "Illegal combination")] +type TRuleContent348 = 'GContextFree TContent350 +type TVariation489 = 'GElement 1 2 TRuleContent348 +type TRuleVariation477 = 'GContextFree TVariation489 +type TNonSpare796 = 'GNonSpare "CHAB" "Channel A/B Selection Status" TRuleVariation477 +type TItem166 = 'GItem TNonSpare796 +type TNonSpare1531 = 'GNonSpare "OVLSUR" "Overload Condition" TRuleVariation662 +type TItem725 = 'GItem TNonSpare1531 +type TContent58 = 'GContentTable '[ '(0, "Channel A in use"), '(1, "Channel B in use")] +type TRuleContent58 = 'GContextFree TContent58 +type TVariation855 = 'GElement 5 1 TRuleContent58 +type TRuleVariation824 = 'GContextFree TVariation855 +type TNonSpare1810 = 'GNonSpare "SCF" "Channel A/B Selection Status for Surveillance Co-ordination Function" TRuleVariation824 +type TItem928 = 'GItem TNonSpare1810 +type TVariation934 = 'GElement 6 1 TRuleContent58 +type TRuleVariation903 = 'GContextFree TVariation934 +type TNonSpare956 = 'GNonSpare "DLF" "Channel A/B Selection Status for Data Link Function" TRuleVariation903 +type TItem281 = 'GItem TNonSpare956 +type TVariation1019 = 'GElement 7 1 TRuleContent385 +type TRuleVariation988 = 'GContextFree TVariation1019 +type TNonSpare1530 = 'GNonSpare "OVLSCF" "Overload in Surveillance Co-ordination Function" TRuleVariation988 +type TItem724 = 'GItem TNonSpare1530 +type TVariation65 = 'GElement 0 1 TRuleContent385 +type TRuleVariation65 = 'GContextFree TVariation65 +type TNonSpare1528 = 'GNonSpare "OVLDLF" "Overload in Data Link Function" TRuleVariation65 +type TItem722 = 'GItem TNonSpare1528 +type TVariation1094 = 'GGroup 0 '[ TItem78, TItem166, TItem725, TItem640, TItem928, TItem281, TItem724, TItem722, TItem10] +type TRuleVariation1060 = 'GContextFree TVariation1094 +type TNonSpare1371 = 'GNonSpare "MDS" "Specific Status Information for a Mode S Sensor" TRuleVariation1060 +type TVariation1566 = 'GCompound '[ 'Just TNonSpare849, 'Nothing, 'Nothing, 'Just TNonSpare1604, 'Just TNonSpare1926, 'Just TNonSpare1371] +type TRuleVariation1482 = 'GContextFree TVariation1566 +type TNonSpare189 = 'GNonSpare "050" "System Configuration and Status" TRuleVariation1482 +type TUapItem189 = 'GUapItem TNonSpare189 +type TContent388 = 'GContentTable '[ '(0, "No reduction active"), '(1, "Reduction step 1 active"), '(2, "Reduction step 2 active"), '(3, "Reduction step 3 active"), '(4, "Reduction step 4 active"), '(5, "Reduction step 5 active"), '(6, "Reduction step 6 active"), '(7, "Reduction step 7 active")] +type TRuleContent386 = 'GContextFree TContent388 +type TVariation502 = 'GElement 1 3 TRuleContent386 +type TRuleVariation490 = 'GContextFree TVariation502 +type TNonSpare1707 = 'GNonSpare "REDRDP" "Reduction Steps in Use for An Overload of the RDP" TRuleVariation490 +type TItem859 = 'GItem TNonSpare1707 +type TVariation815 = 'GElement 4 3 TRuleContent386 +type TRuleVariation793 = 'GContextFree TVariation815 +type TNonSpare1708 = 'GNonSpare "REDXMT" "Reduction Steps in Use for An Overload of the Transmission Subsystem" TRuleVariation793 +type TItem860 = 'GItem TNonSpare1708 +type TVariation1034 = 'GGroup 0 '[ TItem0, TItem859, TItem860, TItem29] +type TRuleVariation1003 = 'GContextFree TVariation1034 +type TNonSpare848 = 'GNonSpare "COM" "Common Part" TRuleVariation1003 +type TContent268 = 'GContentTable '[ '(0, "Linear polarization"), '(1, "Circular polarization")] +type TRuleContent266 = 'GContextFree TContent268 +type TVariation53 = 'GElement 0 1 TRuleContent266 +type TRuleVariation53 = 'GContextFree TVariation53 +type TNonSpare1563 = 'GNonSpare "POL" "Polarization in Use by PSR" TRuleVariation53 +type TItem746 = 'GItem TNonSpare1563 +type TNonSpare1705 = 'GNonSpare "REDRAD" "Reduction Steps in Use as Result of An Overload Within the PSR Subsystem" TRuleVariation490 +type TItem857 = 'GItem TNonSpare1705 +type TContent475 = 'GContentTable '[ '(0, "STC Map-1"), '(1, "STC Map-2"), '(2, "STC Map-3"), '(3, "STC Map-4")] +type TRuleContent473 = 'GContextFree TContent475 +type TVariation795 = 'GElement 4 2 TRuleContent473 +type TRuleVariation783 = 'GContextFree TVariation795 +type TNonSpare1948 = 'GNonSpare "STC" "Sensitivity Time Control Map in Use" TRuleVariation783 +type TItem1028 = 'GItem TNonSpare1948 +type TVariation1219 = 'GGroup 0 '[ TItem746, TItem857, TItem1028, TItem27] +type TRuleVariation1165 = 'GContextFree TVariation1219 +type TNonSpare1603 = 'GNonSpare "PSR" "Specific Processing Mode Information for a PSR Sensor" TRuleVariation1165 +type TVariation137 = 'GElement 0 3 TRuleContent386 +type TRuleVariation137 = 'GContextFree TVariation137 +type TNonSpare1706 = 'GNonSpare "REDRAD" "Reduction Steps in Use as Result of An Overload Within the SSR Subsystem" TRuleVariation137 +type TItem858 = 'GItem TNonSpare1706 +type TVariation1237 = 'GGroup 0 '[ TItem858, TItem19] +type TRuleVariation1183 = 'GContextFree TVariation1237 +type TNonSpare1925 = 'GNonSpare "SSR" "Specific Processing Mode Information for a SSR Sensor" TRuleVariation1183 +type TNonSpare1704 = 'GNonSpare "REDRAD" "Reduction Steps in Use as Result of An Overload Within the Mode S Subsystem" TRuleVariation137 +type TItem856 = 'GItem TNonSpare1704 +type TContent45 = 'GContentTable '[ '(0, "Autonomous"), '(1, "Not autonomous")] +type TRuleContent45 = 'GContextFree TContent45 +type TVariation638 = 'GElement 3 1 TRuleContent45 +type TRuleVariation626 = 'GContextFree TVariation638 +type TNonSpare810 = 'GNonSpare "CLU" "Cluster State" TRuleVariation626 +type TItem177 = 'GItem TNonSpare810 +type TVariation1236 = 'GGroup 0 '[ TItem856, TItem177, TItem22] +type TRuleVariation1182 = 'GContextFree TVariation1236 +type TNonSpare1370 = 'GNonSpare "MDS" "Specific Processing Mode Information for a Mode S Sensor" TRuleVariation1182 +type TVariation1565 = 'GCompound '[ 'Just TNonSpare848, 'Nothing, 'Nothing, 'Just TNonSpare1603, 'Just TNonSpare1925, 'Just TNonSpare1370] +type TRuleVariation1481 = 'GContextFree TVariation1565 +type TNonSpare209 = 'GNonSpare "060" "System Processing Mode" TRuleVariation1481 +type TUapItem209 = 'GUapItem TNonSpare209 +type TContent365 = 'GContentTable '[ '(0, "No detection (number of misses)"), '(1, "Single PSR target reports"), '(2, "Single SSR target reports (Non-Mode S)"), '(3, "SSR+PSR target reports (Non-Mode S)"), '(4, "Single All-Call target reports (Mode S)"), '(5, "Single Roll-Call target reports (Mode S)"), '(6, "All-Call + PSR (Mode S) target reports"), '(7, "Roll-Call + PSR (Mode S) target reports"), '(8, "Filter for Weather data"), '(9, "Filter for Jamming Strobe"), '(10, "Filter for PSR data"), '(11, "Filter for SSR/Mode S data"), '(12, "Filter for SSR/Mode S+PSR data"), '(13, "Filter for Enhanced Surveillance data"), '(14, "Filter for PSR+Enhanced Surveillance"), '(15, "Filter for PSR+Enhanced Surveillance + SSR/Mode S data not in Area of Prime Interest"), '(16, "Filter for PSR+Enhanced Surveillance + all SSR/Mode S data")] +type TRuleContent363 = 'GContextFree TContent365 +type TVariation151 = 'GElement 0 5 TRuleContent363 +type TRuleVariation151 = 'GContextFree TVariation151 +type TNonSpare2142 = 'GNonSpare "TYP" "Type of Message Counter" TRuleVariation151 +type TItem1171 = 'GItem TNonSpare2142 +type TVariation925 = 'GElement 5 11 TRuleContent638 +type TRuleVariation894 = 'GContextFree TVariation925 +type TNonSpare867 = 'GNonSpare "COUNT" "COUNTER" TRuleVariation894 +type TItem214 = 'GItem TNonSpare867 +type TVariation1304 = 'GGroup 0 '[ TItem1171, TItem214] +type TVariation1522 = 'GRepetitive ('GRepetitiveRegular 1) TVariation1304 +type TRuleVariation1438 = 'GContextFree TVariation1522 +type TNonSpare216 = 'GNonSpare "070" "Message Count Values" TRuleVariation1438 +type TUapItem216 = 'GUapItem TNonSpare216 +type TContent804 = 'GContentQuantity 'GUnsigned ('GNumDiv ('GNumInt ('GZ 'GPlus 1)) ('GNumPow ('GZ 'GPlus 2) ('GZ 'GPlus 8))) "NM" +type TRuleContent801 = 'GContextFree TContent804 +type TVariation350 = 'GElement 0 16 TRuleContent801 +type TRuleVariation342 = 'GContextFree TVariation350 +type TNonSpare1729 = 'GNonSpare "RHOST" "Rho Start" TRuleVariation342 +type TItem880 = 'GItem TNonSpare1729 +type TNonSpare1728 = 'GNonSpare "RHOEND" "Rho End" TRuleVariation342 +type TItem879 = 'GItem TNonSpare1728 +type TNonSpare2024 = 'GNonSpare "THETAST" "Theta Start" TRuleVariation349 +type TItem1080 = 'GItem TNonSpare2024 +type TNonSpare2023 = 'GNonSpare "THETAEND" "Theta End" TRuleVariation349 +type TItem1079 = 'GItem TNonSpare2023 +type TVariation1242 = 'GGroup 0 '[ TItem880, TItem879, TItem1080, TItem1079] +type TRuleVariation1188 = 'GContextFree TVariation1242 +type TNonSpare285 = 'GNonSpare "100" "Generic Polar Window" TRuleVariation1188 +type TUapItem285 = 'GUapItem TNonSpare285 +type TContent257 = 'GContentTable '[ '(0, "Invalid value"), '(1, "Filter for Weather data"), '(2, "Filter for Jamming Strobe"), '(3, "Filter for PSR data"), '(4, "Filter for SSR/Mode S data"), '(5, "Filter for SSR/Mode S + PSR data"), '(6, "Enhanced Surveillance data"), '(7, "Filter for PSR+Enhanced Surveillance data"), '(8, "Filter for PSR+Enhanced Surveillance + SSR/Mode S data not in Area of Prime Interest"), '(9, "Filter for PSR+Enhanced Surveillance + all SSR/Mode S data")] +type TRuleContent255 = 'GContextFree TContent257 +type TVariation182 = 'GElement 0 8 TRuleContent255 +type TRuleVariation175 = 'GContextFree TVariation182 +type TNonSpare300 = 'GNonSpare "110" "Data Filter" TRuleVariation175 +type TUapItem300 = 'GUapItem TNonSpare300 +type TVariation272 = 'GElement 0 16 TRuleContent651 +type TRuleVariation264 = 'GContextFree TVariation272 +type TNonSpare1146 = 'GNonSpare "HGT" "Height of Data Source" TRuleVariation264 +type TItem416 = 'GItem TNonSpare1146 +type TContent722 = 'GContentQuantity 'GSigned ('GNumDiv ('GNumInt ('GZ 'GPlus 180)) ('GNumPow ('GZ 'GPlus 2) ('GZ 'GPlus 23))) "°" +type TRuleContent720 = 'GContextFree TContent722 +type TVariation373 = 'GElement 0 24 TRuleContent720 +type TRuleVariation365 = 'GContextFree TVariation373 +type TNonSpare1263 = 'GNonSpare "LON" "Longitude" TRuleVariation365 +type TItem517 = 'GItem TNonSpare1263 +type TVariation1172 = 'GGroup 0 '[ TItem416, TItem486, TItem517] +type TRuleVariation1125 = 'GContextFree TVariation1172 +type TNonSpare311 = 'GNonSpare "120" "3D-Position Of Data Source" TRuleVariation1125 +type TUapItem311 = 'GUapItem TNonSpare311 +type TNonSpare1736 = 'GNonSpare "RNG" "Range Error" TRuleVariation221 +type TItem886 = 'GItem TNonSpare1736 +type TNonSpare720 = 'GNonSpare "AZM" "Azimuth Error" TRuleVariation226 +type TItem111 = 'GItem TNonSpare720 +type TVariation1244 = 'GGroup 0 '[ TItem886, TItem111] +type TRuleVariation1189 = 'GContextFree TVariation1244 +type TNonSpare258 = 'GNonSpare "090" "Collimation Error" TRuleVariation1189 +type TUapItem258 = 'GUapItem TNonSpare258 +type TRecord17 = 'GRecord '[ TUapItem35, TUapItem4, TUapItem111, TUapItem82, TUapItem159, TUapItem189, TUapItem209, TUapItem216, TUapItem285, TUapItem300, TUapItem311, TUapItem258, TUapItem594, TUapItem596] +type TUap17 = 'GUap TRecord17 +type TAsterix45 = 'GAsterixBasic 34 ('GEdition 1 27) TUap17 +type TContent615 = 'GContentTable '[ '(1, "North marker message"), '(2, "Sector crossing message"), '(3, "Geographical filtering message"), '(4, "Jamming strobe message"), '(5, "Solar Storm Message")] +type TRuleContent613 = 'GContextFree TContent615 +type TVariation202 = 'GElement 0 8 TRuleContent613 +type TRuleVariation194 = 'GContextFree TVariation202 +type TNonSpare5 = 'GNonSpare "000" "Message Type" TRuleVariation194 +type TUapItem5 = 'GUapItem TNonSpare5 +type TContent366 = 'GContentTable '[ '(0, "No detection (number of misses)"), '(1, "Single PSR target reports"), '(2, "Single SSR target reports (Non-Mode S)"), '(3, "SSR+PSR target reports (Non-Mode S)"), '(4, "Single All-Call target reports (Mode S)"), '(5, "Single Roll-Call target reports (Mode S)"), '(6, "All-Call + PSR (Mode S) target reports"), '(7, "Roll-Call + PSR (Mode S) target reports"), '(8, "Filter for Weather data"), '(9, "Filter for Jamming Strobe"), '(10, "Filter for PSR data"), '(11, "Filter for SSR/Mode S data"), '(12, "Filter for SSR/Mode S+PSR data"), '(13, "Filter for Enhanced Surveillance data"), '(14, "Filter for PSR+Enhanced Surveillance"), '(15, "Filter for PSR+Enhanced Surveillance + SSR/Mode S data not in Area of Prime Interest"), '(16, "Filter for PSR+Enhanced Surveillance + all SSR/Mode S data"), '(17, "Re-Interrogations (per sector)"), '(18, "BDS Swap and wrong DF replies(per sector)"), '(19, "Mode A/C FRUIT (per sector)"), '(20, "Mode S FRUIT (per sector)")] +type TRuleContent364 = 'GContextFree TContent366 +type TVariation152 = 'GElement 0 5 TRuleContent364 +type TRuleVariation152 = 'GContextFree TVariation152 +type TNonSpare2143 = 'GNonSpare "TYP" "Type of Message Counter" TRuleVariation152 +type TItem1172 = 'GItem TNonSpare2143 +type TVariation1305 = 'GGroup 0 '[ TItem1172, TItem214] +type TVariation1523 = 'GRepetitive ('GRepetitiveRegular 1) TVariation1305 +type TRuleVariation1439 = 'GContextFree TVariation1523 +type TNonSpare217 = 'GNonSpare "070" "Message Count Values" TRuleVariation1439 +type TUapItem217 = 'GUapItem TNonSpare217 +type TRecord18 = 'GRecord '[ TUapItem35, TUapItem5, TUapItem111, TUapItem82, TUapItem159, TUapItem189, TUapItem209, TUapItem217, TUapItem285, TUapItem300, TUapItem311, TUapItem258, TUapItem594, TUapItem596] +type TUap18 = 'GUap TRecord18 +type TAsterix46 = 'GAsterixBasic 34 ('GEdition 1 28) TUap18 +type TContent616 = 'GContentTable '[ '(1, "North marker message"), '(2, "Sector crossing message"), '(3, "Geographical filtering message"), '(4, "Jamming strobe message"), '(5, "Solar Storm Message"), '(6, "SSR Jamming Strobe Message"), '(7, "Mode S Jamming Strobe Message")] +type TRuleContent614 = 'GContextFree TContent616 +type TVariation203 = 'GElement 0 8 TRuleContent614 +type TRuleVariation195 = 'GContextFree TVariation203 +type TNonSpare6 = 'GNonSpare "000" "Message Type" TRuleVariation195 +type TUapItem6 = 'GUapItem TNonSpare6 +type TRecord19 = 'GRecord '[ TUapItem35, TUapItem6, TUapItem111, TUapItem82, TUapItem159, TUapItem189, TUapItem209, TUapItem217, TUapItem285, TUapItem300, TUapItem311, TUapItem258, TUapItem594, TUapItem596] +type TUap19 = 'GUap TRecord19 +type TAsterix47 = 'GAsterixBasic 34 ('GEdition 1 29) TUap19 +type TContent342 = 'GContentTable '[ '(0, "No authenticated Mode 5 Data reply/report"), '(1, "Authenticated Mode 5 Data reply/report (i.e any valid Mode 5 reply type other than ID)")] +type TRuleContent340 = 'GContextFree TContent342 +type TVariation579 = 'GElement 2 1 TRuleContent340 +type TRuleVariation567 = 'GContextFree TVariation579 +type TNonSpare926 = 'GNonSpare "DA" "" TRuleVariation567 +type TItem254 = 'GItem TNonSpare926 +type TContent292 = 'GContentTable '[ '(0, "Mode C altitude not present or not from Mode 5 reply/report"), '(1, "Mode C altitude from Mode 5 reply/report")] +type TRuleContent290 = 'GContextFree TContent292 +type TVariation971 = 'GElement 6 1 TRuleContent290 +type TRuleVariation940 = 'GContextFree TVariation971 +type TNonSpare1342 = 'GNonSpare "MC" "" TRuleVariation940 +type TItem579 = 'GItem TNonSpare1342 +type TVariation1199 = 'GGroup 0 '[ TItem558, TItem450, TItem254, TItem543, TItem546, TItem550, TItem579, TItem29] +type TRuleVariation1150 = 'GContextFree TVariation1199 +type TNonSpare1972 = 'GNonSpare "SUM" "Mode 5 Summary" TRuleVariation1150 +type TContent314 = 'GContentTable '[ '(0, "National Origin is valid"), '(1, "National Origin is invalid")] +type TRuleContent312 = 'GContextFree TContent314 +type TVariation575 = 'GElement 2 1 TRuleContent312 +type TRuleVariation563 = 'GContextFree TVariation575 +type TNonSpare1465 = 'GNonSpare "NAV" "Validity of NAT" TRuleVariation563 +type TItem661 = 'GItem TNonSpare1465 +type TVariation1043 = 'GGroup 0 '[ TItem1, TItem739, TItem1, TItem661, TItem656, TItem1, TItem604] +type TRuleVariation1012 = 'GContextFree TVariation1043 +type TNonSpare1554 = 'GNonSpare "PMN" "PIN/ National Origin/Mission Code" TRuleVariation1012 +type TContent725 = 'GContentQuantity 'GSigned ('GNumDiv ('GNumInt ('GZ 'GPlus 180)) ('GNumPow ('GZ 'GPlus 2) ('GZ 'GPlus 23))) "°" +type TRuleContent723 = 'GContextFree TContent725 +type TVariation376 = 'GElement 0 24 TRuleContent723 +type TRuleVariation368 = 'GContextFree TVariation376 +type TNonSpare1237 = 'GNonSpare "LAT" "Latitude in WGS 84" TRuleVariation368 +type TItem493 = 'GItem TNonSpare1237 +type TContent724 = 'GContentQuantity 'GSigned ('GNumDiv ('GNumInt ('GZ 'GPlus 180)) ('GNumPow ('GZ 'GPlus 2) ('GZ 'GPlus 23))) "°" +type TRuleContent722 = 'GContextFree TContent724 +type TVariation375 = 'GElement 0 24 TRuleContent722 +type TRuleVariation367 = 'GContextFree TVariation375 +type TNonSpare1270 = 'GNonSpare "LON" "Longitude in WGS 84" TRuleVariation367 +type TItem524 = 'GItem TNonSpare1270 +type TVariation1189 = 'GGroup 0 '[ TItem493, TItem524] +type TRuleVariation1140 = 'GContextFree TVariation1189 +type TNonSpare1568 = 'GNonSpare "POS" "Mode 5 Reported Position" TRuleVariation1140 +type TNonSpare1717 = 'GNonSpare "RES" "" TRuleVariation429 +type TItem868 = 'GItem TNonSpare1717 +type TNonSpare1088 = 'GNonSpare "GA" "" TRuleVariation613 +type TItem380 = 'GItem TNonSpare1088 +type TVariation1035 = 'GGroup 0 '[ TItem0, TItem868, TItem380] +type TRuleVariation1004 = 'GContextFree TVariation1035 +type TNonSpare1091 = 'GNonSpare "GA" "Mode 5 GNSS-derived Altitude" TRuleVariation1004 +type TContent281 = 'GContentTable '[ '(0, "Mode 1 Code derived from the reply of the transponder"), '(1, "Mode 1 Code not extracted during the last scan")] +type TRuleContent279 = 'GContextFree TContent281 +type TVariation560 = 'GElement 2 1 TRuleContent279 +type TRuleVariation548 = 'GContextFree TVariation560 +type TNonSpare1210 = 'GNonSpare "L" "" TRuleVariation548 +type TItem466 = 'GItem TNonSpare1210 +type TVariation1313 = 'GGroup 0 '[ TItem1190, TItem377, TItem466, TItem16, TItem307] +type TRuleVariation1237 = 'GContextFree TVariation1313 +type TNonSpare995 = 'GNonSpare "EM1" "Extended Mode 1 Code in Octal Representation" TRuleVariation1237 +type TVariation252 = 'GElement 0 8 TRuleContent797 +type TRuleVariation244 = 'GContextFree TVariation252 +type TNonSpare2055 = 'GNonSpare "TOS" "Time Offset for POS and GA" TRuleVariation244 +type TNonSpare2309 = 'GNonSpare "XP" "X-pulse from Mode 5 PIN Reply/Report" TRuleVariation590 +type TItem1321 = 'GItem TNonSpare2309 +type TVariation1050 = 'GGroup 0 '[ TItem1, TItem1321, TItem1317, TItem1320, TItem1316, TItem1314, TItem1310] +type TRuleVariation1019 = 'GContextFree TVariation1050 +type TNonSpare2306 = 'GNonSpare "XP" "X Pulse Presence" TRuleVariation1019 +type TVariation1597 = 'GCompound '[ 'Just TNonSpare1972, 'Just TNonSpare1554, 'Just TNonSpare1568, 'Just TNonSpare1091, 'Just TNonSpare995, 'Just TNonSpare2055, 'Just TNonSpare2306] +type TRuleVariation1513 = 'GContextFree TVariation1597 +type TNonSpare1356 = 'GNonSpare "MD5" "Mode 5 Reports" TRuleVariation1513 +type TNonSpare1973 = 'GNonSpare "SUM" "Mode 5 Summary" TRuleVariation1150 +type TVariation761 = 'GElement 4 1 TRuleContent312 +type TRuleVariation749 = 'GContextFree TVariation761 +type TNonSpare1495 = 'GNonSpare "NOV" "Validity of NO" TRuleVariation749 +type TItem691 = 'GItem TNonSpare1495 +type TNonSpare1477 = 'GNonSpare "NO" "National Origin" TRuleVariation893 +type TItem673 = 'GItem TNonSpare1477 +type TVariation1045 = 'GGroup 0 '[ TItem1, TItem739, TItem3, TItem691, TItem673] +type TRuleVariation1014 = 'GContextFree TVariation1045 +type TNonSpare1555 = 'GNonSpare "PMN" "PIN/ National Origin/Mission Code" TRuleVariation1014 +type TNonSpare1567 = 'GNonSpare "POS" "Mode 5 Reported Position" TRuleVariation1140 +type TNonSpare1718 = 'GNonSpare "RES" "" TRuleVariation429 +type TItem869 = 'GItem TNonSpare1718 +type TNonSpare1089 = 'GNonSpare "GA" "" TRuleVariation613 +type TItem381 = 'GItem TNonSpare1089 +type TVariation1036 = 'GGroup 0 '[ TItem0, TItem869, TItem381] +type TRuleVariation1005 = 'GContextFree TVariation1036 +type TNonSpare1092 = 'GNonSpare "GA" "Mode 5 GNSS-derived Altitude" TRuleVariation1005 +type TNonSpare1057 = 'GNonSpare "FOM" "" TRuleVariation708 +type TItem358 = 'GItem TNonSpare1057 +type TVariation1053 = 'GGroup 0 '[ TItem2, TItem358] +type TRuleVariation1022 = 'GContextFree TVariation1053 +type TNonSpare1059 = 'GNonSpare "FOM" "Figure of Merit" TRuleVariation1022 +type TVariation1598 = 'GCompound '[ 'Just TNonSpare1973, 'Just TNonSpare1555, 'Just TNonSpare1567, 'Just TNonSpare1092, 'Just TNonSpare995, 'Just TNonSpare2055, 'Just TNonSpare2306, 'Just TNonSpare1059] +type TRuleVariation1514 = 'GContextFree TVariation1598 +type TNonSpare1317 = 'GNonSpare "M5N" "Mode 5 Reports, New Format" TRuleVariation1514 +type TContent324 = 'GContentTable '[ '(0, "No Mode 4 interrogation"), '(1, "Possibly friendly target"), '(2, "Probably friendly target"), '(3, "Friendly target")] +type TRuleContent322 = 'GContextFree TContent324 +type TVariation911 = 'GElement 5 2 TRuleContent322 +type TRuleVariation880 = 'GContextFree TVariation911 +type TNonSpare1056 = 'GNonSpare "FOEFRI" "Indication Foe/Friend (Mode4)" TRuleVariation880 +type TItem357 = 'GItem TNonSpare1056 +type TVariation1415 = 'GExtended '[ 'Just TItem4, 'Just TItem357, 'Nothing] +type TRuleVariation1331 = 'GContextFree TVariation1415 +type TNonSpare1310 = 'GNonSpare "M4E" "Extended Mode 4 Report" TRuleVariation1331 +type TNonSpare1813 = 'GNonSpare "SCO" "Score" TRuleVariation211 +type TContent765 = 'GContentQuantity 'GUnsigned ('GNumDiv ('GNumInt ('GZ 'GPlus 1)) ('GNumInt ('GZ 'GPlus 10))) "dB" +type TRuleContent763 = 'GContextFree TContent765 +type TVariation327 = 'GElement 0 16 TRuleContent763 +type TRuleVariation319 = 'GContextFree TVariation327 +type TNonSpare1907 = 'GNonSpare "SRC" "Signal/Clutter Ratio" TRuleVariation319 +type TContent806 = 'GContentQuantity 'GUnsigned ('GNumDiv ('GNumInt ('GZ 'GPlus 1)) ('GNumPow ('GZ 'GPlus 2) ('GZ 'GPlus 8))) "NM" +type TRuleContent803 = 'GContextFree TContent806 +type TVariation351 = 'GElement 0 16 TRuleContent803 +type TRuleVariation343 = 'GContextFree TVariation351 +type TNonSpare1781 = 'GNonSpare "RW" "Range Width" TRuleVariation343 +type TNonSpare676 = 'GNonSpare "AR" "Ambiguous Range" TRuleVariation343 +type TVariation1590 = 'GCompound '[ 'Just TNonSpare1813, 'Just TNonSpare1907, 'Just TNonSpare1781, 'Just TNonSpare676] +type TRuleVariation1506 = 'GContextFree TVariation1590 +type TNonSpare1741 = 'GNonSpare "RPC" "Radar Plot Characteristics" TRuleVariation1506 +type TContent805 = 'GContentQuantity 'GUnsigned ('GNumDiv ('GNumInt ('GZ 'GPlus 1)) ('GNumPow ('GZ 'GPlus 2) ('GZ 'GPlus 8))) "NM" +type TRuleContent802 = 'GContextFree TContent805 +type TVariation386 = 'GElement 0 24 TRuleContent802 +type TRuleVariation378 = 'GContextFree TVariation386 +type TNonSpare1032 = 'GNonSpare "ERR" "Extended Range Report" TRuleVariation378 +type TContent536 = 'GContentTable '[ '(0, "Track is not associated with an SCN Plot"), '(1, "Track is associated with an SCN Plot")] +type TRuleContent534 = 'GContextFree TContent536 +type TVariation687 = 'GElement 3 1 TRuleContent534 +type TRuleVariation675 = 'GContextFree TVariation687 +type TNonSpare1812 = 'GNonSpare "SCN" "Track / SCN Association" TRuleVariation675 +type TItem930 = 'GItem TNonSpare1812 +type TContent42 = 'GContentTable '[ '(0, "Associated Plot does not contain a Roll Call component"), '(1, "Associated Plot contains at least a Roll Call component")] +type TRuleContent42 = 'GContextFree TContent42 +type TVariation726 = 'GElement 4 1 TRuleContent42 +type TRuleVariation714 = 'GContextFree TVariation726 +type TNonSpare1680 = 'GNonSpare "RC" "Roll Call Component" TRuleVariation714 +type TItem838 = 'GItem TNonSpare1680 +type TContent43 = 'GContentTable '[ '(0, "Associated Plot does not contain an All Call component"), '(1, "Associated Plot contains at least an All Call component")] +type TRuleContent43 = 'GContextFree TContent43 +type TVariation852 = 'GElement 5 1 TRuleContent43 +type TRuleVariation821 = 'GContextFree TVariation852 +type TNonSpare606 = 'GNonSpare "AC" "All Call Component" TRuleVariation821 +type TItem41 = 'GItem TNonSpare606 +type TContent44 = 'GContentTable '[ '(0, "Associated Plot does not contain an SSR component"), '(1, "Associated Plot contains at least an SSR component")] +type TRuleContent44 = 'GContextFree TContent44 +type TVariation933 = 'GElement 6 1 TRuleContent44 +type TRuleVariation902 = 'GContextFree TVariation933 +type TNonSpare1924 = 'GNonSpare "SSR" "SSR Component" TRuleVariation902 +type TItem1010 = 'GItem TNonSpare1924 +type TContent41 = 'GContentTable '[ '(0, "Associated Plot does not contain a PSR component"), '(1, "Associated Plot contains at least a PSR component")] +type TRuleContent41 = 'GContextFree TContent41 +type TVariation1008 = 'GElement 7 1 TRuleContent41 +type TRuleVariation977 = 'GContextFree TVariation1008 +type TNonSpare1602 = 'GNonSpare "PSR" "PSR Component" TRuleVariation977 +type TItem771 = 'GItem TNonSpare1602 +type TNonSpare1552 = 'GNonSpare "PLOTNR" "" TRuleVariation259 +type TItem741 = 'GItem TNonSpare1552 +type TVariation1056 = 'GGroup 0 '[ TItem2, TItem930, TItem838, TItem41, TItem1010, TItem771, TItem741] +type TRuleVariation1025 = 'GContextFree TVariation1056 +type TNonSpare1608 = 'GNonSpare "PTL" "Plot/Track Link" TRuleVariation1025 +type TVariation1472 = 'GRepetitive ('GRepetitiveRegular 1) TVariation267 +type TRuleVariation1388 = 'GContextFree TVariation1472 +type TNonSpare695 = 'GNonSpare "ATL" "ADS-B/Track Link" TRuleVariation1388 +type TContent739 = 'GContentQuantity 'GUnsigned ('GNumInt ('GZ 'GPlus 1)) "%" +type TRuleContent737 = 'GContextFree TContent739 +type TVariation235 = 'GElement 0 8 TRuleContent737 +type TRuleVariation227 = 'GContextFree TVariation235 +type TNonSpare2092 = 'GNonSpare "TRN" "Turn State" TRuleVariation227 +type TVariation344 = 'GElement 0 16 TRuleContent793 +type TRuleVariation336 = 'GContextFree TVariation344 +type TNonSpare1582 = 'GNonSpare "PREDRHO" "Predicted Range" TRuleVariation336 +type TItem757 = 'GItem TNonSpare1582 +type TNonSpare1583 = 'GNonSpare "PREDTHETA" "Predicted Azimuth" TRuleVariation349 +type TItem758 = 'GItem TNonSpare1583 +type TNonSpare1039 = 'GNonSpare "EVOLRHOSTART" "Predicted Closest Range" TRuleVariation336 +type TItem344 = 'GItem TNonSpare1039 +type TNonSpare1038 = 'GNonSpare "EVOLRHOEND" "Predicted Largest Range" TRuleVariation336 +type TItem343 = 'GItem TNonSpare1038 +type TNonSpare1041 = 'GNonSpare "EVOLTHETASTART" "Predicted Smallest Azimuth" TRuleVariation349 +type TItem346 = 'GItem TNonSpare1041 +type TNonSpare1040 = 'GNonSpare "EVOLTHETAEND" "Predicted Largest Azimuth" TRuleVariation349 +type TItem345 = 'GItem TNonSpare1040 +type TNonSpare1490 = 'GNonSpare "NOISERHOSTART" "Predicted Closest Range" TRuleVariation336 +type TItem686 = 'GItem TNonSpare1490 +type TNonSpare1489 = 'GNonSpare "NOISERHOEND" "Predicted Largest Range" TRuleVariation336 +type TItem685 = 'GItem TNonSpare1489 +type TNonSpare1492 = 'GNonSpare "NOISETHETASTART" "Predicted Smallest Azimuth" TRuleVariation349 +type TItem688 = 'GItem TNonSpare1492 +type TNonSpare1491 = 'GNonSpare "NOISETHETAEND" "Predicted Largest Azimuth" TRuleVariation349 +type TItem687 = 'GItem TNonSpare1491 +type TNonSpare1584 = 'GNonSpare "PREDTIME" "Predicted Detection Time" TRuleVariation340 +type TItem759 = 'GItem TNonSpare1584 +type TVariation1220 = 'GGroup 0 '[ TItem757, TItem758, TItem344, TItem343, TItem346, TItem345, TItem686, TItem685, TItem688, TItem687, TItem759] +type TRuleVariation1166 = 'GContextFree TVariation1220 +type TNonSpare1496 = 'GNonSpare "NPP" "Next Predicted Position" TRuleVariation1166 +type TContent483 = 'GContentTable '[ '(0, "Surveillance Mode A (alert bit or periodic)"), '(1, "Comm-A"), '(2, "Ground Initiated Comm-B"), '(3, "Air Initiated Comm-B"), '(4, "Broadcast Comm-B"), '(5, "Comm-C"), '(6, "Comm-D"), '(7, "Reserved for future use"), '(8, "Reserved for future use"), '(9, "Reserved for future use"), '(10, "Reserved for future use"), '(11, "Reserved for future use"), '(12, "Reserved for future use"), '(13, "Reserved for future use"), '(14, "Reserved for future use"), '(15, "Reserved for future use")] +type TRuleContent481 = 'GContextFree TContent483 +type TVariation143 = 'GElement 0 4 TRuleContent481 +type TRuleVariation143 = 'GContextFree TVariation143 +type TNonSpare2144 = 'GNonSpare "TYPE" "" TRuleVariation143 +type TItem1173 = 'GItem TNonSpare2144 +type TContent224 = 'GContentTable '[ '(0, "From previous scan"), '(1, "New in current scan"), '(2, "Requested in the beam by transponder"), '(3, "Invalid ASTERIX value")] +type TRuleContent224 = 'GContextFree TContent224 +type TVariation791 = 'GElement 4 2 TRuleContent224 +type TRuleVariation779 = 'GContextFree TVariation791 +type TNonSpare1521 = 'GNonSpare "ORIGIN" "" TRuleVariation779 +type TItem716 = 'GItem TNonSpare1521 +type TContent248 = 'GContentTable '[ '(0, "In progress"), '(1, "Completed"), '(2, "Cancelled"), '(3, "Invalid ASTERIX value")] +type TRuleContent248 = 'GContextFree TContent248 +type TVariation992 = 'GElement 6 2 TRuleContent248 +type TRuleVariation961 = 'GContextFree TVariation992 +type TNonSpare1947 = 'GNonSpare "STATE" "" TRuleVariation961 +type TItem1027 = 'GItem TNonSpare1947 +type TVariation1306 = 'GGroup 0 '[ TItem1173, TItem716, TItem1027] +type TVariation1524 = 'GRepetitive ('GRepetitiveRegular 1) TVariation1306 +type TRuleVariation1440 = 'GContextFree TVariation1524 +type TNonSpare957 = 'GNonSpare "DLK" "Data Link Characteristics" TRuleVariation1440 +type TContent506 = 'GContentTable '[ '(0, "Target not locked out by this radar"), '(1, "Target locked out by this radar")] +type TRuleContent504 = 'GContextFree TContent506 +type TVariation87 = 'GElement 0 1 TRuleContent504 +type TRuleVariation87 = 'GContextFree TVariation87 +type TNonSpare1282 = 'GNonSpare "LS" "Lockout State" TRuleVariation87 +type TItem534 = 'GItem TNonSpare1282 +type TContent751 = 'GContentQuantity 'GUnsigned ('GNumInt ('GZ 'GPlus 1)) "ms" +type TRuleContent749 = 'GContextFree TContent751 +type TVariation520 = 'GElement 1 15 TRuleContent749 +type TRuleVariation508 = 'GContextFree TVariation520 +type TNonSpare1258 = 'GNonSpare "LOCTIM" "Lockout Time" TRuleVariation508 +type TItem512 = 'GItem TNonSpare1258 +type TVariation1195 = 'GGroup 0 '[ TItem534, TItem512] +type TRuleVariation1146 = 'GContextFree TVariation1195 +type TNonSpare1246 = 'GNonSpare "LCK" "Lockout Characteristics" TRuleVariation1146 +type TVariation1029 = 'GElement 7 4 TRuleContent638 +type TRuleVariation998 = 'GContextFree TVariation1029 +type TNonSpare2010 = 'GNonSpare "TCOUNT1" "" TRuleVariation998 +type TItem1067 = 'GItem TNonSpare2010 +type TNonSpare2007 = 'GNonSpare "TCODE1" "" TRuleVariation708 +type TItem1064 = 'GItem TNonSpare2007 +type TNonSpare2011 = 'GNonSpare "TCOUNT2" "" TRuleVariation146 +type TItem1068 = 'GItem TNonSpare2011 +type TNonSpare2008 = 'GNonSpare "TCODE2" "" TRuleVariation807 +type TItem1065 = 'GItem TNonSpare2008 +type TNonSpare2012 = 'GNonSpare "TCOUNT3" "" TRuleVariation146 +type TItem1069 = 'GItem TNonSpare2012 +type TNonSpare2009 = 'GNonSpare "TCODE3" "" TRuleVariation807 +type TItem1066 = 'GItem TNonSpare2009 +type TVariation1087 = 'GGroup 0 '[ TItem6, TItem1067, TItem1064, TItem1068, TItem1065, TItem1069, TItem1066] +type TRuleVariation1054 = 'GContextFree TVariation1087 +type TNonSpare2000 = 'GNonSpare "TC" "Transition Code" TRuleVariation1054 +type TContent510 = 'GContentTable '[ '(0, "Tentative Track with One Plot"), '(1, "Tentative Track with at least Two Plots"), '(2, "Pre-Confirmed Track"), '(3, "Confirmed Track")] +type TRuleContent508 = 'GContextFree TContent510 +type TVariation119 = 'GElement 0 2 TRuleContent508 +type TRuleVariation119 = 'GContextFree TVariation119 +type TNonSpare613 = 'GNonSpare "ACQI" "" TRuleVariation119 +type TItem46 = 'GItem TNonSpare613 +type TVariation623 = 'GElement 2 14 TRuleContent638 +type TRuleVariation611 = 'GContextFree TVariation623 +type TNonSpare2090 = 'GNonSpare "TRKUPDCTR" "" TRuleVariation611 +type TItem1125 = 'GItem TNonSpare2090 +type TVariation321 = 'GElement 0 16 TRuleContent749 +type TRuleVariation313 = 'GContextFree TVariation321 +type TNonSpare1226 = 'GNonSpare "LASTTRKUPD" "" TRuleVariation313 +type TItem482 = 'GItem TNonSpare1226 +type TVariation1092 = 'GGroup 0 '[ TItem46, TItem1125, TItem482] +type TRuleVariation1058 = 'GContextFree TVariation1092 +type TNonSpare2039 = 'GNonSpare "TLC" "Track Life Cycle" TRuleVariation1058 +type TNonSpare1797 = 'GNonSpare "SACADJS" "SAC of the Adjacent Sensor" TRuleVariation171 +type TItem922 = 'GItem TNonSpare1797 +type TNonSpare1853 = 'GNonSpare "SICADJS" "SIC of the Adjacent Sensor" TRuleVariation171 +type TItem953 = 'GItem TNonSpare1853 +type TNonSpare2036 = 'GNonSpare "TIMEOFDAYSCN" "Absolute Timestamp in UTC Provided by the SCN" TRuleVariation340 +type TItem1087 = 'GItem TNonSpare2036 +type TContent83 = 'GContentTable '[ '(0, "Data used by Tracker"), '(1, "Data not used by Tracker"), '(2, "2-127: Reserved for future use")] +type TRuleContent83 = 'GContextFree TContent83 +type TVariation161 = 'GElement 0 7 TRuleContent83 +type TRuleVariation161 = 'GContextFree TVariation161 +type TNonSpare930 = 'GNonSpare "DATAUSE" "Use of Adjacent Sensor Data" TRuleVariation161 +type TItem257 = 'GItem TNonSpare930 +type TContent78 = 'GContentTable '[ '(0, "DRN not available"), '(1, "DRN available")] +type TRuleContent78 = 'GContextFree TContent78 +type TVariation1009 = 'GElement 7 1 TRuleContent78 +type TRuleVariation978 = 'GContextFree TVariation1009 +type TNonSpare970 = 'GNonSpare "DRNA" "DRN Availability" TRuleVariation978 +type TItem291 = 'GItem TNonSpare970 +type TNonSpare969 = 'GNonSpare "DRN" "" TRuleVariation259 +type TItem290 = 'GItem TNonSpare969 +type TVariation1259 = 'GGroup 0 '[ TItem922, TItem953, TItem1087, TItem257, TItem291, TItem290] +type TVariation1512 = 'GRepetitive ('GRepetitiveRegular 1) TVariation1259 +type TRuleVariation1428 = 'GContextFree TVariation1512 +type TNonSpare690 = 'GNonSpare "ASI" "Adjacent Sensor Information" TRuleVariation1428 +type TContent459 = 'GContentTable '[ '(0, "Radar tracker calculation"), '(1, "Integrated ADS-B"), '(2, "External ADS-B"), '(3, "SCN")] +type TRuleContent457 = 'GContextFree TContent459 +type TVariation190 = 'GElement 0 8 TRuleContent457 +type TRuleVariation182 = 'GContextFree TVariation190 +type TNonSpare2019 = 'GNonSpare "TES" "Track Extrapolation Source" TRuleVariation182 +type TContent247 = 'GContentTable '[ '(0, "Identity not requested"), '(1, "Identity requested")] +type TRuleContent247 = 'GContextFree TContent247 +type TVariation51 = 'GElement 0 1 TRuleContent247 +type TRuleVariation51 = 'GContextFree TVariation51 +type TNonSpare1202 = 'GNonSpare "IR" "" TRuleVariation51 +type TItem460 = 'GItem TNonSpare1202 +type TVariation515 = 'GElement 1 7 TRuleContent751 +type TRuleVariation503 = 'GContextFree TVariation515 +type TNonSpare1302 = 'GNonSpare "M3A" "Age of Mode 3/A Code (I048/070)" TRuleVariation503 +type TItem551 = 'GItem TNonSpare1302 +type TVariation1179 = 'GGroup 0 '[ TItem460, TItem551] +type TRuleVariation1130 = 'GContextFree TVariation1179 +type TNonSpare1203 = 'GNonSpare "IR" "Identity Requested" TRuleVariation1130 +type TVariation1588 = 'GCompound '[ 'Just TNonSpare1608, 'Just TNonSpare695, 'Just TNonSpare2092, 'Just TNonSpare1496, 'Just TNonSpare957, 'Just TNonSpare1246, 'Just TNonSpare2000, 'Just TNonSpare2039, 'Just TNonSpare690, 'Just TNonSpare2019, 'Just TNonSpare1203] +type TRuleVariation1504 = 'GContextFree TVariation1588 +type TNonSpare1771 = 'GNonSpare "RTC" "Radar Track Characteristics" TRuleVariation1504 +type TNonSpare1557 = 'GNonSpare "PNB" "Plot Number" TRuleVariation259 +type TContent446 = 'GContentTable '[ '(0, "PSR Echo"), '(1, "SSR Reply"), '(2, "All Call Reply"), '(3, "Roll Call Reply")] +type TRuleContent444 = 'GContextFree TContent446 +type TVariation189 = 'GElement 0 8 TRuleContent444 +type TRuleVariation181 = 'GContextFree TVariation189 +type TNonSpare2145 = 'GNonSpare "TYPE" "Reply Type" TRuleVariation181 +type TItem1174 = 'GItem TNonSpare2145 +type TNonSpare1716 = 'GNonSpare "REPLYNBR" "" TRuleVariation259 +type TItem867 = 'GItem TNonSpare1716 +type TVariation1307 = 'GGroup 0 '[ TItem1174, TItem867] +type TVariation1525 = 'GRepetitive ('GRepetitiveRegular 1) TVariation1307 +type TRuleVariation1441 = 'GContextFree TVariation1525 +type TNonSpare1744 = 'GNonSpare "RPL" "Replies/Plot Link" TRuleVariation1441 +type TNonSpare1886 = 'GNonSpare "SNB" "Scan Number" TRuleVariation211 +type TContent643 = 'GContentInteger 'GUnsigned +type TRuleContent641 = 'GContextFree TContent643 +type TVariation149 = 'GElement 0 4 TRuleContent641 +type TRuleVariation149 = 'GContextFree TVariation149 +type TNonSpare2347 = 'GNonSpare "Y1" "" TRuleVariation149 +type TItem1359 = 'GItem TNonSpare2347 +type TVariation833 = 'GElement 4 4 TRuleContent641 +type TRuleVariation802 = 'GContextFree TVariation833 +type TNonSpare2350 = 'GNonSpare "Y2" "" TRuleVariation802 +type TItem1362 = 'GItem TNonSpare2350 +type TNonSpare2352 = 'GNonSpare "Y3" "" TRuleVariation149 +type TItem1364 = 'GItem TNonSpare2352 +type TNonSpare2353 = 'GNonSpare "Y4" "" TRuleVariation802 +type TItem1365 = 'GItem TNonSpare2353 +type TContent641 = 'GContentInteger 'GUnsigned +type TRuleContent639 = 'GContextFree TContent641 +type TVariation147 = 'GElement 0 4 TRuleContent639 +type TRuleVariation147 = 'GContextFree TVariation147 +type TNonSpare1289 = 'GNonSpare "M1" "" TRuleVariation147 +type TItem541 = 'GItem TNonSpare1289 +type TNonSpare1295 = 'GNonSpare "M2" "" TRuleVariation802 +type TItem547 = 'GItem TNonSpare1295 +type TContent642 = 'GContentInteger 'GUnsigned +type TRuleContent640 = 'GContextFree TContent642 +type TVariation148 = 'GElement 0 4 TRuleContent640 +type TRuleVariation148 = 'GContextFree TVariation148 +type TNonSpare923 = 'GNonSpare "D1" "" TRuleVariation148 +type TItem251 = 'GItem TNonSpare923 +type TNonSpare924 = 'GNonSpare "D2" "" TRuleVariation802 +type TItem252 = 'GItem TNonSpare924 +type TVariation1385 = 'GGroup 0 '[ TItem1359, TItem1362, TItem1364, TItem1365, TItem541, TItem547, TItem251, TItem252] +type TRuleVariation1304 = 'GContextFree TVariation1385 +type TNonSpare931 = 'GNonSpare "DATE" "Common and Plot Characteristics Date" TRuleVariation1304 +type TVariation1583 = 'GCompound '[ 'Just TNonSpare1557, 'Just TNonSpare1744, 'Just TNonSpare1886, 'Just TNonSpare931] +type TRuleVariation1499 = 'GContextFree TVariation1583 +type TNonSpare884 = 'GNonSpare "CPC" "Common and Plot Characteristics" TRuleVariation1499 +type TExpansion6 = 'GExpansion ('Just 1) '[ 'Just TNonSpare1356, 'Just TNonSpare1317, 'Just TNonSpare1310, 'Just TNonSpare1741, 'Just TNonSpare1032, 'Just TNonSpare1771, 'Just TNonSpare884] +type TAsterix48 = 'GAsterixExpansion 48 ('GEdition 1 11) TExpansion6 +type TNonSpare968 = 'GNonSpare "DRN" "" TRuleVariation259 +type TItem289 = 'GItem TNonSpare968 +type TVariation1258 = 'GGroup 0 '[ TItem922, TItem953, TItem1087, TItem257, TItem291, TItem289] +type TVariation1511 = 'GRepetitive ('GRepetitiveRegular 1) TVariation1258 +type TRuleVariation1427 = 'GContextFree TVariation1511 +type TNonSpare689 = 'GNonSpare "ASI" "Adjacent Sensor Information" TRuleVariation1427 +type TVariation1587 = 'GCompound '[ 'Just TNonSpare1608, 'Just TNonSpare695, 'Just TNonSpare2092, 'Just TNonSpare1496, 'Just TNonSpare957, 'Just TNonSpare1246, 'Just TNonSpare2000, 'Just TNonSpare2039, 'Just TNonSpare689, 'Just TNonSpare2019, 'Just TNonSpare1203] +type TRuleVariation1503 = 'GContextFree TVariation1587 +type TNonSpare1770 = 'GNonSpare "RTC" "Radar Track Characteristics" TRuleVariation1503 +type TContent297 = 'GContentTable '[ '(0, "Mode-2 code as derived from reply of the transponder"), '(1, "Smoothed Mode-2 as provided by a local tracker")] +type TRuleContent295 = 'GContextFree TContent297 +type TVariation566 = 'GElement 2 1 TRuleContent295 +type TRuleVariation554 = 'GContextFree TVariation566 +type TNonSpare1216 = 'GNonSpare "L" "" TRuleVariation554 +type TItem472 = 'GItem TNonSpare1216 +type TNonSpare652 = 'GNonSpare "ALTM2" "Mode-2 Code in Octal Representation" TRuleVariation807 +type TItem68 = 'GItem TNonSpare652 +type TVariation1324 = 'GGroup 0 '[ TItem1191, TItem377, TItem472, TItem16, TItem68] +type TRuleVariation1248 = 'GContextFree TVariation1324 +type TNonSpare651 = 'GNonSpare "ALTM2" "Alternative Mode 2 Code" TRuleVariation1248 +type TContent300 = 'GContentTable '[ '(0, "Mode-3/A code as derived from the reply of the transponder"), '(1, "Smoothed Mode-3/A code as provided by a local tracker")] +type TRuleContent298 = 'GContextFree TContent300 +type TVariation569 = 'GElement 2 1 TRuleContent298 +type TRuleVariation557 = 'GContextFree TVariation569 +type TNonSpare1219 = 'GNonSpare "L" "" TRuleVariation557 +type TItem475 = 'GItem TNonSpare1219 +type TNonSpare654 = 'GNonSpare "ALTM3" "Mode-3/A Code in Octal Representation" TRuleVariation807 +type TItem69 = 'GItem TNonSpare654 +type TVariation1326 = 'GGroup 0 '[ TItem1191, TItem377, TItem475, TItem16, TItem69] +type TRuleVariation1250 = 'GContextFree TVariation1326 +type TNonSpare653 = 'GNonSpare "ALTM3" "Alternative Mode 3/A" TRuleVariation1250 +type TContent680 = 'GContentQuantity 'GSigned ('GNumDiv ('GNumInt ('GZ 'GPlus 1)) ('GNumPow ('GZ 'GPlus 2) ('GZ 'GPlus 2))) "ALTFL" +type TRuleContent678 = 'GContextFree TContent680 +type TVariation627 = 'GElement 2 14 TRuleContent678 +type TRuleVariation615 = 'GContextFree TVariation627 +type TNonSpare650 = 'GNonSpare "ALTFL" "Flight Level in Two's Complement Form" TRuleVariation615 +type TItem67 = 'GItem TNonSpare650 +type TVariation1318 = 'GGroup 0 '[ TItem1191, TItem377, TItem67] +type TRuleVariation1242 = 'GContextFree TVariation1318 +type TNonSpare649 = 'GNonSpare "ALTFL" "Alternative Flight Level" TRuleVariation1242 +type TVariation1554 = 'GCompound '[ 'Just TNonSpare651, 'Just TNonSpare653, 'Just TNonSpare649] +type TRuleVariation1470 = 'GContextFree TVariation1554 +type TNonSpare1110 = 'GNonSpare "GEN48" "Generic Category 048 Data" TRuleVariation1470 +type TExpansion5 = 'GExpansion ('Just 1) '[ 'Just TNonSpare1356, 'Just TNonSpare1317, 'Just TNonSpare1310, 'Just TNonSpare1741, 'Just TNonSpare1032, 'Just TNonSpare1770, 'Just TNonSpare884, 'Just TNonSpare1110] +type TAsterix49 = 'GAsterixExpansion 48 ('GEdition 1 12) TExpansion5 +type TNonSpare648 = 'GNonSpare "ALTFL" "Alternative Flight Level" TRuleVariation1242 +type TContent671 = 'GContentQuantity 'GSigned ('GNumDiv ('GNumInt ('GZ 'GPlus 1)) ('GNumInt ('GZ 'GPlus 100))) "dBm²" +type TRuleContent669 = 'GContextFree TContent671 +type TVariation626 = 'GElement 2 14 TRuleContent669 +type TRuleVariation614 = 'GContextFree TVariation626 +type TNonSpare1686 = 'GNonSpare "RCSDB" "" TRuleVariation614 +type TItem844 = 'GItem TNonSpare1686 +type TVariation1047 = 'GGroup 0 '[ TItem1, TItem844] +type TRuleVariation1016 = 'GContextFree TVariation1047 +type TNonSpare1687 = 'GNonSpare "RCSDB" "Radar Cross Section" TRuleVariation1016 +type TContent812 = 'GContentQuantity 'GUnsigned ('GNumDiv ('GNumInt ('GZ 'GPlus 1)) ('GNumPow ('GZ 'GPlus 10) ('GZ 'GPlus 6))) "m²" +type TRuleContent809 = 'GContextFree TContent812 +type TVariation633 = 'GElement 2 30 TRuleContent809 +type TRuleVariation621 = 'GContextFree TVariation633 +type TNonSpare1688 = 'GNonSpare "RCSM" "" TRuleVariation621 +type TItem845 = 'GItem TNonSpare1688 +type TVariation1048 = 'GGroup 0 '[ TItem1, TItem845] +type TRuleVariation1017 = 'GContextFree TVariation1048 +type TNonSpare1689 = 'GNonSpare "RCSM" "Radar Cross Section" TRuleVariation1017 +type TVariation1553 = 'GCompound '[ 'Just TNonSpare651, 'Just TNonSpare653, 'Just TNonSpare648, 'Just TNonSpare1687, 'Just TNonSpare1689] +type TRuleVariation1469 = 'GContextFree TVariation1553 +type TNonSpare1109 = 'GNonSpare "GEN48" "Generic Category 048 Data" TRuleVariation1469 +type TExpansion4 = 'GExpansion ('Just 1) '[ 'Just TNonSpare1356, 'Just TNonSpare1317, 'Just TNonSpare1310, 'Just TNonSpare1741, 'Just TNonSpare1032, 'Just TNonSpare1770, 'Just TNonSpare884, 'Just TNonSpare1109] +type TAsterix50 = 'GAsterixExpansion 48 ('GEdition 1 13) TExpansion4 +type TContent362 = 'GContentTable '[ '(0, "No detection"), '(1, "Single PSR detection"), '(2, "Single SSR detection"), '(3, "SSR + PSR detection"), '(4, "Single ModeS All-Call"), '(5, "Single ModeS Roll-Call"), '(6, "ModeS All-Call + PSR"), '(7, "ModeS Roll-Call +PSR")] +type TRuleContent360 = 'GContextFree TContent362 +type TVariation135 = 'GElement 0 3 TRuleContent360 +type TRuleVariation135 = 'GContextFree TVariation135 +type TNonSpare2132 = 'GNonSpare "TYP" "" TRuleVariation135 +type TItem1162 = 'GItem TNonSpare2132 +type TVariation1464 = 'GExtended '[ 'Just TItem1162, 'Just TItem969, 'Just TItem847, 'Just TItem990, 'Just TItem826, 'Nothing, 'Just TItem1138, 'Just TItem338, 'Just TItem1323, 'Just TItem592, 'Just TItem599, 'Just TItem356, 'Nothing] +type TRuleVariation1380 = 'GContextFree TVariation1464 +type TNonSpare89 = 'GNonSpare "020" "Target Report Descriptor" TRuleVariation1380 +type TUapItem89 = 'GUapItem TNonSpare89 +type TNonSpare145 = 'GNonSpare "040" "Measured Position in Polar Co-ordinates" TRuleVariation1185 +type TUapItem145 = 'GUapItem TNonSpare145 +type TNonSpare221 = 'GNonSpare "070" "Mode-3/A Code in Octal Representation" TRuleVariation1253 +type TUapItem221 = 'GUapItem TNonSpare221 +type TNonSpare1048 = 'GNonSpare "FL" "" TRuleVariation618 +type TItem352 = 'GItem TNonSpare1048 +type TVariation1320 = 'GGroup 0 '[ TItem1191, TItem377, TItem352] +type TRuleVariation1244 = 'GContextFree TVariation1320 +type TNonSpare262 = 'GNonSpare "090" "Flight Level in Binary Representation" TRuleVariation1244 +type TUapItem262 = 'GUapItem TNonSpare262 +type TNonSpare1912 = 'GNonSpare "SRL" "SSR Plot Runlength" TRuleVariation251 +type TNonSpare1914 = 'GNonSpare "SRR" "Number of Received Replies for (M)SSR" TRuleVariation211 +type TNonSpare1802 = 'GNonSpare "SAM" "Amplitude of (M)SSR Reply" TRuleVariation214 +type TNonSpare1592 = 'GNonSpare "PRL" "Primary Plot Runlength" TRuleVariation251 +type TNonSpare1539 = 'GNonSpare "PAM" "Amplitude of Primary Plot" TRuleVariation214 +type TNonSpare1742 = 'GNonSpare "RPD" "Difference in Range Between PSR and SSR Plot" TRuleVariation223 +type TNonSpare669 = 'GNonSpare "APD" "Difference in Azimuth Between PSR and SSR Plot" TRuleVariation226 +type TVariation1593 = 'GCompound '[ 'Just TNonSpare1912, 'Just TNonSpare1914, 'Just TNonSpare1802, 'Just TNonSpare1592, 'Just TNonSpare1539, 'Just TNonSpare1742, 'Just TNonSpare669] +type TRuleVariation1509 = 'GContextFree TVariation1593 +type TNonSpare332 = 'GNonSpare "130" "Radar Plot Characteristics" TRuleVariation1509 +type TUapItem332 = 'GUapItem TNonSpare332 +type TNonSpare466 = 'GNonSpare "240" "Aircraft Identification" TRuleVariation396 +type TUapItem466 = 'GUapItem TNonSpare466 +type TNonSpare484 = 'GNonSpare "250" "Mode S MB Data" TRuleVariation1418 +type TUapItem484 = 'GUapItem TNonSpare484 +type TNonSpare387 = 'GNonSpare "161" "Track Number" TRuleVariation1044 +type TUapItem387 = 'GUapItem TNonSpare387 +type TNonSpare2337 = 'GNonSpare "Y" "X-Component" TRuleVariation293 +type TItem1349 = 'GItem TNonSpare2337 +type TVariation1378 = 'GGroup 0 '[ TItem1305, TItem1349] +type TRuleVariation1300 = 'GContextFree TVariation1378 +type TNonSpare166 = 'GNonSpare "042" "Calculated Position in Cartesian Co-ordinates" TRuleVariation1300 +type TUapItem166 = 'GUapItem TNonSpare166 +type TContent378 = 'GContentTable '[ '(0, "No horizontal man.sensed"), '(1, "Horizontal man. sensed")] +type TRuleContent376 = 'GContextFree TContent378 +type TVariation764 = 'GElement 4 1 TRuleContent376 +type TRuleVariation752 = 'GContextFree TVariation764 +type TNonSpare1324 = 'GNonSpare "MAH" "Manoeuvre Detection in Horizontal Sense" TRuleVariation752 +type TItem566 = 'GItem TNonSpare1324 +type TNonSpare778 = 'GNonSpare "CDM" "Climbing / Descending Mode" TRuleVariation877 +type TItem152 = 'GItem TNonSpare778 +type TContent539 = 'GContentTable '[ '(0, "Track still alive"), '(1, "End of track lifetime(last report for this track)")] +type TRuleContent537 = 'GContextFree TContent539 +type TVariation95 = 'GElement 0 1 TRuleContent537 +type TRuleVariation95 = 'GContextFree TVariation95 +type TNonSpare2086 = 'GNonSpare "TRE" "Signal for End_of_Track" TRuleVariation95 +type TItem1123 = 'GItem TNonSpare2086 +type TContent542 = 'GContentTable '[ '(0, "Tracking performed in so-called 'Radar Plane', i.e. neither slant range correction nor stereographical projection was applied"), '(1, "Slant range correction and a suitable projection technique are used to track in a 2D.reference plane, tangential to the earth model at the Radar Site co-ordinates")] +type TRuleContent540 = 'GContextFree TContent542 +type TVariation689 = 'GElement 3 1 TRuleContent540 +type TRuleVariation677 = 'GContextFree TVariation689 +type TNonSpare2006 = 'GNonSpare "TCC" "Type of Plot Coordinate Transformation Mechanism:" TRuleVariation677 +type TItem1063 = 'GItem TNonSpare2006 +type TVariation1423 = 'GExtended '[ 'Just TItem183, 'Just TItem831, 'Just TItem287, 'Just TItem566, 'Just TItem152, 'Nothing, 'Just TItem1123, 'Just TItem394, 'Just TItem1045, 'Just TItem1063, 'Just TItem21, 'Nothing] +type TRuleVariation1339 = 'GContextFree TVariation1423 +type TNonSpare400 = 'GNonSpare "170" "Track Status" TRuleVariation1339 +type TUapItem400 = 'GUapItem TNonSpare400 +type TNonSpare1861 = 'GNonSpare "SIGX" "Sigma (X)) Standard Deviation on the Horizontal Axis of the Local Grid System" TRuleVariation243 +type TItem959 = 'GItem TNonSpare1861 +type TNonSpare1863 = 'GNonSpare "SIGY" "Sigma (Y)) Standard Deviation on the Vertical Axis of the Local Grid System" TRuleVariation243 +type TItem961 = 'GItem TNonSpare1863 +type TNonSpare1859 = 'GNonSpare "SIGV" "Sigma (V)) Standard Deviation on the Groundspeed Within the Local Grid System" TRuleVariation246 +type TItem957 = 'GItem TNonSpare1859 +type TNonSpare1857 = 'GNonSpare "SIGH" "Sigma (H)) Standard Deviation on the Heading Within the Local Grid System" TRuleVariation250 +type TItem955 = 'GItem TNonSpare1857 +type TVariation1272 = 'GGroup 0 '[ TItem959, TItem961, TItem957, TItem955] +type TRuleVariation1211 = 'GContextFree TVariation1272 +type TNonSpare442 = 'GNonSpare "210" "Track Quality" TRuleVariation1211 +type TUapItem442 = 'GUapItem TNonSpare442 +type TContent414 = 'GContentTable '[ '(0, "Not defined; never used"), '(1, "Multipath Reply (Reflection)"), '(2, "Reply due to sidelobe interrogation/reception"), '(3, "Split plot"), '(4, "Second time around reply"), '(5, "Angel"), '(6, "Slow moving target correlated with road infrastructure (terrestrial vehicle)"), '(7, "Fixed PSR plot"), '(8, "Slow PSR target"), '(9, "Low quality PSR plot"), '(10, "Phantom SSR plot"), '(11, "Non-Matching Mode-3/A Code"), '(12, "Mode C code / Mode S altitude code abnormal value compared to the track"), '(13, "Target in Clutter Area"), '(14, "Maximum Doppler Response in Zero Filter"), '(15, "Transponder anomaly detected"), '(16, "Duplicated or Illegal Mode S Aircraft Address"), '(17, "Mode S error correction applied"), '(18, "Undecodable Mode C code / Mode S altitude code"), '(19, "Birds"), '(20, "Flock of Birds"), '(21, "Mode-1 was present in original reply"), '(22, "Mode-2 was present in original reply"), '(23, "Plot potentially caused by Wind Turbine"), '(24, "Helicopter"), '(25, "Maximum number of re-interrogations reached (surveillance information)"), '(26, "Maximum number of re-interrogations reached (BDS Extractions)"), '(27, "BDS Overlay Incoherence"), '(28, "Potential BDS Swap Detected"), '(29, "Track Update in the Zenithal Gap"), '(30, "Mode S Track re-acquired"), '(31, "Duplicated Mode 5 Pair NO/PIN detected")] +type TRuleContent412 = 'GContextFree TContent414 +type TVariation163 = 'GElement 0 7 TRuleContent412 +type TVariation1535 = 'GRepetitive 'GRepetitiveFx TVariation163 +type TRuleVariation1451 = 'GContextFree TVariation1535 +type TNonSpare123 = 'GNonSpare "030" "Warning/Error Conditions and Target Classification" TRuleVariation1451 +type TUapItem123 = 'GUapItem TNonSpare123 +type TNonSpare536 = 'GNonSpare "3DH" "3D Height, in Binary Notation. Negative Values Are Expressed in Two's Complement" TRuleVariation612 +type TItem32 = 'GItem TNonSpare536 +type TVariation1040 = 'GGroup 0 '[ TItem1, TItem32] +type TRuleVariation1009 = 'GContextFree TVariation1040 +type TNonSpare303 = 'GNonSpare "110" "Height Measured by a 3D Radar" TRuleVariation1009 +type TUapItem303 = 'GUapItem TNonSpare303 +type TNonSpare762 = 'GNonSpare "CAL" "Calculated Doppler Speed, Coded in Two's Complement" TRuleVariation971 +type TItem143 = 'GItem TNonSpare762 +type TVariation1133 = 'GGroup 0 '[ TItem250, TItem8, TItem143] +type TRuleVariation1088 = 'GContextFree TVariation1133 +type TNonSpare761 = 'GNonSpare "CAL" "Calculated Doppler Speed" TRuleVariation1088 +type TNonSpare1695 = 'GNonSpare "RDS" "Raw Doppler Speed" TRuleVariation1412 +type TVariation1561 = 'GCompound '[ 'Just TNonSpare761, 'Just TNonSpare1695] +type TRuleVariation1477 = 'GContextFree TVariation1561 +type TNonSpare319 = 'GNonSpare "120" "Radial Doppler Speed" TRuleVariation1477 +type TUapItem319 = 'GUapItem TNonSpare319 +type TContent353 = 'GContentTable '[ '(0, "No communications capability (surveillance only)"), '(1, "Comm. A and Comm. B capability"), '(2, "Comm. A, Comm. B and Uplink ELM"), '(3, "Comm. A, Comm. B, Uplink ELM and Downlink ELM"), '(4, "Level 5 Transponder capability")] +type TRuleContent351 = 'GContextFree TContent353 +type TVariation130 = 'GElement 0 3 TRuleContent351 +type TRuleVariation130 = 'GContextFree TVariation130 +type TNonSpare851 = 'GNonSpare "COM" "Communications Capability of the Transponder" TRuleVariation130 +type TItem202 = 'GItem TNonSpare851 +type TContent339 = 'GContentTable '[ '(0, "No alert, no SPI, aircraft airborne"), '(1, "No alert, no SPI, aircraft on ground"), '(2, "Alert, no SPI, aircraft airborne"), '(3, "Alert, no SPI, aircraft on ground"), '(4, "Alert, SPI, aircraft airborne or on ground"), '(5, "No alert, SPI, aircraft airborne or on ground"), '(7, "Unknown")] +type TRuleContent337 = 'GContextFree TContent339 +type TVariation712 = 'GElement 3 3 TRuleContent337 +type TRuleVariation700 = 'GContextFree TVariation712 +type TNonSpare1940 = 'GNonSpare "STAT" "Flight Status" TRuleVariation700 +type TItem1020 = 'GItem TNonSpare1940 +type TVariation1123 = 'GGroup 0 '[ TItem202, TItem1020, TItem948, TItem29, TItem646, TItem84, TItem58, TItem112, TItem114] +type TRuleVariation1078 = 'GContextFree TVariation1123 +type TNonSpare457 = 'GNonSpare "230" "Communications/ACAS Capability and Flight Status" TRuleVariation1078 +type TUapItem457 = 'GUapItem TNonSpare457 +type TNonSpare489 = 'GNonSpare "260" "ACAS Resolution Advisory Report" TRuleVariation397 +type TUapItem489 = 'GUapItem TNonSpare489 +type TNonSpare181 = 'GNonSpare "050" "Mode-2 Code in Octal Representation" TRuleVariation1249 +type TUapItem181 = 'GUapItem TNonSpare181 +type TRecord34 = 'GRecord '[ TUapItem39, TUapItem355, TUapItem89, TUapItem145, TUapItem221, TUapItem262, TUapItem332, TUapItem447, TUapItem466, TUapItem484, TUapItem387, TUapItem166, TUapItem415, TUapItem400, TUapItem442, TUapItem123, TUapItem244, TUapItem288, TUapItem303, TUapItem319, TUapItem457, TUapItem489, TUapItem194, TUapItem181, TUapItem213, TUapItem196, TUapItem596, TUapItem594] +type TUap28 = 'GUap TRecord34 +type TAsterix51 = 'GAsterixBasic 48 ('GEdition 1 27) TUap28 +type TContent415 = 'GContentTable '[ '(0, "Not defined; never used"), '(1, "Multipath Reply (Reflection)"), '(2, "Reply due to sidelobe interrogation/reception"), '(3, "Split plot"), '(4, "Second time around reply"), '(5, "Angel"), '(6, "Slow moving target correlated with road infrastructure (terrestrial vehicle)"), '(7, "Fixed PSR plot"), '(8, "Slow PSR target"), '(9, "Low quality PSR plot"), '(10, "Phantom SSR plot"), '(11, "Non-Matching Mode-3/A Code"), '(12, "Mode C code / Mode S altitude code abnormal value compared to the track"), '(13, "Target in Clutter Area"), '(14, "Maximum Doppler Response in Zero Filter"), '(15, "Transponder anomaly detected"), '(16, "Duplicated or Illegal Mode S Aircraft Address"), '(17, "Mode S error correction applied"), '(18, "Undecodable Mode C code / Mode S altitude code"), '(19, "Birds"), '(20, "Flock of Birds"), '(21, "Mode-1 was present in original reply"), '(22, "Mode-2 was present in original reply"), '(23, "Plot potentially caused by Wind Turbine"), '(24, "Helicopter"), '(25, "Maximum number of re-interrogations reached (surveillance information)"), '(26, "Maximum number of re-interrogations reached (BDS Extractions)"), '(27, "BDS Overlay Incoherence"), '(28, "Potential BDS Swap Detected"), '(29, "Track Update in the Zenithal Gap"), '(30, "Mode S Track re-acquired"), '(31, "Duplicated Mode 5 Pair NO/PIN detected"), '(32, "Wrong DF reply format detected"), '(33, "Transponder anomaly (MS XPD replies with Mode A/C to Mode A/C-only all-call)"), '(34, "Transponder anomaly (SI capability report wrong)")] +type TRuleContent413 = 'GContextFree TContent415 +type TVariation164 = 'GElement 0 7 TRuleContent413 +type TVariation1536 = 'GRepetitive 'GRepetitiveFx TVariation164 +type TRuleVariation1452 = 'GContextFree TVariation1536 +type TNonSpare124 = 'GNonSpare "030" "Warning/Error Conditions and Target Classification" TRuleVariation1452 +type TUapItem124 = 'GUapItem TNonSpare124 +type TRecord35 = 'GRecord '[ TUapItem39, TUapItem355, TUapItem89, TUapItem145, TUapItem221, TUapItem262, TUapItem332, TUapItem447, TUapItem466, TUapItem484, TUapItem387, TUapItem166, TUapItem415, TUapItem400, TUapItem442, TUapItem124, TUapItem244, TUapItem288, TUapItem303, TUapItem319, TUapItem457, TUapItem489, TUapItem194, TUapItem181, TUapItem213, TUapItem196, TUapItem596, TUapItem594] +type TUap29 = 'GUap TRecord35 +type TAsterix52 = 'GAsterixBasic 48 ('GEdition 1 28) TUap29 +type TNonSpare479 = 'GNonSpare "250" "BDS Register Data" TRuleVariation1418 +type TUapItem479 = 'GUapItem TNonSpare479 +type TNonSpare491 = 'GNonSpare "260" "ACAS Resolution Advisory Report" TRuleVariation397 +type TUapItem491 = 'GUapItem TNonSpare491 +type TRecord33 = 'GRecord '[ TUapItem39, TUapItem355, TUapItem89, TUapItem145, TUapItem221, TUapItem262, TUapItem332, TUapItem447, TUapItem466, TUapItem479, TUapItem387, TUapItem166, TUapItem415, TUapItem400, TUapItem442, TUapItem124, TUapItem244, TUapItem288, TUapItem303, TUapItem319, TUapItem457, TUapItem491, TUapItem194, TUapItem181, TUapItem213, TUapItem196, TUapItem596, TUapItem594] +type TUap27 = 'GUap TRecord33 +type TAsterix53 = 'GAsterixBasic 48 ('GEdition 1 29) TUap27 +type TNonSpare448 = 'GNonSpare "220" "Aircraft Address" TRuleVariation355 +type TUapItem448 = 'GUapItem TNonSpare448 +type TNonSpare468 = 'GNonSpare "240" "Aircraft Identification" TRuleVariation396 +type TUapItem468 = 'GUapItem TNonSpare468 +type TNonSpare478 = 'GNonSpare "250" "BDS Register Data" TRuleVariation1418 +type TUapItem478 = 'GUapItem TNonSpare478 +type TNonSpare458 = 'GNonSpare "230" "Communications/ACAS Capability and Flight Status" TRuleVariation1078 +type TUapItem458 = 'GUapItem TNonSpare458 +type TNonSpare178 = 'GNonSpare "050" "Mode-2 Code in Octal Representation" TRuleVariation1249 +type TUapItem178 = 'GUapItem TNonSpare178 +type TRecord36 = 'GRecord '[ TUapItem39, TUapItem355, TUapItem89, TUapItem145, TUapItem221, TUapItem262, TUapItem332, TUapItem448, TUapItem468, TUapItem478, TUapItem387, TUapItem166, TUapItem415, TUapItem400, TUapItem442, TUapItem124, TUapItem244, TUapItem288, TUapItem303, TUapItem319, TUapItem458, TUapItem491, TUapItem194, TUapItem178, TUapItem213, TUapItem196, TUapItem596, TUapItem594] +type TUap30 = 'GUap TRecord36 +type TAsterix54 = 'GAsterixBasic 48 ('GEdition 1 30) TUap30 +type TVariation1465 = 'GExtended '[ 'Just TItem1162, 'Just TItem969, 'Just TItem847, 'Just TItem990, 'Just TItem826, 'Nothing, 'Just TItem1138, 'Just TItem338, 'Just TItem1323, 'Just TItem592, 'Just TItem599, 'Just TItem356, 'Nothing, 'Just TItem51, 'Just TItem929, 'Just TItem730, 'Just TItem26, 'Nothing] +type TRuleVariation1381 = 'GContextFree TVariation1465 +type TNonSpare90 = 'GNonSpare "020" "Target Report Descriptor" TRuleVariation1381 +type TUapItem90 = 'GUapItem TNonSpare90 +type TContent416 = 'GContentTable '[ '(0, "Not defined; never used"), '(1, "Multipath Reply (Reflection)"), '(2, "Reply due to sidelobe interrogation/reception"), '(3, "Split plot"), '(4, "Second time around reply"), '(5, "Angel"), '(6, "Slow moving target correlated with road infrastructure (terrestrial vehicle)"), '(7, "Fixed PSR plot"), '(8, "Slow PSR target"), '(9, "Low quality PSR plot"), '(10, "Phantom SSR plot"), '(11, "Non-Matching Mode-3/A Code"), '(12, "Mode C code / Mode S altitude code abnormal value compared to the track"), '(13, "Target in Clutter Area"), '(14, "Maximum Doppler Response in Zero Filter"), '(15, "Transponder anomaly detected"), '(16, "Duplicated or Illegal Mode S Aircraft Address"), '(17, "Mode S error correction applied"), '(18, "Undecodable Mode C code / Mode S altitude code"), '(19, "Birds"), '(20, "Flock of Birds"), '(21, "Mode-1 was present in original reply"), '(22, "Mode-2 was present in original reply"), '(23, "Plot potentially caused by Wind Turbine"), '(24, "Helicopter"), '(25, "Maximum number of re-interrogations reached (surveillance information)"), '(26, "Maximum number of re-interrogations reached (BDS Extractions)"), '(27, "BDS Overlay Incoherence"), '(28, "Potential BDS Swap Detected"), '(29, "Track Update in the Zenithal Gap"), '(30, "Mode S Track re-acquired"), '(31, "Duplicated Mode 5 Pair NO/PIN detected"), '(32, "Wrong DF reply format detected"), '(33, "Transponder anomaly (MS XPD replies with Mode A/C to Mode A/C-only all-call)"), '(34, "Transponder anomaly (SI capability report wrong)"), '(35, "Potential IC Conflict"), '(36, "IC Conflict detection possible-no conflict currently detected")] +type TRuleContent414 = 'GContextFree TContent416 +type TVariation165 = 'GElement 0 7 TRuleContent414 +type TVariation1537 = 'GRepetitive 'GRepetitiveFx TVariation165 +type TRuleVariation1453 = 'GContextFree TVariation1537 +type TNonSpare125 = 'GNonSpare "030" "Warning/Error Conditions and Target Classification" TRuleVariation1453 +type TUapItem125 = 'GUapItem TNonSpare125 +type TNonSpare320 = 'GNonSpare "120" "Radial Doppler Speed" TRuleVariation1477 +type TUapItem320 = 'GUapItem TNonSpare320 +type TRecord37 = 'GRecord '[ TUapItem39, TUapItem355, TUapItem90, TUapItem145, TUapItem221, TUapItem262, TUapItem332, TUapItem448, TUapItem468, TUapItem478, TUapItem387, TUapItem166, TUapItem415, TUapItem400, TUapItem442, TUapItem125, TUapItem244, TUapItem288, TUapItem303, TUapItem320, TUapItem458, TUapItem491, TUapItem194, TUapItem178, TUapItem213, TUapItem196, TUapItem596, TUapItem594] +type TUap31 = 'GUap TRecord37 +type TAsterix55 = 'GAsterixBasic 48 ('GEdition 1 31) TUap31 +type TContent10 = 'GContentTable '[ '(0, "ACASXV not populated"), '(1, "ACASXV populated")] +type TRuleContent10 = 'GContextFree TContent10 +type TVariation2 = 'GElement 0 1 TRuleContent10 +type TRuleVariation2 = 'GContextFree TVariation2 +type TNonSpare1007 = 'GNonSpare "EP" "ACASXV Element Populated Bit" TRuleVariation2 +type TItem315 = 'GItem TNonSpare1007 +type TContent398 = 'GContentTable '[ '(0, "Non-Extended Version"), '(1, "ACAS Xa Version 1"), '(2, "ACAS Xu Version 1")] +type TRuleContent396 = 'GContextFree TContent398 +type TVariation505 = 'GElement 1 4 TRuleContent396 +type TRuleVariation493 = 'GContextFree TVariation505 +type TNonSpare2169 = 'GNonSpare "VAL" "ACAS Extended Version Value" TRuleVariation493 +type TItem1194 = 'GItem TNonSpare2169 +type TVariation1141 = 'GGroup 0 '[ TItem315, TItem1194] +type TRuleVariation1094 = 'GContextFree TVariation1141 +type TNonSpare611 = 'GNonSpare "ACASXV" "Extended Version" TRuleVariation1094 +type TItem44 = 'GItem TNonSpare611 +type TNonSpare2180 = 'GNonSpare "VAL" "POACT Active for Current Plot" TRuleVariation451 +type TItem1205 = 'GItem TNonSpare2180 +type TVariation1157 = 'GGroup 0 '[ TItem331, TItem1205] +type TRuleVariation1110 = 'GContextFree TVariation1157 +type TNonSpare1562 = 'GNonSpare "POACT" "PO Active for Current Plot" TRuleVariation1110 +type TItem745 = 'GItem TNonSpare1562 +type TNonSpare1018 = 'GNonSpare "EP" "IRM Element Populated Bit" TRuleVariation544 +type TItem326 = 'GItem TNonSpare1018 +type TVariation1391 = 'GGroup 2 '[ TItem326, TItem1199] +type TRuleVariation1310 = 'GContextFree TVariation1391 +type TNonSpare1204 = 'GNonSpare "IRMACT" "IRM Active for Current Plot" TRuleVariation1310 +type TItem461 = 'GItem TNonSpare1204 +type TVariation1466 = 'GExtended '[ 'Just TItem1162, 'Just TItem969, 'Just TItem847, 'Just TItem990, 'Just TItem826, 'Nothing, 'Just TItem1138, 'Just TItem338, 'Just TItem1323, 'Just TItem592, 'Just TItem599, 'Just TItem356, 'Nothing, 'Just TItem51, 'Just TItem929, 'Just TItem730, 'Just TItem26, 'Nothing, 'Just TItem44, 'Just TItem752, 'Nothing, 'Just TItem745, 'Just TItem295, 'Just TItem294, 'Just TItem26, 'Nothing, 'Just TItem463, 'Just TItem461, 'Just TItem21, 'Nothing] +type TRuleVariation1382 = 'GContextFree TVariation1466 +type TNonSpare91 = 'GNonSpare "020" "Target Report Descriptor" TRuleVariation1382 +type TUapItem91 = 'GUapItem TNonSpare91 +type TNonSpare223 = 'GNonSpare "070" "Mode-3/A Code in Octal Representation" TRuleVariation1253 +type TUapItem223 = 'GUapItem TNonSpare223 +type TNonSpare1047 = 'GNonSpare "FL" "" TRuleVariation616 +type TItem351 = 'GItem TNonSpare1047 +type TVariation1319 = 'GGroup 0 '[ TItem1191, TItem377, TItem351] +type TRuleVariation1243 = 'GContextFree TVariation1319 +type TNonSpare261 = 'GNonSpare "090" "Flight Level in Binary Representation" TRuleVariation1243 +type TUapItem261 = 'GUapItem TNonSpare261 +type TContent417 = 'GContentTable '[ '(0, "Not defined; never used"), '(1, "Multipath Reply (Reflection)"), '(2, "Reply due to sidelobe interrogation/reception"), '(3, "Split plot"), '(4, "Second time around reply"), '(5, "Angel"), '(6, "Slow moving target correlated with road infrastructure (terrestrial vehicle)"), '(7, "Fixed PSR plot"), '(8, "Slow PSR target"), '(9, "Low quality PSR plot"), '(10, "Phantom SSR plot"), '(11, "Non-Matching Mode-3/A Code"), '(12, "Mode C code / Mode S altitude code abnormal value compared to the track"), '(13, "Target in Clutter Area"), '(14, "Maximum Doppler Response in Zero Filter"), '(15, "Transponder anomaly detected"), '(16, "Duplicated or Illegal Mode S Aircraft Address"), '(17, "Mode S error correction applied"), '(18, "Undecodable Mode C code / Mode S altitude code"), '(19, "Birds"), '(20, "Flock of Birds"), '(21, "Mode-1 was present in original reply"), '(22, "Mode-2 was present in original reply"), '(23, "Plot potentially caused by Wind Turbine"), '(24, "Helicopter"), '(25, "Maximum number of re-interrogations reached (surveillance information)"), '(26, "Maximum number of re-interrogations reached (BDS Extractions)"), '(27, "BDS Overlay Incoherence"), '(28, "Potential BDS Swap Detected"), '(29, "Track Update in the Zenithal Gap"), '(30, "Mode S Track re-acquired"), '(31, "Duplicated Mode 5 Pair NO/PIN detected"), '(32, "Wrong DF reply format detected"), '(33, "Transponder anomaly (MS XPD replies with Mode A/C to Mode A/C-only all-call)"), '(34, "Transponder anomaly (SI capability report wrong)"), '(35, "Potential IC Conflict"), '(36, "IC Conflict detection possible-no conflict currently detected"), '(37, "Duplicate Mode 5 PIN (refer to the Mode 5 items in the REF)")] +type TRuleContent415 = 'GContextFree TContent417 +type TVariation166 = 'GElement 0 7 TRuleContent415 +type TVariation1538 = 'GRepetitive 'GRepetitiveFx TVariation166 +type TRuleVariation1454 = 'GContextFree TVariation1538 +type TNonSpare126 = 'GNonSpare "030" "Warning/Error Conditions and Target Classification" TRuleVariation1454 +type TUapItem126 = 'GUapItem TNonSpare126 +type TNonSpare180 = 'GNonSpare "050" "Mode-2 Code in Octal Representation" TRuleVariation1249 +type TUapItem180 = 'GUapItem TNonSpare180 +type TRecord38 = 'GRecord '[ TUapItem39, TUapItem355, TUapItem91, TUapItem145, TUapItem223, TUapItem261, TUapItem332, TUapItem448, TUapItem468, TUapItem478, TUapItem387, TUapItem166, TUapItem415, TUapItem400, TUapItem442, TUapItem126, TUapItem244, TUapItem288, TUapItem303, TUapItem320, TUapItem458, TUapItem491, TUapItem194, TUapItem180, TUapItem213, TUapItem196, TUapItem596, TUapItem594] +type TUap32 = 'GUap TRecord38 +type TAsterix56 = 'GAsterixBasic 48 ('GEdition 1 32) TUap32 +type TContent363 = 'GContentTable '[ '(0, "No detection"), '(1, "Single PSR detection"), '(2, "Single SSR detection"), '(3, "SSR+PSR detection"), '(4, "Single Mode S All-Call"), '(5, "Single Mode S Roll-Call"), '(6, "Mode S All-Call + PSR"), '(7, "Mode S Roll-Call + PSR"), '(8, "ADS-B"), '(9, "WAM")] +type TRuleContent361 = 'GContextFree TContent363 +type TVariation828 = 'GElement 4 4 TRuleContent361 +type TRuleVariation797 = 'GContextFree TVariation828 +type TNonSpare2136 = 'GNonSpare "TYP" "" TRuleVariation797 +type TItem1166 = 'GItem TNonSpare2136 +type TNonSpare1283 = 'GNonSpare "LTN" "Local Track Number" TRuleVariation259 +type TItem535 = 'GItem TNonSpare1283 +type TVariation1255 = 'GGroup 0 '[ TItem920, TItem951, TItem3, TItem1166, TItem535] +type TVariation1510 = 'GRepetitive ('GRepetitiveRegular 1) TVariation1255 +type TRuleVariation1426 = 'GContextFree TVariation1510 +type TNonSpare911 = 'GNonSpare "CST" "Contributing Sensors With Local Tracknumbers" TRuleVariation1426 +type TVariation1254 = 'GGroup 0 '[ TItem920, TItem951, TItem3, TItem1166] +type TVariation1509 = 'GRepetitive ('GRepetitiveRegular 1) TVariation1254 +type TRuleVariation1425 = 'GContextFree TVariation1509 +type TNonSpare905 = 'GNonSpare "CSN" "Contributing Sensors No Local Tracknumbers" TRuleVariation1425 +type TContent691 = 'GContentQuantity 'GSigned ('GNumDiv ('GNumInt ('GZ 'GPlus 1)) ('GNumPow ('GZ 'GPlus 2) ('GZ 'GPlus 2))) "m/s" +type TRuleContent689 = 'GContextFree TContent691 +type TVariation294 = 'GElement 0 16 TRuleContent689 +type TRuleVariation286 = 'GContextFree TVariation294 +type TNonSpare2238 = 'GNonSpare "VX" "" TRuleVariation286 +type TItem1259 = 'GItem TNonSpare2238 +type TNonSpare2243 = 'GNonSpare "VY" "" TRuleVariation286 +type TItem1264 = 'GItem TNonSpare2243 +type TVariation1344 = 'GGroup 0 '[ TItem1259, TItem1264] +type TRuleVariation1268 = 'GContextFree TVariation1344 +type TNonSpare2126 = 'GNonSpare "TVS" "Calculated Track Velocity Relative to System Reference Point" TRuleVariation1268 +type TContent219 = 'GContentTable '[ '(0, "Flight plan data from active FDPS"), '(1, "Flight plan data retained from no longer active FDPS")] +type TRuleContent219 = 'GContextFree TContent219 +type TVariation45 = 'GElement 0 1 TRuleContent219 +type TRuleVariation45 = 'GContextFree TVariation45 +type TNonSpare1046 = 'GNonSpare "FDR" "Flight Data Retained" TRuleVariation45 +type TItem350 = 'GItem TNonSpare1046 +type TVariation1431 = 'GExtended '[ 'Just TItem350, 'Just TItem9, 'Nothing] +type TRuleVariation1347 = 'GContextFree TVariation1431 +type TNonSpare1962 = 'GNonSpare "STS" "Supplementary Track Status" TRuleVariation1347 +type TExpansion2 = 'GExpansion ('Just 1) '[ 'Just TNonSpare911, 'Just TNonSpare905, 'Just TNonSpare2126, 'Just TNonSpare1962] +type TAsterix57 = 'GAsterixExpansion 62 ('GEdition 1 2) TExpansion2 +type TContent262 = 'GContentTable '[ '(0, "LNAV not populated"), '(1, "LNAV populated")] +type TRuleContent260 = 'GContextFree TContent262 +type TVariation449 = 'GElement 1 1 TRuleContent260 +type TRuleVariation437 = 'GContextFree TVariation449 +type TNonSpare1021 = 'GNonSpare "EP" "LNAV Element Populated" TRuleVariation437 +type TItem329 = 'GItem TNonSpare1021 +type TContent260 = 'GContentTable '[ '(0, "LNAV Mode Engaged"), '(1, "LNAV Mode not Engaged")] +type TRuleContent258 = 'GContextFree TContent260 +type TVariation558 = 'GElement 2 1 TRuleContent258 +type TRuleVariation546 = 'GContextFree TVariation558 +type TNonSpare2176 = 'GNonSpare "VAL" "LNAV Mode" TRuleVariation546 +type TItem1201 = 'GItem TNonSpare2176 +type TVariation1386 = 'GGroup 1 '[ TItem329, TItem1201] +type TRuleVariation1305 = 'GContextFree TVariation1386 +type TNonSpare1255 = 'GNonSpare "LNAV" "Lateral Navigation Mode" TRuleVariation1305 +type TItem509 = 'GItem TNonSpare1255 +type TVariation1432 = 'GExtended '[ 'Just TItem350, 'Just TItem509, 'Just TItem18, 'Nothing] +type TRuleVariation1348 = 'GContextFree TVariation1432 +type TNonSpare1963 = 'GNonSpare "STS" "Supplementary Track Status" TRuleVariation1348 +type TContent445 = 'GContentTable '[ '(0, "PS3 Element not populated"), '(1, "PS3 Element populated")] +type TRuleContent443 = 'GContextFree TContent445 +type TVariation74 = 'GElement 0 1 TRuleContent443 +type TRuleVariation74 = 'GContextFree TVariation74 +type TNonSpare1025 = 'GNonSpare "EP" "Priority Status for Version 3 ADS-B Systems Populated" TRuleVariation74 +type TItem333 = 'GItem TNonSpare1025 +type TContent375 = 'GContentTable '[ '(0, "No emergency / not reported"), '(1, "General emergency"), '(2, "UAS/RPAS - Lost link"), '(3, "Minimum fuel"), '(4, "No communications"), '(5, "Unlawful interference"), '(6, "Aircraft in Distress Automatic Activation"), '(7, "Aircraft in Distress Manual Activation")] +type TRuleContent373 = 'GContextFree TContent375 +type TVariation501 = 'GElement 1 3 TRuleContent373 +type TRuleVariation489 = 'GContextFree TVariation501 +type TNonSpare2182 = 'GNonSpare "VAL" "Priority Status for Version 3 ADS-B Systems" TRuleVariation489 +type TItem1207 = 'GItem TNonSpare2182 +type TVariation1158 = 'GGroup 0 '[ TItem333, TItem1207, TItem22] +type TRuleVariation1111 = 'GContextFree TVariation1158 +type TNonSpare1596 = 'GNonSpare "PS3" "Priority Status for Version 3 ADS-B Systems" TRuleVariation1111 +type TContent407 = 'GContentTable '[ '(0, "Not RCE"), '(1, "TABS"), '(2, "Reserved for future use"), '(3, "Other RCE")] +type TRuleContent405 = 'GContextFree TContent407 +type TVariation491 = 'GElement 1 2 TRuleContent405 +type TRuleVariation479 = 'GContextFree TVariation491 +type TNonSpare2189 = 'GNonSpare "VAL" "Value" TRuleVariation479 +type TItem1214 = 'GItem TNonSpare2189 +type TVariation1148 = 'GGroup 0 '[ TItem320, TItem1214] +type TRuleVariation1101 = 'GContextFree TVariation1148 +type TNonSpare1681 = 'GNonSpare "RCE" "Reduced Capability Equipment" TRuleVariation1101 +type TItem839 = 'GItem TNonSpare1681 +type TVariation774 = 'GElement 4 1 TRuleContent459 +type TRuleVariation762 = 'GContextFree TVariation774 +type TNonSpare2200 = 'GNonSpare "VAL" "Value" TRuleVariation762 +type TItem1225 = 'GItem TNonSpare2200 +type TVariation1397 = 'GGroup 3 '[ TItem322, TItem1225] +type TRuleVariation1316 = 'GContextFree TVariation1397 +type TNonSpare1750 = 'GNonSpare "RRL" "Reply Rate Limiting" TRuleVariation1316 +type TItem892 = 'GItem TNonSpare1750 +type TVariation999 = 'GElement 6 2 TRuleContent555 +type TRuleVariation968 = 'GContextFree TVariation999 +type TNonSpare2209 = 'GNonSpare "VAL" "Value" TRuleVariation968 +type TItem1234 = 'GItem TNonSpare2209 +type TVariation1410 = 'GGroup 5 '[ TItem324, TItem1234] +type TRuleVariation1326 = 'GContextFree TVariation1410 +type TNonSpare2067 = 'GNonSpare "TPW" "Transmit Power" TRuleVariation1326 +type TItem1107 = 'GItem TNonSpare2067 +type TContent578 = 'GContentTable '[ '(0, "Unknown"), '(1, "Transponder #1 (left/pilot side or single)"), '(2, "Transponder #2 (right/co-pilot side)"), '(3, "Transponder #3 (auxiliary or Back-up)")] +type TRuleContent576 = 'GContextFree TContent578 +type TVariation495 = 'GElement 1 2 TRuleContent576 +type TRuleVariation483 = 'GContextFree TVariation495 +type TNonSpare2190 = 'GNonSpare "VAL" "Value" TRuleVariation483 +type TItem1215 = 'GItem TNonSpare2190 +type TVariation1149 = 'GGroup 0 '[ TItem320, TItem1215] +type TRuleVariation1102 = 'GContextFree TVariation1149 +type TNonSpare2102 = 'GNonSpare "TSI" "Transponder Side Indication" TRuleVariation1102 +type TItem1135 = 'GItem TNonSpare2102 +type TVariation788 = 'GElement 4 1 TRuleContent585 +type TRuleVariation776 = 'GContextFree TVariation788 +type TNonSpare1699 = 'GNonSpare "RE" "Range Exceeded" TRuleVariation776 +type TItem852 = 'GItem TNonSpare1699 +type TVariation923 = 'GElement 5 6 TRuleContent0 +type TRuleVariation892 = 'GContextFree TVariation923 +type TNonSpare2206 = 'GNonSpare "VAL" "Value" TRuleVariation892 +type TItem1231 = 'GItem TNonSpare2206 +type TVariation1395 = 'GGroup 3 '[ TItem322, TItem852, TItem1231] +type TRuleVariation1314 = 'GContextFree TVariation1395 +type TNonSpare1988 = 'GNonSpare "TAO" "Transponder Antenna Offset" TRuleVariation1314 +type TItem1054 = 'GItem TNonSpare1988 +type TVariation1230 = 'GGroup 0 '[ TItem839, TItem892, TItem1107, TItem1135, TItem1054, TItem19] +type TRuleVariation1176 = 'GContextFree TVariation1230 +type TNonSpare688 = 'GNonSpare "AS" "Aircraft Status" TRuleVariation1176 +type TVariation451 = 'GElement 1 1 TRuleContent273 +type TRuleVariation439 = 'GContextFree TVariation451 +type TNonSpare2187 = 'GNonSpare "VAL" "Value" TRuleVariation439 +type TItem1212 = 'GItem TNonSpare2187 +type TVariation1146 = 'GGroup 0 '[ TItem320, TItem1212] +type TRuleVariation1099 = 'GContextFree TVariation1146 +type TNonSpare1449 = 'GNonSpare "MUO" "Manned / Unmanned Operation" TRuleVariation1099 +type TItem649 = 'GItem TNonSpare1449 +type TVariation702 = 'GElement 3 2 TRuleContent329 +type TRuleVariation690 = 'GContextFree TVariation702 +type TNonSpare2197 = 'GNonSpare "VAL" "Value" TRuleVariation690 +type TItem1222 = 'GItem TNonSpare2197 +type TVariation1389 = 'GGroup 2 '[ TItem321, TItem1222] +type TRuleVariation1308 = 'GContextFree TVariation1389 +type TNonSpare928 = 'GNonSpare "DAA" "Detect and Avoid Capabilities" TRuleVariation1308 +type TItem255 = 'GItem TNonSpare928 +type TNonSpare1782 = 'GNonSpare "RWC" "Remain Well Clear" TRuleVariation1324 +type TItem910 = 'GItem TNonSpare1782 +type TVariation1204 = 'GGroup 0 '[ TItem649, TItem255, TItem910, TItem29] +type TRuleVariation1152 = 'GContextFree TVariation1204 +type TNonSpare2149 = 'GNonSpare "UAS" "UAS/RPAS Status" TRuleVariation1152 +type TContent18 = 'GContentTable '[ '(0, "Active CAS (TCAS II) or no CAS"), '(1, "Active CAS (not TCAS II)"), '(2, "Active CAS (not TCAS II) with OCM transmit capability"), '(3, "Active CAS of Junior Status"), '(4, "Passive CAS with 1030 TCAS Resolution Message receive capability"), '(5, "Passive CAS with only OCM receive capability"), '(6, "Reserved for future use"), '(7, "Reserved for future use")] +type TRuleContent18 = 'GContextFree TContent18 +type TVariation806 = 'GElement 4 3 TRuleContent18 +type TRuleVariation791 = 'GContextFree TVariation806 +type TNonSpare2202 = 'GNonSpare "VAL" "Value" TRuleVariation791 +type TItem1227 = 'GItem TNonSpare2202 +type TVariation1399 = 'GGroup 3 '[ TItem322, TItem1227] +type TRuleVariation1318 = 'GContextFree TVariation1399 +type TNonSpare770 = 'GNonSpare "CATC" "CAS Type & Capability" TRuleVariation1318 +type TItem148 = 'GItem TNonSpare770 +type TVariation1282 = 'GGroup 0 '[ TItem1046, TItem148, TItem29] +type TRuleVariation1220 = 'GContextFree TVariation1282 +type TNonSpare767 = 'GNonSpare "CASS" "Collision Avoidance System Status" TRuleVariation1220 +type TVariation1584 = 'GCompound '[ 'Just TNonSpare1596, 'Just TNonSpare688, 'Just TNonSpare2149, 'Just TNonSpare767] +type TRuleVariation1500 = 'GContextFree TVariation1584 +type TNonSpare2166 = 'GNonSpare "V3" "ADS-B Version 3 Data" TRuleVariation1500 +type TExpansion3 = 'GExpansion ('Just 1) '[ 'Just TNonSpare911, 'Just TNonSpare905, 'Just TNonSpare2126, 'Just TNonSpare1963, 'Just TNonSpare2166] +type TAsterix58 = 'GAsterixExpansion 62 ('GEdition 1 3) TExpansion3 +type TNonSpare46 = 'GNonSpare "010" "Data Source Identifier" TRuleVariation1196 +type TUapItem46 = 'GUapItem TNonSpare46 +type TNonSpare59 = 'GNonSpare "015" "Service Identification" TRuleVariation171 +type TUapItem59 = 'GUapItem TNonSpare59 +type TNonSpare228 = 'GNonSpare "070" "Time Of Track Information" TRuleVariation376 +type TUapItem228 = 'GUapItem TNonSpare228 +type TNonSpare297 = 'GNonSpare "105" "Calculated Position In WGS-84 Co-ordinates" TRuleVariation1135 +type TUapItem297 = 'GUapItem TNonSpare297 +type TNonSpare2285 = 'GNonSpare "X" "X Coordinate" TRuleVariation358 +type TItem1301 = 'GItem TNonSpare2285 +type TNonSpare2340 = 'GNonSpare "Y" "Y Coordinate" TRuleVariation358 +type TItem1352 = 'GItem TNonSpare2340 +type TVariation1374 = 'GGroup 0 '[ TItem1301, TItem1352] +type TRuleVariation1297 = 'GContextFree TVariation1374 +type TNonSpare283 = 'GNonSpare "100" "Calculated Track Position (Cartesian)" TRuleVariation1297 +type TUapItem283 = 'GUapItem TNonSpare283 +type TNonSpare2239 = 'GNonSpare "VX" "Velocity (X-component)" TRuleVariation286 +type TItem1260 = 'GItem TNonSpare2239 +type TNonSpare2244 = 'GNonSpare "VY" "Velocity (Y-component)" TRuleVariation286 +type TItem1265 = 'GItem TNonSpare2244 +type TVariation1345 = 'GGroup 0 '[ TItem1260, TItem1265] +type TRuleVariation1269 = 'GContextFree TVariation1345 +type TNonSpare410 = 'GNonSpare "185" "Calculated Track Velocity (Cartesian)" TRuleVariation1269 +type TUapItem410 = 'GUapItem TNonSpare410 +type TContent692 = 'GContentQuantity 'GSigned ('GNumDiv ('GNumInt ('GZ 'GPlus 1)) ('GNumPow ('GZ 'GPlus 2) ('GZ 'GPlus 2))) "m/s²" +type TRuleContent690 = 'GContextFree TContent692 +type TVariation225 = 'GElement 0 8 TRuleContent690 +type TRuleVariation217 = 'GContextFree TVariation225 +type TNonSpare708 = 'GNonSpare "AX" "" TRuleVariation217 +type TItem101 = 'GItem TNonSpare708 +type TNonSpare712 = 'GNonSpare "AY" "" TRuleVariation217 +type TItem105 = 'GItem TNonSpare712 +type TVariation1099 = 'GGroup 0 '[ TItem101, TItem105] +type TRuleVariation1065 = 'GContextFree TVariation1099 +type TNonSpare436 = 'GNonSpare "210" "Calculated Acceleration (Cartesian)" TRuleVariation1065 +type TUapItem436 = 'GUapItem TNonSpare436 +type TContent348 = 'GContentTable '[ '(0, "No change"), '(1, "Mode 3/A has changed")] +type TRuleContent346 = 'GContextFree TContent348 +type TVariation580 = 'GElement 2 1 TRuleContent346 +type TRuleVariation568 = 'GContextFree TVariation580 +type TNonSpare794 = 'GNonSpare "CH" "Change in Mode 3/A" TRuleVariation568 +type TItem164 = 'GItem TNonSpare794 +type TVariation1042 = 'GGroup 0 '[ TItem1, TItem164, TItem16, TItem622] +type TRuleVariation1011 = 'GContextFree TVariation1042 +type TNonSpare211 = 'GNonSpare "060" "Track Mode 3/A Code" TRuleVariation1011 +type TUapItem211 = 'GUapItem TNonSpare211 +type TContent54 = 'GContentTable '[ '(0, "Callsign or registration downlinked from target"), '(1, "Callsign not downlinked from target"), '(2, "Registration not downlinked from target"), '(3, "Invalid")] +type TRuleContent54 = 'GContextFree TContent54 +type TVariation101 = 'GElement 0 2 TRuleContent54 +type TRuleVariation101 = 'GContextFree TVariation101 +type TNonSpare1952 = 'GNonSpare "STI" "" TRuleVariation101 +type TItem1031 = 'GItem TNonSpare1952 +type TVariation1277 = 'GGroup 0 '[ TItem1031, TItem15, TItem171] +type TRuleVariation1216 = 'GContextFree TVariation1277 +type TNonSpare472 = 'GNonSpare "245" "Target Identification" TRuleVariation1216 +type TUapItem472 = 'GUapItem TNonSpare472 +type TNonSpare623 = 'GNonSpare "ADR" "Target Address" TRuleVariation355 +type TNonSpare1189 = 'GNonSpare "ID" "Target Identification" TRuleVariation396 +type TNonSpare1388 = 'GNonSpare "MHG" "Magnetic Heading" TRuleVariation349 +type TContent27 = 'GContentTable '[ '(0, "Air Speed = IAS, LSB (Bit-1) = 2^-14 NM/s"), '(1, "Air Speed = Mach, LSB (Bit-1) = 0.001")] +type TRuleContent27 = 'GContextFree TContent27 +type TVariation9 = 'GElement 0 1 TRuleContent27 +type TRuleVariation9 = 'GContextFree TVariation9 +type TNonSpare1200 = 'GNonSpare "IM" "" TRuleVariation9 +type TItem458 = 'GItem TNonSpare1200 +type TRuleContent831 = 'GDependent '[ '[ "380", "IAS", "IM"]] TContent0 '[ '( '[ 0], TContent808), '( '[ 1], TContent780)] +type TVariation523 = 'GElement 1 15 TRuleContent831 +type TRuleVariation511 = 'GContextFree TVariation523 +type TNonSpare1180 = 'GNonSpare "IAS" "" TRuleVariation511 +type TItem444 = 'GItem TNonSpare1180 +type TVariation1178 = 'GGroup 0 '[ TItem458, TItem444] +type TRuleVariation1129 = 'GContextFree TVariation1178 +type TNonSpare1182 = 'GNonSpare "IAS" "Indicated Airspeed/Mach No" TRuleVariation1129 +type TContent746 = 'GContentQuantity 'GUnsigned ('GNumInt ('GZ 'GPlus 1)) "kt" +type TRuleContent744 = 'GContextFree TContent746 +type TVariation318 = 'GElement 0 16 TRuleContent744 +type TRuleVariation310 = 'GContextFree TVariation318 +type TNonSpare1995 = 'GNonSpare "TAS" "True Airspeed" TRuleVariation310 +type TContent392 = 'GContentTable '[ '(0, "No source information provided"), '(1, "Source information provided")] +type TRuleContent390 = 'GContextFree TContent392 +type TVariation67 = 'GElement 0 1 TRuleContent390 +type TRuleVariation67 = 'GContextFree TVariation67 +type TNonSpare1804 = 'GNonSpare "SAS" "" TRuleVariation67 +type TItem924 = 'GItem TNonSpare1804 +type TContent565 = 'GContentTable '[ '(0, "Unknown"), '(1, "Aircraft altitude"), '(2, "FCU/MCP selected altitude"), '(3, "FMS selected altitude")] +type TRuleContent563 = 'GContextFree TContent565 +type TVariation494 = 'GElement 1 2 TRuleContent563 +type TRuleVariation482 = 'GContextFree TVariation494 +type TNonSpare1905 = 'GNonSpare "SRC" "" TRuleVariation482 +type TItem999 = 'GItem TNonSpare1905 +type TContent663 = 'GContentQuantity 'GSigned ('GNumInt ('GZ 'GPlus 25)) "ft" +type TRuleContent661 = 'GContextFree TContent663 +type TVariation723 = 'GElement 3 13 TRuleContent661 +type TRuleVariation711 = 'GContextFree TVariation723 +type TNonSpare646 = 'GNonSpare "ALT" "Altitude in Two's Complement Form" TRuleVariation711 +type TItem65 = 'GItem TNonSpare646 +type TVariation1260 = 'GGroup 0 '[ TItem924, TItem999, TItem65] +type TRuleVariation1199 = 'GContextFree TVariation1260 +type TNonSpare1798 = 'GNonSpare "SAL" "Selected Altitude" TRuleVariation1199 +type TNonSpare1452 = 'GNonSpare "MV" "Manage Vertical Mode" TRuleVariation70 +type TItem652 = 'GItem TNonSpare1452 +type TNonSpare633 = 'GNonSpare "AH" "Altitude Hold" TRuleVariation446 +type TItem54 = 'GItem TNonSpare633 +type TNonSpare656 = 'GNonSpare "AM" "Approach Mode" TRuleVariation573 +type TItem71 = 'GItem TNonSpare656 +type TVariation1206 = 'GGroup 0 '[ TItem652, TItem54, TItem71, TItem65] +type TRuleVariation1154 = 'GContextFree TVariation1206 +type TNonSpare1077 = 'GNonSpare "FSS" "Final State Selected Altitude" TRuleVariation1154 +type TContent545 = 'GContentTable '[ '(0, "Trajectory intent data is available for this aircraft"), '(1, "Trajectory intent data is not available for this aircraft")] +type TRuleContent543 = 'GContextFree TContent545 +type TVariation97 = 'GElement 0 1 TRuleContent543 +type TRuleVariation97 = 'GContextFree TVariation97 +type TNonSpare1464 = 'GNonSpare "NAV" "TID Available" TRuleVariation97 +type TItem660 = 'GItem TNonSpare1464 +type TContent546 = 'GContentTable '[ '(0, "Trajectory intent data is valid"), '(1, "Trajectory intent data is not valid")] +type TRuleContent544 = 'GContextFree TContent546 +type TVariation476 = 'GElement 1 1 TRuleContent544 +type TRuleVariation464 = 'GContextFree TVariation476 +type TNonSpare1505 = 'GNonSpare "NVB" "TID Valid" TRuleVariation464 +type TItem700 = 'GItem TNonSpare1505 +type TVariation1446 = 'GExtended '[ 'Just TItem660, 'Just TItem700, 'Just TItem14, 'Nothing] +type TRuleVariation1362 = 'GContextFree TVariation1446 +type TNonSpare2038 = 'GNonSpare "TIS" "Trajectory Intent Status" TRuleVariation1362 +type TNonSpare2002 = 'GNonSpare "TCA" "TCP Number Availability" TRuleVariation83 +type TItem1060 = 'GItem TNonSpare2002 +type TNonSpare1474 = 'GNonSpare "NC" "TCP Compliance" TRuleVariation454 +type TItem670 = 'GItem TNonSpare1474 +type TNonSpare2014 = 'GNonSpare "TCPN" "Trajectory Change Point Number" TRuleVariation608 +type TItem1071 = 'GItem TNonSpare2014 +type TNonSpare1241 = 'GNonSpare "LAT" "Latitude in WGS.84 in Two's Complement" TRuleVariation366 +type TItem497 = 'GItem TNonSpare1241 +type TNonSpare1274 = 'GNonSpare "LON" "Longitude in WGS.84 in Two's Complement" TRuleVariation364 +type TItem528 = 'GItem TNonSpare1274 +type TNonSpare2016 = 'GNonSpare "TD" "Turn Direction" TRuleVariation781 +type TItem1073 = 'GItem TNonSpare2016 +type TNonSpare2071 = 'GNonSpare "TRA" "Turn Radius Availability" TRuleVariation954 +type TItem1110 = 'GItem TNonSpare2071 +type TNonSpare2046 = 'GNonSpare "TOA" "TOV Available" TRuleVariation993 +type TItem1092 = 'GItem TNonSpare2046 +type TVariation1285 = 'GGroup 0 '[ TItem1060, TItem670, TItem1071, TItem64, TItem497, TItem528, TItem774, TItem1073, TItem1110, TItem1092, TItem1097, TItem1155] +type TVariation1516 = 'GRepetitive ('GRepetitiveRegular 1) TVariation1285 +type TRuleVariation1432 = 'GContextFree TVariation1516 +type TNonSpare2033 = 'GNonSpare "TID" "Trajectory Intent Data" TRuleVariation1432 +type TContent333 = 'GContentTable '[ '(0, "No alert, no SPI, aircraft airborne"), '(1, "No alert, no SPI, aircraft on ground"), '(2, "Alert, no SPI, aircraft airborne"), '(3, "Alert, no SPI, aircraft on ground"), '(4, "Alert, SPI, aircraft airborne or on ground"), '(5, "No alert, SPI, aircraft airborne or on ground")] +type TRuleContent331 = 'GContextFree TContent333 +type TVariation708 = 'GElement 3 3 TRuleContent331 +type TRuleVariation696 = 'GContextFree TVariation708 +type TNonSpare1936 = 'GNonSpare "STAT" "Flight Status" TRuleVariation696 +type TItem1016 = 'GItem TNonSpare1936 +type TNonSpare725 = 'GNonSpare "B1B" "BDS BDS 1,0 Bits 37/40" TRuleVariation796 +type TItem115 = 'GItem TNonSpare725 +type TVariation1125 = 'GGroup 0 '[ TItem204, TItem1016, TItem27, TItem1006, TItem84, TItem58, TItem112, TItem115] +type TRuleVariation1080 = 'GContextFree TVariation1125 +type TNonSpare855 = 'GNonSpare "COM" "Communications/ACAS Capability and Flight Status" TRuleVariation1080 +type TContent562 = 'GContentTable '[ '(0, "Unknown"), '(1, "ACAS not operational"), '(2, "ACAS operational"), '(3, "Invalid")] +type TRuleContent560 = 'GContextFree TContent562 +type TVariation121 = 'GElement 0 2 TRuleContent560 +type TRuleVariation121 = 'GContextFree TVariation121 +type TNonSpare605 = 'GNonSpare "AC" "ACAS Status" TRuleVariation121 +type TItem40 = 'GItem TNonSpare605 +type TContent576 = 'GContentTable '[ '(0, "Unknown"), '(1, "Multiple navigational aids not operating"), '(2, "Multiple navigational aids operating"), '(3, "Invalid")] +type TRuleContent574 = 'GContextFree TContent576 +type TVariation614 = 'GElement 2 2 TRuleContent574 +type TRuleVariation602 = 'GContextFree TVariation614 +type TNonSpare1406 = 'GNonSpare "MN" "Multiple Navigational Aids Status" TRuleVariation602 +type TItem610 = 'GItem TNonSpare1406 +type TContent570 = 'GContentTable '[ '(0, "Unknown"), '(1, "Differential correction"), '(2, "No differential correction"), '(3, "Invalid")] +type TRuleContent568 = 'GContextFree TContent570 +type TVariation798 = 'GElement 4 2 TRuleContent568 +type TRuleVariation786 = 'GContextFree TVariation798 +type TNonSpare942 = 'GNonSpare "DC" "Differential Correction Status" TRuleVariation786 +type TItem268 = 'GItem TNonSpare942 +type TContent550 = 'GContentTable '[ '(0, "Transponder ground bit not set or unknown"), '(1, "Transponder Ground Bit set")] +type TRuleContent548 = 'GContextFree TContent550 +type TVariation989 = 'GElement 6 1 TRuleContent548 +type TRuleVariation958 = 'GContextFree TVariation989 +type TNonSpare1107 = 'GNonSpare "GBS" "Ground Bit Set" TRuleVariation958 +type TItem390 = 'GItem TNonSpare1107 +type TItem31 = 'GSpare 7 6 +type TContent371 = 'GContentTable '[ '(0, "No emergency"), '(1, "General emergency"), '(2, "Lifeguard / medical"), '(3, "Minimum fuel"), '(4, "No communications"), '(5, "Unlawful interference"), '(6, "Downed Aircraft"), '(7, "Unknown")] +type TRuleContent369 = 'GContextFree TContent371 +type TVariation921 = 'GElement 5 3 TRuleContent369 +type TRuleVariation890 = 'GContextFree TVariation921 +type TNonSpare1943 = 'GNonSpare "STAT" "Flight Status" TRuleVariation890 +type TItem1023 = 'GItem TNonSpare1943 +type TVariation1090 = 'GGroup 0 '[ TItem40, TItem610, TItem268, TItem390, TItem31, TItem1023] +type TRuleVariation1056 = 'GContextFree TVariation1090 +type TNonSpare1792 = 'GNonSpare "SAB" "Status Reported by ADS-B" TRuleVariation1056 +type TContent831 = 'GContentBds ('GBdsAt ('Just 48)) +type TRuleContent828 = 'GContextFree TContent831 +type TVariation409 = 'GElement 0 56 TRuleContent828 +type TRuleVariation400 = 'GContextFree TVariation409 +type TNonSpare615 = 'GNonSpare "ACS" "ACAS Resolution Advisory Report" TRuleVariation400 +type TNonSpare753 = 'GNonSpare "BVR" "Barometric Vertical Rate" TRuleVariation299 +type TNonSpare1127 = 'GNonSpare "GVR" "Geometric Vertical Rate" TRuleVariation299 +type TNonSpare1674 = 'GNonSpare "RAN" "Roll Angle" TRuleVariation275 +type TContent694 = 'GContentQuantity 'GSigned ('GNumDiv ('GNumInt ('GZ 'GPlus 1)) ('GNumPow ('GZ 'GPlus 2) ('GZ 'GPlus 2))) "°/s" +type TRuleContent692 = 'GContextFree TContent694 +type TVariation170 = 'GElement 0 7 TRuleContent692 +type TRuleVariation163 = 'GContextFree TVariation170 +type TNonSpare1739 = 'GNonSpare "ROT" "Rate of Turn in Two's Complement Form" TRuleVariation163 +type TItem888 = 'GItem TNonSpare1739 +type TVariation1286 = 'GGroup 0 '[ TItem1081, TItem15, TItem888, TItem29] +type TRuleVariation1221 = 'GContextFree TVariation1286 +type TNonSpare1990 = 'GNonSpare "TAR" "Track Angle Rate" TRuleVariation1221 +type TNonSpare1985 = 'GNonSpare "TAN" "Track Angle" TRuleVariation349 +type TContent710 = 'GContentQuantity 'GSigned ('GNumDiv ('GNumInt ('GZ 'GPlus 1)) ('GNumPow ('GZ 'GPlus 2) ('GZ 'GPlus 14))) "NM/s" +type TRuleContent708 = 'GContextFree TContent710 +type TVariation302 = 'GElement 0 16 TRuleContent708 +type TRuleVariation294 = 'GContextFree TVariation302 +type TNonSpare1116 = 'GNonSpare "GS" "Ground Speed" TRuleVariation294 +type TNonSpare2234 = 'GNonSpare "VUN" "Velocity Uncertainty" TRuleVariation171 +type TContent427 = 'GContentTable '[ '(0, "Not valid Wind Speed"), '(1, "Valid Wind Speed")] +type TRuleContent425 = 'GContextFree TContent427 +type TVariation72 = 'GElement 0 1 TRuleContent425 +type TRuleVariation72 = 'GContextFree TVariation72 +type TNonSpare2255 = 'GNonSpare "WS" "Wind Speed Valid Flag" TRuleVariation72 +type TItem1273 = 'GItem TNonSpare2255 +type TContent426 = 'GContentTable '[ '(0, "Not valid Wind Direction"), '(1, "Valid Wind Direction")] +type TRuleContent424 = 'GContextFree TContent426 +type TVariation462 = 'GElement 1 1 TRuleContent424 +type TRuleVariation450 = 'GContextFree TVariation462 +type TNonSpare2248 = 'GNonSpare "WD" "Wind Direction Valid Flag" TRuleVariation450 +type TItem1268 = 'GItem TNonSpare2248 +type TContent424 = 'GContentTable '[ '(0, "Not valid Temperature"), '(1, "Valid Temperature")] +type TRuleContent422 = 'GContextFree TContent424 +type TVariation589 = 'GElement 2 1 TRuleContent422 +type TRuleVariation577 = 'GContextFree TVariation589 +type TNonSpare2041 = 'GNonSpare "TMP" "Temperature Valid Flag" TRuleVariation577 +type TItem1088 = 'GItem TNonSpare2041 +type TContent425 = 'GContentTable '[ '(0, "Not valid Turbulence"), '(1, "Valid Turbulence")] +type TRuleContent423 = 'GContextFree TContent425 +type TVariation681 = 'GElement 3 1 TRuleContent423 +type TRuleVariation669 = 'GContextFree TVariation681 +type TNonSpare2080 = 'GNonSpare "TRB" "Turbulence Valid Flag" TRuleVariation669 +type TItem1118 = 'GItem TNonSpare2080 +type TNonSpare2256 = 'GNonSpare "WSD" "Wind Speed" TRuleVariation308 +type TItem1274 = 'GItem TNonSpare2256 +type TNonSpare2249 = 'GNonSpare "WDD" "Wind Direction" TRuleVariation315 +type TItem1269 = 'GItem TNonSpare2249 +type TNonSpare2042 = 'GNonSpare "TMPD" "Temperature in Degrees Celsius" TRuleVariation287 +type TItem1089 = 'GItem TNonSpare2042 +type TNonSpare2081 = 'GNonSpare "TRBD" "Turbulence" TRuleVariation212 +type TItem1119 = 'GItem TNonSpare2081 +type TVariation1348 = 'GGroup 0 '[ TItem1273, TItem1268, TItem1088, TItem1118, TItem22, TItem1274, TItem1269, TItem1089, TItem1119] +type TRuleVariation1272 = 'GContextFree TVariation1348 +type TNonSpare1379 = 'GNonSpare "MET" "Meteorological Data" TRuleVariation1272 +type TContent610 = 'GContentTable '[ '(1, "Light aircraft =< 7000 kg"), '(2, "Reserved"), '(3, "7000 kg < medium aircraft < 136000 kg"), '(4, "Reserved"), '(5, "136000 kg <= heavy aircraft"), '(6, "Highly manoeuvrable (5g acceleration capability) and high speed (>400 knots cruise)"), '(7, "Reserved"), '(8, "Reserved"), '(9, "Reserved"), '(10, "Rotocraft"), '(11, "Glider / sailplane"), '(12, "Lighter-than-air"), '(13, "Unmanned aerial vehicle"), '(14, "Space / transatmospheric vehicle"), '(15, "Ultralight / handglider / paraglider"), '(16, "Parachutist / skydiver"), '(17, "Reserved"), '(18, "Reserved"), '(19, "Reserved"), '(20, "Surface emergency vehicle"), '(21, "Surface service vehicle"), '(22, "Fixed ground or tethered obstruction"), '(23, "Reserved"), '(24, "Reserved")] +type TRuleContent608 = 'GContextFree TContent610 +type TVariation199 = 'GElement 0 8 TRuleContent608 +type TRuleVariation191 = 'GContextFree TVariation199 +type TNonSpare999 = 'GNonSpare "EMC" "Emitter Category" TRuleVariation191 +type TNonSpare1242 = 'GNonSpare "LAT" "Latitude in WGS.84 in Two's Complement Form" TRuleVariation366 +type TItem498 = 'GItem TNonSpare1242 +type TNonSpare1275 = 'GNonSpare "LON" "Longitude in WGS.84 in Two's Complement Form" TRuleVariation364 +type TItem529 = 'GItem TNonSpare1275 +type TVariation1193 = 'GGroup 0 '[ TItem498, TItem529] +type TRuleVariation1144 = 'GContextFree TVariation1193 +type TNonSpare1570 = 'GNonSpare "POS" "Position" TRuleVariation1144 +type TNonSpare1095 = 'GNonSpare "GAL" "Geometric Altitude" TRuleVariation298 +type TNonSpare1609 = 'GNonSpare "PUN" "Position Uncertainty" TRuleVariation796 +type TItem775 = 'GItem TNonSpare1609 +type TVariation1072 = 'GGroup 0 '[ TItem3, TItem775] +type TRuleVariation1039 = 'GContextFree TVariation1072 +type TNonSpare1610 = 'GNonSpare "PUN" "Position Uncertainty" TRuleVariation1039 +type TNonSpare1332 = 'GNonSpare "MB" "MODE S MB DATA" TRuleVariation1395 +type TContent745 = 'GContentQuantity 'GUnsigned ('GNumInt ('GZ 'GPlus 1)) "kt" +type TRuleContent743 = 'GContextFree TContent745 +type TVariation317 = 'GElement 0 16 TRuleContent743 +type TRuleVariation309 = 'GContextFree TVariation317 +type TNonSpare1178 = 'GNonSpare "IAR" "Indicated Airspeed" TRuleVariation309 +type TContent779 = 'GContentQuantity 'GUnsigned ('GNumDiv ('GNumInt ('GZ 'GPlus 1)) ('GNumInt ('GZ 'GPlus 125))) "Mach" +type TRuleContent777 = 'GContextFree TContent779 +type TVariation333 = 'GElement 0 16 TRuleContent777 +type TRuleVariation325 = 'GContextFree TVariation333 +type TNonSpare1320 = 'GNonSpare "MAC" "Mach Number" TRuleVariation325 +type TContent770 = 'GContentQuantity 'GUnsigned ('GNumDiv ('GNumInt ('GZ 'GPlus 1)) ('GNumInt ('GZ 'GPlus 10))) "mb" +type TRuleContent768 = 'GContextFree TContent770 +type TVariation842 = 'GElement 4 12 TRuleContent768 +type TRuleVariation811 = 'GContextFree TVariation842 +type TNonSpare747 = 'GNonSpare "BPS" "" TRuleVariation811 +type TItem136 = 'GItem TNonSpare747 +type TVariation1059 = 'GGroup 0 '[ TItem3, TItem136] +type TRuleVariation1028 = 'GContextFree TVariation1059 +type TNonSpare751 = 'GNonSpare "BPS" "Barometric Pressure Setting (derived from Mode S BDS 4,0)" TRuleVariation1028 +type TVariation1546 = 'GCompound '[ 'Just TNonSpare623, 'Just TNonSpare1189, 'Just TNonSpare1388, 'Just TNonSpare1182, 'Just TNonSpare1995, 'Just TNonSpare1798, 'Just TNonSpare1077, 'Just TNonSpare2038, 'Just TNonSpare2033, 'Just TNonSpare855, 'Just TNonSpare1792, 'Just TNonSpare615, 'Just TNonSpare753, 'Just TNonSpare1127, 'Just TNonSpare1674, 'Just TNonSpare1990, 'Just TNonSpare1985, 'Just TNonSpare1116, 'Just TNonSpare2234, 'Just TNonSpare1379, 'Just TNonSpare999, 'Just TNonSpare1570, 'Just TNonSpare1095, 'Just TNonSpare1610, 'Just TNonSpare1332, 'Just TNonSpare1178, 'Just TNonSpare1320, 'Just TNonSpare751] +type TRuleVariation1462 = 'GContextFree TVariation1546 +type TNonSpare525 = 'GNonSpare "380" "Aircraft Derived Data" TRuleVariation1462 +type TUapItem525 = 'GUapItem TNonSpare525 +type TNonSpare155 = 'GNonSpare "040" "Track Number" TRuleVariation259 +type TUapItem155 = 'GUapItem TNonSpare155 +type TContent311 = 'GContentTable '[ '(0, "Multisensor track"), '(1, "Monosensor track")] +type TRuleContent309 = 'GContextFree TContent311 +type TVariation57 = 'GElement 0 1 TRuleContent309 +type TRuleVariation57 = 'GContextFree TVariation57 +type TNonSpare1422 = 'GNonSpare "MON" "" TRuleVariation57 +type TItem626 = 'GItem TNonSpare1422 +type TNonSpare1425 = 'GNonSpare "MRH" "Most Reliable Height" TRuleVariation516 +type TItem629 = 'GItem TNonSpare1425 +type TContent389 = 'GContentTable '[ '(0, "No source"), '(1, "GNSS"), '(2, "3D radar"), '(3, "Triangulation"), '(4, "Height from coverage"), '(5, "Speed look-up table"), '(6, "Default height"), '(7, "Multilateration")] +type TRuleContent387 = 'GContextFree TContent389 +type TVariation714 = 'GElement 3 3 TRuleContent387 +type TRuleVariation702 = 'GContextFree TVariation714 +type TNonSpare1909 = 'GNonSpare "SRC" "Source of Calculated Track Altitude for I062/130" TRuleVariation702 +type TItem1002 = 'GItem TNonSpare1909 +type TContent24 = 'GContentTable '[ '(0, "Actual track"), '(1, "Simulated track")] +type TRuleContent24 = 'GContextFree TContent24 +type TVariation7 = 'GElement 0 1 TRuleContent24 +type TRuleVariation7 = 'GContextFree TVariation7 +type TNonSpare1869 = 'GNonSpare "SIM" "" TRuleVariation7 +type TItem967 = 'GItem TNonSpare1869 +type TContent193 = 'GContentTable '[ '(0, "Default value"), '(1, "Last message transmitted to the user for the track")] +type TRuleContent193 = 'GContextFree TContent193 +type TVariation436 = 'GElement 1 1 TRuleContent193 +type TRuleVariation424 = 'GContextFree TVariation436 +type TNonSpare2100 = 'GNonSpare "TSE" "" TRuleVariation424 +type TItem1133 = 'GItem TNonSpare2100 +type TContent191 = 'GContentTable '[ '(0, "Default value"), '(1, "First message transmitted to the user for the track")] +type TRuleContent191 = 'GContextFree TContent191 +type TVariation548 = 'GElement 2 1 TRuleContent191 +type TRuleVariation536 = 'GContextFree TVariation548 +type TNonSpare2098 = 'GNonSpare "TSB" "" TRuleVariation536 +type TItem1131 = 'GItem TNonSpare2098 +type TContent197 = 'GContentTable '[ '(0, "Default value"), '(1, "Slave Track Promotion")] +type TRuleContent197 = 'GContextFree TContent197 +type TVariation875 = 'GElement 5 1 TRuleContent197 +type TRuleVariation844 = 'GContextFree TVariation875 +type TNonSpare1958 = 'GNonSpare "STP" "" TRuleVariation844 +type TItem1037 = 'GItem TNonSpare1958 +type TContent64 = 'GContentTable '[ '(0, "Complementary service used"), '(1, "Background service used")] +type TRuleContent64 = 'GContextFree TContent64 +type TVariation935 = 'GElement 6 1 TRuleContent64 +type TRuleVariation904 = 'GContextFree TVariation935 +type TNonSpare1209 = 'GNonSpare "KOS" "" TRuleVariation904 +type TItem465 = 'GItem TNonSpare1209 +type TVariation485 = 'GElement 1 2 TRuleContent321 +type TRuleVariation473 = 'GContextFree TVariation485 +type TNonSpare1352 = 'GNonSpare "MD4" "" TRuleVariation473 +type TItem584 = 'GItem TNonSpare1352 +type TVariation656 = 'GElement 3 1 TRuleContent194 +type TRuleVariation644 = 'GContextFree TVariation656 +type TNonSpare1373 = 'GNonSpare "ME" "" TRuleVariation644 +type TItem591 = 'GItem TNonSpare1373 +type TContent195 = 'GContentTable '[ '(0, "Default value"), '(1, "Military Identification present in the last report received from a sensor capable of decoding this data")] +type TRuleContent195 = 'GContextFree TContent195 +type TVariation744 = 'GElement 4 1 TRuleContent195 +type TRuleVariation732 = 'GContextFree TVariation744 +type TNonSpare1392 = 'GNonSpare "MI" "" TRuleVariation732 +type TItem598 = 'GItem TNonSpare1392 +type TContent326 = 'GContentTable '[ '(0, "No Mode 5 interrogation"), '(1, "Friendly target"), '(2, "Unknown target"), '(3, "No reply")] +type TRuleContent324 = 'GContextFree TContent326 +type TVariation912 = 'GElement 5 2 TRuleContent324 +type TRuleVariation881 = 'GContextFree TVariation912 +type TNonSpare1354 = 'GNonSpare "MD5" "" TRuleVariation881 +type TItem585 = 'GItem TNonSpare1354 +type TVariation40 = 'GElement 0 1 TRuleContent185 +type TRuleVariation40 = 'GContextFree TVariation40 +type TNonSpare906 = 'GNonSpare "CST" "" TRuleVariation40 +type TItem237 = 'GItem TNonSpare906 +type TContent179 = 'GContentTable '[ '(0, "Default value"), '(1, "Age of the last received ADS-B track update is higher than system dependent threshold")] +type TRuleContent179 = 'GContextFree TContent179 +type TVariation743 = 'GElement 4 1 TRuleContent179 +type TRuleVariation731 = 'GContextFree TVariation743 +type TNonSpare625 = 'GNonSpare "ADS" "" TRuleVariation731 +type TItem49 = 'GItem TNonSpare625 +type TContent186 = 'GContentTable '[ '(0, "Default value"), '(1, "Assigned Mode A Code Conflict (same discrete Mode A Code assigned to another track)")] +type TRuleContent186 = 'GContextFree TContent186 +type TVariation953 = 'GElement 6 1 TRuleContent186 +type TRuleVariation922 = 'GContextFree TVariation953 +type TNonSpare599 = 'GNonSpare "AAC" "" TRuleVariation922 +type TItem36 = 'GItem TNonSpare599 +type TContent62 = 'GContentTable '[ '(0, "Combined"), '(1, "Co-operative only"), '(2, "Non-Cooperative only"), '(3, "Not defined")] +type TRuleContent62 = 'GContextFree TContent62 +type TVariation105 = 'GElement 0 2 TRuleContent62 +type TRuleVariation105 = 'GContextFree TVariation105 +type TNonSpare1836 = 'GNonSpare "SDS" "" TRuleVariation105 +type TItem939 = 'GItem TNonSpare1836 +type TContent370 = 'GContentTable '[ '(0, "No emergency"), '(1, "General emergency"), '(2, "Lifeguard / medical"), '(3, "Minimum fuel"), '(4, "No communications"), '(5, "Unlawful interference"), '(6, "Downed Aircraft"), '(7, "Undefined")] +type TRuleContent368 = 'GContextFree TContent370 +type TVariation619 = 'GElement 2 3 TRuleContent368 +type TRuleVariation607 = 'GContextFree TVariation619 +type TNonSpare1003 = 'GNonSpare "EMS" "" TRuleVariation607 +type TItem311 = 'GItem TNonSpare1003 +type TContent381 = 'GContentTable '[ '(0, "No indication"), '(1, "Potential False Track Indication")] +type TRuleContent379 = 'GContextFree TContent381 +type TVariation893 = 'GElement 5 1 TRuleContent379 +type TRuleVariation862 = 'GContextFree TVariation893 +type TNonSpare1545 = 'GNonSpare "PFT" "" TRuleVariation862 +type TItem734 = 'GItem TNonSpare1545 +type TContent200 = 'GContentTable '[ '(0, "Default value"), '(1, "Track created / updated with FPL data")] +type TRuleContent200 = 'GContextFree TContent200 +type TVariation955 = 'GElement 6 1 TRuleContent200 +type TRuleVariation924 = 'GContextFree TVariation955 +type TNonSpare1064 = 'GNonSpare "FPLT" "" TRuleVariation924 +type TItem361 = 'GItem TNonSpare1064 +type TContent190 = 'GContentTable '[ '(0, "Default value"), '(1, "Duplicate Mode 3/A Code")] +type TRuleContent190 = 'GContextFree TContent190 +type TVariation41 = 'GElement 0 1 TRuleContent190 +type TRuleVariation41 = 'GContextFree TVariation41 +type TNonSpare982 = 'GNonSpare "DUPT" "" TRuleVariation41 +type TItem300 = 'GItem TNonSpare982 +type TContent188 = 'GContentTable '[ '(0, "Default value"), '(1, "Duplicate Flight Plan")] +type TRuleContent188 = 'GContextFree TContent188 +type TVariation435 = 'GElement 1 1 TRuleContent188 +type TRuleVariation423 = 'GContextFree TVariation435 +type TNonSpare980 = 'GNonSpare "DUPF" "" TRuleVariation423 +type TItem298 = 'GItem TNonSpare980 +type TContent189 = 'GContentTable '[ '(0, "Default value"), '(1, "Duplicate Flight Plan due to manual correlation")] +type TRuleContent189 = 'GContextFree TContent189 +type TVariation547 = 'GElement 2 1 TRuleContent189 +type TRuleVariation535 = 'GContextFree TVariation547 +type TNonSpare981 = 'GNonSpare "DUPM" "" TRuleVariation535 +type TItem299 = 'GItem TNonSpare981 +type TVariation1439 = 'GExtended '[ 'Just TItem626, 'Just TItem989, 'Just TItem629, 'Just TItem1002, 'Just TItem182, 'Nothing, 'Just TItem967, 'Just TItem1133, 'Just TItem1131, 'Just TItem360, 'Just TItem53, 'Just TItem1037, 'Just TItem465, 'Nothing, 'Just TItem74, 'Just TItem584, 'Just TItem591, 'Just TItem598, 'Just TItem585, 'Nothing, 'Just TItem237, 'Just TItem769, 'Just TItem1008, 'Just TItem586, 'Just TItem49, 'Just TItem1043, 'Just TItem36, 'Nothing, 'Just TItem939, 'Just TItem311, 'Just TItem734, 'Just TItem361, 'Nothing, 'Just TItem300, 'Just TItem298, 'Just TItem299, 'Just TItem18, 'Nothing] +type TRuleVariation1355 = 'GContextFree TVariation1439 +type TNonSpare250 = 'GNonSpare "080" "Track Status" TRuleVariation1355 +type TUapItem250 = 'GUapItem TNonSpare250 +type TContent790 = 'GContentQuantity 'GUnsigned ('GNumDiv ('GNumInt ('GZ 'GPlus 1)) ('GNumPow ('GZ 'GPlus 2) ('GZ 'GPlus 2))) "s" +type TRuleContent787 = 'GContextFree TContent790 +type TVariation250 = 'GElement 0 8 TRuleContent787 +type TRuleVariation242 = 'GContextFree TVariation250 +type TNonSpare2088 = 'GNonSpare "TRK" "Track Age" TRuleVariation242 +type TNonSpare1601 = 'GNonSpare "PSR" "PSR Age" TRuleVariation242 +type TNonSpare1923 = 'GNonSpare "SSR" "SSR Age" TRuleVariation242 +type TNonSpare1368 = 'GNonSpare "MDS" "Mode S Age" TRuleVariation242 +type TContent791 = 'GContentQuantity 'GUnsigned ('GNumDiv ('GNumInt ('GZ 'GPlus 1)) ('GNumPow ('GZ 'GPlus 2) ('GZ 'GPlus 2))) "s" +type TRuleContent788 = 'GContextFree TContent791 +type TVariation341 = 'GElement 0 16 TRuleContent788 +type TRuleVariation333 = 'GContextFree TVariation341 +type TNonSpare627 = 'GNonSpare "ADS" "ADS-C Age" TRuleVariation333 +type TNonSpare1036 = 'GNonSpare "ES" "ADS-B Extended Squitter Age" TRuleVariation242 +type TNonSpare2217 = 'GNonSpare "VDL" "ADS-B VDL Mode 4 Age" TRuleVariation242 +type TNonSpare2152 = 'GNonSpare "UAT" "ADS-B UAT Age" TRuleVariation242 +type TNonSpare1280 = 'GNonSpare "LOP" "Loop Age" TRuleVariation242 +type TNonSpare1402 = 'GNonSpare "MLT" "Multilateration Age" TRuleVariation242 +type TVariation1605 = 'GCompound '[ 'Just TNonSpare2088, 'Just TNonSpare1601, 'Just TNonSpare1923, 'Just TNonSpare1368, 'Just TNonSpare627, 'Just TNonSpare1036, 'Just TNonSpare2217, 'Just TNonSpare2152, 'Just TNonSpare1280, 'Just TNonSpare1402] +type TRuleVariation1521 = 'GContextFree TVariation1605 +type TNonSpare508 = 'GNonSpare "290" "System Track Update Ages" TRuleVariation1521 +type TUapItem508 = 'GUapItem TNonSpare508 +type TContent72 = 'GContentTable '[ '(0, "Constant course"), '(1, "Right turn"), '(2, "Left turn"), '(3, "Undetermined")] +type TRuleContent72 = 'GContextFree TContent72 +type TVariation106 = 'GElement 0 2 TRuleContent72 +type TRuleVariation106 = 'GContextFree TVariation106 +type TNonSpare2076 = 'GNonSpare "TRANS" "Transversal Acceleration" TRuleVariation106 +type TItem1115 = 'GItem TNonSpare2076 +type TContent73 = 'GContentTable '[ '(0, "Constant groundspeed"), '(1, "Increasing groundspeed"), '(2, "Decreasing groundspeed"), '(3, "Undetermined")] +type TRuleContent73 = 'GContextFree TContent73 +type TVariation608 = 'GElement 2 2 TRuleContent73 +type TRuleVariation596 = 'GContextFree TVariation608 +type TNonSpare1276 = 'GNonSpare "LONG" "Longitudinal Acceleration" TRuleVariation596 +type TItem530 = 'GItem TNonSpare1276 +type TContent266 = 'GContentTable '[ '(0, "Level"), '(1, "Climb"), '(2, "Descent"), '(3, "Undetermined")] +type TRuleContent264 = 'GContextFree TContent266 +type TVariation792 = 'GElement 4 2 TRuleContent264 +type TRuleVariation780 = 'GContextFree TVariation792 +type TNonSpare2221 = 'GNonSpare "VERT" "Vertical Rate" TRuleVariation780 +type TItem1245 = 'GItem TNonSpare2221 +type TContent340 = 'GContentTable '[ '(0, "No altitude discrepancy"), '(1, "Altitude discrepancy")] +type TRuleContent338 = 'GContextFree TContent340 +type TVariation973 = 'GElement 6 1 TRuleContent338 +type TRuleVariation942 = 'GContextFree TVariation973 +type TNonSpare621 = 'GNonSpare "ADF" "Altitude Discrepancy Flag" TRuleVariation942 +type TItem47 = 'GItem TNonSpare621 +type TVariation1292 = 'GGroup 0 '[ TItem1115, TItem530, TItem1245, TItem47, TItem29] +type TRuleVariation1225 = 'GContextFree TVariation1292 +type TNonSpare420 = 'GNonSpare "200" "Mode of Movement" TRuleVariation1225 +type TUapItem420 = 'GUapItem TNonSpare420 +type TNonSpare1384 = 'GNonSpare "MFL" "Measured Flight Level Age" TRuleVariation242 +type TNonSpare1348 = 'GNonSpare "MD1" "Mode 1 Age" TRuleVariation242 +type TNonSpare1351 = 'GNonSpare "MD2" "Mode 2 Age" TRuleVariation242 +type TNonSpare1361 = 'GNonSpare "MDA" "Mode 3/A Age" TRuleVariation242 +type TNonSpare1353 = 'GNonSpare "MD4" "Mode 4 Age" TRuleVariation242 +type TNonSpare1355 = 'GNonSpare "MD5" "Mode 5 Age" TRuleVariation242 +type TNonSpare1389 = 'GNonSpare "MHG" "Magnetic Heading Age" TRuleVariation242 +type TNonSpare1181 = 'GNonSpare "IAS" "Indicated Airspeed / Mach Nb Age" TRuleVariation242 +type TNonSpare1996 = 'GNonSpare "TAS" "True Airspeed Age" TRuleVariation242 +type TNonSpare1800 = 'GNonSpare "SAL" "Selected Altitude Age" TRuleVariation242 +type TNonSpare1078 = 'GNonSpare "FSS" "Final State Selected Altitude Age" TRuleVariation242 +type TNonSpare2031 = 'GNonSpare "TID" "Trajectory Intent Age" TRuleVariation242 +type TNonSpare850 = 'GNonSpare "COM" "Communication/ACAS Capability and Flight Status Age" TRuleVariation242 +type TNonSpare1793 = 'GNonSpare "SAB" "Status Reported by ADS-B Age" TRuleVariation242 +type TNonSpare616 = 'GNonSpare "ACS" "ACAS Resolution Advisory Report Age" TRuleVariation242 +type TNonSpare756 = 'GNonSpare "BVR" "Barometric Vertical Rate Age" TRuleVariation242 +type TNonSpare1130 = 'GNonSpare "GVR" "Geometrical Vertical Rate Age" TRuleVariation242 +type TNonSpare1675 = 'GNonSpare "RAN" "Roll Angle Age" TRuleVariation242 +type TNonSpare1992 = 'GNonSpare "TAR" "Track Angle Rate Age" TRuleVariation242 +type TNonSpare1986 = 'GNonSpare "TAN" "Track Angle Age" TRuleVariation242 +type TNonSpare1121 = 'GNonSpare "GSP" "Ground Speed Age" TRuleVariation242 +type TNonSpare2235 = 'GNonSpare "VUN" "Velocity Uncertainty Age" TRuleVariation242 +type TNonSpare1380 = 'GNonSpare "MET" "Meteorological Data Age" TRuleVariation242 +type TNonSpare1000 = 'GNonSpare "EMC" "Emitter Category Age" TRuleVariation242 +type TNonSpare1572 = 'GNonSpare "POS" "Position Age" TRuleVariation242 +type TNonSpare1097 = 'GNonSpare "GAL" "Geometric Altitude Age" TRuleVariation242 +type TNonSpare1612 = 'GNonSpare "PUN" "Position Uncertainty Age" TRuleVariation242 +type TNonSpare1334 = 'GNonSpare "MB" "Mode S MB Data Age" TRuleVariation242 +type TNonSpare1179 = 'GNonSpare "IAR" "Indicated Airspeed Data Age" TRuleVariation242 +type TNonSpare1321 = 'GNonSpare "MAC" "Mach Number Data Age" TRuleVariation242 +type TNonSpare752 = 'GNonSpare "BPS" "Barometric Pressure Setting Data Age" TRuleVariation242 +type TVariation1581 = 'GCompound '[ 'Just TNonSpare1384, 'Just TNonSpare1348, 'Just TNonSpare1351, 'Just TNonSpare1361, 'Just TNonSpare1353, 'Just TNonSpare1355, 'Just TNonSpare1389, 'Just TNonSpare1181, 'Just TNonSpare1996, 'Just TNonSpare1800, 'Just TNonSpare1078, 'Just TNonSpare2031, 'Just TNonSpare850, 'Just TNonSpare1793, 'Just TNonSpare616, 'Just TNonSpare756, 'Just TNonSpare1130, 'Just TNonSpare1675, 'Just TNonSpare1992, 'Just TNonSpare1986, 'Just TNonSpare1121, 'Just TNonSpare2235, 'Just TNonSpare1380, 'Just TNonSpare1000, 'Just TNonSpare1572, 'Just TNonSpare1097, 'Just TNonSpare1612, 'Just TNonSpare1334, 'Just TNonSpare1179, 'Just TNonSpare1321, 'Just TNonSpare752] +type TRuleVariation1497 = 'GContextFree TVariation1581 +type TNonSpare513 = 'GNonSpare "295" "Track Data Ages" TRuleVariation1497 +type TUapItem513 = 'GUapItem TNonSpare513 +type TVariation287 = 'GElement 0 16 TRuleContent681 +type TRuleVariation279 = 'GContextFree TVariation287 +type TNonSpare341 = 'GNonSpare "136" "Measured Flight Level" TRuleVariation279 +type TUapItem341 = 'GUapItem TNonSpare341 +type TNonSpare325 = 'GNonSpare "130" "Calculated Track Geometric Altitude" TRuleVariation298 +type TUapItem325 = 'GUapItem TNonSpare325 +type TNonSpare1654 = 'GNonSpare "QNH" "" TRuleVariation61 +type TItem816 = 'GItem TNonSpare1654 +type TNonSpare915 = 'GNonSpare "CTB" "Calculated Track Barometric Altitude" TRuleVariation505 +type TItem245 = 'GItem TNonSpare915 +type TVariation1226 = 'GGroup 0 '[ TItem816, TItem245] +type TRuleVariation1172 = 'GContextFree TVariation1226 +type TNonSpare340 = 'GNonSpare "135" "Calculated Track Barometric Altitude" TRuleVariation1172 +type TUapItem340 = 'GUapItem TNonSpare340 +type TNonSpare450 = 'GNonSpare "220" "Calculated Rate of Climb/Descent" TRuleVariation299 +type TUapItem450 = 'GUapItem TNonSpare450 +type TNonSpare1984 = 'GNonSpare "TAG" "FPPS Identification Tag" TRuleVariation1196 +type TNonSpare900 = 'GNonSpare "CS" "Callsign" TRuleVariation398 +type TNonSpare1471 = 'GNonSpare "NBR" "Number from 0 to 99 999 999" TRuleVariation896 +type TItem667 = 'GItem TNonSpare1471 +type TVariation1297 = 'GGroup 0 '[ TItem1160, TItem13, TItem667] +type TRuleVariation1230 = 'GContextFree TVariation1297 +type TNonSpare1196 = 'GNonSpare "IFI" "IFPS_FLIGHT_ID" TRuleVariation1230 +type TNonSpare1067 = 'GNonSpare "FR1FR2" "" TRuleVariation597 +type TItem363 = 'GItem TNonSpare1067 +type TVariation1165 = 'GGroup 0 '[ TItem384, TItem363, TItem906, TItem423, TItem29] +type TRuleVariation1118 = 'GContextFree TVariation1165 +type TNonSpare1045 = 'GNonSpare "FCT" "Flight Category" TRuleVariation1118 +type TNonSpare1983 = 'GNonSpare "TAC" "Type of Aircraft" TRuleVariation380 +type TNonSpare2259 = 'GNonSpare "WTC" "Wake Turbulence Category" TRuleVariation209 +type TNonSpare948 = 'GNonSpare "DEP" "Departure Airport" TRuleVariation380 +type TNonSpare973 = 'GNonSpare "DST" "Destination Airport" TRuleVariation380 +type TNonSpare917 = 'GNonSpare "CTL" "Current Control Position" TRuleVariation1074 +type TNonSpare2135 = 'GNonSpare "TYP" "" TRuleVariation154 +type TItem1165 = 'GItem TNonSpare2135 +type TNonSpare1152 = 'GNonSpare "HOR" "Hours" TRuleVariation709 +type TItem421 = 'GItem TNonSpare1152 +type TNonSpare1396 = 'GNonSpare "MIN" "Minutes" TRuleVariation609 +type TItem602 = 'GItem TNonSpare1396 +type TNonSpare706 = 'GNonSpare "AVS" "Seconds Available Flag" TRuleVariation78 +type TItem100 = 'GItem TNonSpare706 +type TNonSpare1841 = 'GNonSpare "SEC" "Seconds" TRuleVariation609 +type TItem943 = 'GItem TNonSpare1841 +type TVariation1299 = 'GGroup 0 '[ TItem1165, TItem258, TItem30, TItem421, TItem1, TItem602, TItem100, TItem7, TItem943] +type TVariation1520 = 'GRepetitive ('GRepetitiveRegular 1) TVariation1299 +type TRuleVariation1436 = 'GContextFree TVariation1520 +type TNonSpare2050 = 'GNonSpare "TOD" "Time of Departure / Arrival" TRuleVariation1436 +type TNonSpare1950 = 'GNonSpare "STD" "Standard Instrument Departure" TRuleVariation398 +type TNonSpare1932 = 'GNonSpare "STA" "Standard Instrument Arrival" TRuleVariation398 +type TContent394 = 'GContentTable '[ '(0, "No valid Mode 3/A available"), '(1, "Valid Mode 3/A available")] +type TRuleContent392 = 'GContextFree TContent394 +type TVariation676 = 'GElement 3 1 TRuleContent392 +type TRuleVariation664 = 'GContextFree TVariation676 +type TNonSpare2167 = 'GNonSpare "VA" "" TRuleVariation664 +type TItem1193 = 'GItem TNonSpare2167 +type TVariation1057 = 'GGroup 0 '[ TItem2, TItem1193, TItem622] +type TRuleVariation1026 = 'GContextFree TVariation1057 +type TNonSpare1544 = 'GNonSpare "PEM" "Pre-Emergency Mode 3/A" TRuleVariation1026 +type TNonSpare1543 = 'GNonSpare "PEC" "Pre-Emergency Callsign" TRuleVariation398 +type TVariation1600 = 'GCompound '[ 'Just TNonSpare1984, 'Just TNonSpare900, 'Just TNonSpare1196, 'Just TNonSpare1045, 'Just TNonSpare1983, 'Just TNonSpare2259, 'Just TNonSpare948, 'Just TNonSpare973, 'Just TNonSpare1696, 'Just TNonSpare792, 'Just TNonSpare917, 'Just TNonSpare2050, 'Just TNonSpare692, 'Just TNonSpare1960, 'Just TNonSpare1950, 'Just TNonSpare1932, 'Just TNonSpare1544, 'Just TNonSpare1543] +type TRuleVariation1516 = 'GContextFree TVariation1600 +type TNonSpare534 = 'GNonSpare "390" "Flight Plan Related Data" TRuleVariation1516 +type TUapItem534 = 'GUapItem TNonSpare534 +type TNonSpare498 = 'GNonSpare "270" "Target Size and Orientation" TRuleVariation1350 +type TUapItem498 = 'GUapItem TNonSpare498 +type TContent290 = 'GContentTable '[ '(0, "Mode C altitude code not present or not from Mode 5 reply"), '(1, "Mode C altitude from Mode 5 reply")] +type TRuleContent288 = 'GContextFree TContent290 +type TVariation969 = 'GElement 6 1 TRuleContent288 +type TRuleVariation938 = 'GContextFree TVariation969 +type TNonSpare1340 = 'GNonSpare "MC" "" TRuleVariation938 +type TItem577 = 'GItem TNonSpare1340 +type TContent596 = 'GContentTable '[ '(0, "X-pulse set to zero or no authenticated Data reply or Report received"), '(1, "X-pulse set to one")] +type TRuleContent594 = 'GContextFree TContent596 +type TVariation1027 = 'GElement 7 1 TRuleContent594 +type TRuleVariation996 = 'GContextFree TVariation1027 +type TNonSpare2292 = 'GNonSpare "X" "X-pulse from Mode 5 Data Reply or Report" TRuleVariation996 +type TItem1308 = 'GItem TNonSpare2292 +type TVariation1196 = 'GGroup 0 '[ TItem558, TItem449, TItem253, TItem542, TItem545, TItem549, TItem577, TItem1308] +type TRuleVariation1147 = 'GContextFree TVariation1196 +type TNonSpare1970 = 'GNonSpare "SUM" "Mode 5 Summary" TRuleVariation1147 +type TNonSpare1553 = 'GNonSpare "PMN" "Mode 5 PIN/ National Origin/Mission Code" TRuleVariation1013 +type TNonSpare1566 = 'GNonSpare "POS" "Mode 5 Reported Position" TRuleVariation1133 +type TNonSpare1093 = 'GNonSpare "GA" "Mode 5 GNSS-derived Altitude" TRuleVariation1006 +type TNonSpare997 = 'GNonSpare "EM1" "Extended Mode 1 Reply in Octal Representation" TRuleVariation807 +type TItem308 = 'GItem TNonSpare997 +type TVariation1061 = 'GGroup 0 '[ TItem3, TItem308] +type TRuleVariation1030 = 'GContextFree TVariation1061 +type TNonSpare994 = 'GNonSpare "EM1" "Extended Mode 1 Code in Octal Representation" TRuleVariation1030 +type TNonSpare2054 = 'GNonSpare "TOS" "Time Offset for POS and GA" TRuleVariation222 +type TNonSpare2308 = 'GNonSpare "XP" "X Pulse Presence" TRuleVariation1027 +type TVariation1595 = 'GCompound '[ 'Just TNonSpare1970, 'Just TNonSpare1553, 'Just TNonSpare1566, 'Just TNonSpare1093, 'Just TNonSpare994, 'Just TNonSpare2054, 'Just TNonSpare2308] +type TRuleVariation1511 = 'GContextFree TVariation1595 +type TNonSpare306 = 'GNonSpare "110" "Mode 5 Data Reports and Extended Mode 1 Code" TRuleVariation1511 +type TUapItem306 = 'GUapItem TNonSpare306 +type TVariation1065 = 'GGroup 0 '[ TItem3, TItem616] +type TRuleVariation1033 = 'GContextFree TVariation1065 +type TNonSpare324 = 'GNonSpare "120" "Track Mode 2 Code" TRuleVariation1033 +type TUapItem324 = 'GUapItem TNonSpare324 +type TNonSpare1193 = 'GNonSpare "IDENT" "System Unit Identification" TRuleVariation171 +type TItem454 = 'GItem TNonSpare1193 +type TNonSpare2072 = 'GNonSpare "TRACK" "System Track Number" TRuleVariation257 +type TItem1111 = 'GItem TNonSpare2072 +type TVariation1176 = 'GGroup 0 '[ TItem454, TItem1111] +type TVariation1541 = 'GRepetitive 'GRepetitiveFx TVariation1176 +type TRuleVariation1457 = 'GContextFree TVariation1541 +type TNonSpare568 = 'GNonSpare "510" "Composed Track Number" TRuleVariation1457 +type TUapItem566 = 'GUapItem TNonSpare568 +type TNonSpare2275 = 'GNonSpare "X" "APC (X-Component)" TRuleVariation317 +type TItem1291 = 'GItem TNonSpare2275 +type TNonSpare2329 = 'GNonSpare "Y" "APC (Y-Component)" TRuleVariation317 +type TItem1341 = 'GItem TNonSpare2329 +type TVariation1364 = 'GGroup 0 '[ TItem1291, TItem1341] +type TRuleVariation1288 = 'GContextFree TVariation1364 +type TNonSpare667 = 'GNonSpare "APC" "Estimated Accuracy Of Track Position (Cartesian)" TRuleVariation1288 +type TNonSpare870 = 'GNonSpare "COV" "XY Covariance Component" TRuleVariation271 +type TContent819 = 'GContentQuantity 'GUnsigned ('GNumDiv ('GNumInt ('GZ 'GPlus 180)) ('GNumPow ('GZ 'GPlus 2) ('GZ 'GPlus 25))) "°" +type TRuleContent816 = 'GContextFree TContent819 +type TVariation356 = 'GElement 0 16 TRuleContent816 +type TRuleVariation348 = 'GContextFree TVariation356 +type TNonSpare1227 = 'GNonSpare "LAT" "APW (Latitude Component)" TRuleVariation348 +type TItem483 = 'GItem TNonSpare1227 +type TNonSpare1259 = 'GNonSpare "LON" "APW (Longitude Component)" TRuleVariation348 +type TItem513 = 'GItem TNonSpare1259 +type TVariation1180 = 'GGroup 0 '[ TItem483, TItem513] +type TRuleVariation1131 = 'GContextFree TVariation1180 +type TNonSpare673 = 'GNonSpare "APW" "Estimated Accuracy Of Track Position (WGS-84)" TRuleVariation1131 +type TContent813 = 'GContentQuantity 'GUnsigned ('GNumDiv ('GNumInt ('GZ 'GPlus 25)) ('GNumPow ('GZ 'GPlus 2) ('GZ 'GPlus 2))) "ft" +type TRuleContent810 = 'GContextFree TContent813 +type TVariation255 = 'GElement 0 8 TRuleContent810 +type TRuleVariation247 = 'GContextFree TVariation255 +type TNonSpare632 = 'GNonSpare "AGA" "Estimated Accuracy Of Calculated Track Geometric Altitude" TRuleVariation247 +type TVariation245 = 'GElement 0 8 TRuleContent779 +type TRuleVariation237 = 'GContextFree TVariation245 +type TNonSpare602 = 'GNonSpare "ABA" "Estimated Accuracy Of Calculated Track Barometric Altitude" TRuleVariation237 +type TContent787 = 'GContentQuantity 'GUnsigned ('GNumDiv ('GNumInt ('GZ 'GPlus 1)) ('GNumPow ('GZ 'GPlus 2) ('GZ 'GPlus 2))) "m/s" +type TRuleContent784 = 'GContextFree TContent787 +type TVariation247 = 'GElement 0 8 TRuleContent784 +type TRuleVariation239 = 'GContextFree TVariation247 +type TNonSpare2276 = 'GNonSpare "X" "ATV (X-Component)" TRuleVariation239 +type TItem1292 = 'GItem TNonSpare2276 +type TNonSpare2330 = 'GNonSpare "Y" "ATV (Y-Component)" TRuleVariation239 +type TItem1342 = 'GItem TNonSpare2330 +type TVariation1365 = 'GGroup 0 '[ TItem1292, TItem1342] +type TRuleVariation1289 = 'GContextFree TVariation1365 +type TNonSpare699 = 'GNonSpare "ATV" "Estimated Accuracy Of Track Velocity (Cartesian)" TRuleVariation1289 +type TContent788 = 'GContentQuantity 'GUnsigned ('GNumDiv ('GNumInt ('GZ 'GPlus 1)) ('GNumPow ('GZ 'GPlus 2) ('GZ 'GPlus 2))) "m/s²" +type TRuleContent785 = 'GContextFree TContent788 +type TVariation248 = 'GElement 0 8 TRuleContent785 +type TRuleVariation240 = 'GContextFree TVariation248 +type TNonSpare2274 = 'GNonSpare "X" "AA (X-Component)" TRuleVariation240 +type TItem1290 = 'GItem TNonSpare2274 +type TNonSpare2328 = 'GNonSpare "Y" "AA (Y-Component)" TRuleVariation240 +type TItem1340 = 'GItem TNonSpare2328 +type TVariation1363 = 'GGroup 0 '[ TItem1290, TItem1340] +type TRuleVariation1287 = 'GContextFree TVariation1363 +type TNonSpare598 = 'GNonSpare "AA" "Estimated Accuracy Of Acceleration (Cartesian)" TRuleVariation1287 +type TContent814 = 'GContentQuantity 'GUnsigned ('GNumDiv ('GNumInt ('GZ 'GPlus 25)) ('GNumPow ('GZ 'GPlus 2) ('GZ 'GPlus 2))) "ft/min" +type TRuleContent811 = 'GContextFree TContent814 +type TVariation256 = 'GElement 0 8 TRuleContent811 +type TRuleVariation248 = 'GContextFree TVariation256 +type TNonSpare683 = 'GNonSpare "ARC" "Estimated Accuracy Of Rate Of Climb/Descent" TRuleVariation248 +type TVariation1558 = 'GCompound '[ 'Just TNonSpare667, 'Just TNonSpare870, 'Just TNonSpare673, 'Just TNonSpare632, 'Just TNonSpare602, 'Just TNonSpare699, 'Just TNonSpare598, 'Just TNonSpare683] +type TRuleVariation1474 = 'GContextFree TVariation1558 +type TNonSpare563 = 'GNonSpare "500" "Estimated Accuracies" TRuleVariation1474 +type TUapItem561 = 'GUapItem TNonSpare563 +type TNonSpare1854 = 'GNonSpare "SID" "Sensor Identification" TRuleVariation1196 +type TNonSpare1726 = 'GNonSpare "RHO" "Measured Distance" TRuleVariation342 +type TItem877 = 'GItem TNonSpare1726 +type TNonSpare2022 = 'GNonSpare "THETA" "Measured Azimuth" TRuleVariation349 +type TItem1078 = 'GItem TNonSpare2022 +type TVariation1240 = 'GGroup 0 '[ TItem877, TItem1078] +type TRuleVariation1186 = 'GContextFree TVariation1240 +type TNonSpare1565 = 'GNonSpare "POS" "Measured Position" TRuleVariation1186 +type TNonSpare1142 = 'GNonSpare "HEIGHT" "Measured 3-D Height" TRuleVariation316 +type TContent684 = 'GContentQuantity 'GSigned ('GNumDiv ('GNumInt ('GZ 'GPlus 1)) ('GNumPow ('GZ 'GPlus 2) ('GZ 'GPlus 2))) "FL" +type TRuleContent682 = 'GContextFree TContent684 +type TVariation629 = 'GElement 2 14 TRuleContent682 +type TRuleVariation617 = 'GContextFree TVariation629 +type TNonSpare1253 = 'GNonSpare "LMC" "Last Measured Mode C Code" TRuleVariation617 +type TItem507 = 'GItem TNonSpare1253 +type TVariation1341 = 'GGroup 0 '[ TItem1192, TItem379, TItem507] +type TRuleVariation1265 = 'GContextFree TVariation1341 +type TNonSpare1362 = 'GNonSpare "MDC" "" TRuleVariation1265 +type TContent289 = 'GContentTable '[ '(0, "Mode 3/A code as derived from the reply of the transponder"), '(1, "Mode 3/A code as provided by a sensor local tracker")] +type TRuleContent287 = 'GContextFree TContent289 +type TVariation562 = 'GElement 2 1 TRuleContent287 +type TRuleVariation550 = 'GContextFree TVariation562 +type TNonSpare1212 = 'GNonSpare "L" "" TRuleVariation550 +type TItem468 = 'GItem TNonSpare1212 +type TVariation1336 = 'GGroup 0 '[ TItem1192, TItem379, TItem468, TItem16, TItem622] +type TRuleVariation1260 = 'GContextFree TVariation1336 +type TNonSpare1357 = 'GNonSpare "MDA" "" TRuleVariation1260 +type TNonSpare2140 = 'GNonSpare "TYP" "Report Type" TRuleVariation134 +type TItem1169 = 'GItem TNonSpare2140 +type TContent466 = 'GContentTable '[ '(0, "Report from target transponder"), '(1, "Report from field monitor (item transponder)")] +type TRuleContent464 = 'GContextFree TContent466 +type TVariation777 = 'GElement 4 1 TRuleContent464 +type TRuleVariation765 = 'GContextFree TVariation777 +type TNonSpare1664 = 'GNonSpare "RAB" "" TRuleVariation765 +type TItem824 = 'GItem TNonSpare1664 +type TVariation900 = 'GElement 5 1 TRuleContent458 +type TRuleVariation869 = 'GContextFree TVariation900 +type TNonSpare2108 = 'GNonSpare "TST" "" TRuleVariation869 +type TItem1141 = 'GItem TNonSpare2108 +type TVariation1302 = 'GGroup 0 '[ TItem1169, TItem969, TItem824, TItem1141, TItem27] +type TRuleVariation1233 = 'GContextFree TVariation1302 +type TNonSpare2137 = 'GNonSpare "TYP" "" TRuleVariation1233 +type TVariation1592 = 'GCompound '[ 'Just TNonSpare1854, 'Just TNonSpare1565, 'Just TNonSpare1142, 'Just TNonSpare1362, 'Just TNonSpare1357, 'Just TNonSpare2137] +type TRuleVariation1508 = 'GContextFree TVariation1592 +type TNonSpare522 = 'GNonSpare "340" "Measured Information" TRuleVariation1508 +type TUapItem522 = 'GUapItem TNonSpare522 +type TRecord49 = 'GRecord '[ TUapItem46, TUapItem598, TUapItem59, TUapItem228, TUapItem297, TUapItem283, TUapItem410, TUapItem436, TUapItem211, TUapItem472, TUapItem525, TUapItem155, TUapItem250, TUapItem508, TUapItem420, TUapItem513, TUapItem341, TUapItem325, TUapItem340, TUapItem450, TUapItem534, TUapItem498, TUapItem517, TUapItem306, TUapItem324, TUapItem566, TUapItem561, TUapItem522, TUapItem598, TUapItem598, TUapItem598, TUapItem598, TUapItem598, TUapItem594, TUapItem596] +type TUap43 = 'GUap TRecord49 +type TAsterix59 = 'GAsterixBasic 62 ('GEdition 1 16) TUap43 +type TVariation1334 = 'GGroup 0 '[ TItem1192, TItem379, TItem164, TItem16, TItem622] +type TRuleVariation1258 = 'GContextFree TVariation1334 +type TNonSpare212 = 'GNonSpare "060" "Track Mode 3/A Code" TRuleVariation1258 +type TUapItem212 = 'GUapItem TNonSpare212 +type TNonSpare471 = 'GNonSpare "245" "Target Identification" TRuleVariation1216 +type TUapItem471 = 'GUapItem TNonSpare471 +type TRecord50 = 'GRecord '[ TUapItem46, TUapItem598, TUapItem59, TUapItem228, TUapItem297, TUapItem283, TUapItem410, TUapItem436, TUapItem212, TUapItem471, TUapItem525, TUapItem155, TUapItem250, TUapItem508, TUapItem420, TUapItem513, TUapItem341, TUapItem325, TUapItem340, TUapItem450, TUapItem534, TUapItem498, TUapItem517, TUapItem306, TUapItem324, TUapItem566, TUapItem561, TUapItem522, TUapItem598, TUapItem598, TUapItem598, TUapItem598, TUapItem598, TUapItem594, TUapItem596] +type TUap44 = 'GUap TRecord50 +type TAsterix60 = 'GAsterixBasic 62 ('GEdition 1 17) TUap44 +type TContent338 = 'GContentTable '[ '(0, "No alert, no SPI, aircraft airborne"), '(1, "No alert, no SPI, aircraft on ground"), '(2, "Alert, no SPI, aircraft airborne"), '(3, "Alert, no SPI, aircraft on ground"), '(4, "Alert, SPI, aircraft airborne or on ground"), '(5, "No alert, SPI, aircraft airborne or on ground"), '(6, "Not defined"), '(7, "Unknown or not yet extracted")] +type TRuleContent336 = 'GContextFree TContent338 +type TVariation711 = 'GElement 3 3 TRuleContent336 +type TRuleVariation699 = 'GContextFree TVariation711 +type TNonSpare1939 = 'GNonSpare "STAT" "Flight Status" TRuleVariation699 +type TItem1019 = 'GItem TNonSpare1939 +type TVariation1128 = 'GGroup 0 '[ TItem204, TItem1019, TItem27, TItem1006, TItem84, TItem58, TItem112, TItem115] +type TRuleVariation1083 = 'GContextFree TVariation1128 +type TNonSpare856 = 'GNonSpare "COM" "Communications/ACAS Capability and Flight Status" TRuleVariation1083 +type TVariation1550 = 'GCompound '[ 'Just TNonSpare623, 'Just TNonSpare1189, 'Just TNonSpare1388, 'Just TNonSpare1182, 'Just TNonSpare1995, 'Just TNonSpare1798, 'Just TNonSpare1077, 'Just TNonSpare2038, 'Just TNonSpare2033, 'Just TNonSpare856, 'Just TNonSpare1792, 'Just TNonSpare615, 'Just TNonSpare753, 'Just TNonSpare1127, 'Just TNonSpare1674, 'Just TNonSpare1990, 'Just TNonSpare1985, 'Just TNonSpare1116, 'Just TNonSpare2234, 'Just TNonSpare1379, 'Just TNonSpare999, 'Just TNonSpare1570, 'Just TNonSpare1095, 'Just TNonSpare1610, 'Just TNonSpare1332, 'Just TNonSpare1178, 'Just TNonSpare1320, 'Just TNonSpare751] +type TRuleVariation1466 = 'GContextFree TVariation1550 +type TNonSpare529 = 'GNonSpare "380" "Aircraft Derived Data" TRuleVariation1466 +type TUapItem529 = 'GUapItem TNonSpare529 +type TContent199 = 'GContentTable '[ '(0, "Default value"), '(1, "Surface target")] +type TRuleContent199 = 'GContextFree TContent199 +type TVariation657 = 'GElement 3 1 TRuleContent199 +type TRuleVariation645 = 'GContextFree TVariation657 +type TNonSpare1844 = 'GNonSpare "SFC" "" TRuleVariation645 +type TItem946 = 'GItem TNonSpare1844 +type TContent380 = 'GContentTable '[ '(0, "No indication"), '(1, "Duplicate Flight-ID")] +type TRuleContent378 = 'GContextFree TContent380 +type TVariation766 = 'GElement 4 1 TRuleContent378 +type TRuleVariation754 = 'GContextFree TVariation766 +type TNonSpare1190 = 'GNonSpare "IDD" "" TRuleVariation754 +type TItem451 = 'GItem TNonSpare1190 +type TContent192 = 'GContentTable '[ '(0, "Default value"), '(1, "Inconsistent Emergency Code")] +type TRuleContent192 = 'GContextFree TContent192 +type TVariation873 = 'GElement 5 1 TRuleContent192 +type TRuleVariation842 = 'GContextFree TVariation873 +type TNonSpare1194 = 'GNonSpare "IEC" "" TRuleVariation842 +type TItem455 = 'GItem TNonSpare1194 +type TVariation1440 = 'GExtended '[ 'Just TItem626, 'Just TItem989, 'Just TItem629, 'Just TItem1002, 'Just TItem182, 'Nothing, 'Just TItem967, 'Just TItem1133, 'Just TItem1131, 'Just TItem360, 'Just TItem53, 'Just TItem1037, 'Just TItem465, 'Nothing, 'Just TItem74, 'Just TItem584, 'Just TItem591, 'Just TItem598, 'Just TItem585, 'Nothing, 'Just TItem237, 'Just TItem769, 'Just TItem1008, 'Just TItem586, 'Just TItem49, 'Just TItem1043, 'Just TItem36, 'Nothing, 'Just TItem939, 'Just TItem311, 'Just TItem734, 'Just TItem361, 'Nothing, 'Just TItem300, 'Just TItem298, 'Just TItem299, 'Just TItem946, 'Just TItem451, 'Just TItem455, 'Just TItem26, 'Nothing] +type TRuleVariation1356 = 'GContextFree TVariation1440 +type TNonSpare251 = 'GNonSpare "080" "Track Status" TRuleVariation1356 +type TUapItem251 = 'GUapItem TNonSpare251 +type TRecord53 = 'GRecord '[ TUapItem46, TUapItem598, TUapItem59, TUapItem228, TUapItem297, TUapItem283, TUapItem410, TUapItem436, TUapItem212, TUapItem471, TUapItem529, TUapItem155, TUapItem251, TUapItem508, TUapItem420, TUapItem513, TUapItem341, TUapItem325, TUapItem340, TUapItem450, TUapItem534, TUapItem498, TUapItem517, TUapItem306, TUapItem324, TUapItem566, TUapItem561, TUapItem522, TUapItem598, TUapItem598, TUapItem598, TUapItem598, TUapItem598, TUapItem594, TUapItem596] +type TUap47 = 'GUap TRecord53 +type TAsterix61 = 'GAsterixBasic 62 ('GEdition 1 18) TUap47 +type TNonSpare749 = 'GNonSpare "BPS" "Barometric Pressure Setting" TRuleVariation1028 +type TVariation1549 = 'GCompound '[ 'Just TNonSpare623, 'Just TNonSpare1189, 'Just TNonSpare1388, 'Just TNonSpare1182, 'Just TNonSpare1995, 'Just TNonSpare1798, 'Just TNonSpare1077, 'Just TNonSpare2038, 'Just TNonSpare2033, 'Just TNonSpare856, 'Just TNonSpare1792, 'Just TNonSpare615, 'Just TNonSpare753, 'Just TNonSpare1127, 'Just TNonSpare1674, 'Just TNonSpare1990, 'Just TNonSpare1985, 'Just TNonSpare1116, 'Just TNonSpare2234, 'Just TNonSpare1379, 'Just TNonSpare999, 'Just TNonSpare1570, 'Just TNonSpare1095, 'Just TNonSpare1610, 'Just TNonSpare1332, 'Just TNonSpare1178, 'Just TNonSpare1320, 'Just TNonSpare749] +type TRuleVariation1465 = 'GContextFree TVariation1549 +type TNonSpare528 = 'GNonSpare "380" "Aircraft Derived Data" TRuleVariation1465 +type TUapItem528 = 'GUapItem TNonSpare528 +type TContent784 = 'GContentQuantity 'GUnsigned ('GNumDiv ('GNumInt ('GZ 'GPlus 1)) ('GNumPow ('GZ 'GPlus 2) ('GZ 'GPlus 2))) "FL" +type TRuleContent781 = 'GContextFree TContent784 +type TVariation337 = 'GElement 0 16 TRuleContent781 +type TRuleVariation329 = 'GContextFree TVariation337 +type TNonSpare793 = 'GNonSpare "CFL" "Current Cleared Flight Level" TRuleVariation329 +type TVariation1601 = 'GCompound '[ 'Just TNonSpare1984, 'Just TNonSpare900, 'Just TNonSpare1196, 'Just TNonSpare1045, 'Just TNonSpare1983, 'Just TNonSpare2259, 'Just TNonSpare948, 'Just TNonSpare973, 'Just TNonSpare1696, 'Just TNonSpare793, 'Just TNonSpare917, 'Just TNonSpare2050, 'Just TNonSpare692, 'Just TNonSpare1960, 'Just TNonSpare1950, 'Just TNonSpare1932, 'Just TNonSpare1544, 'Just TNonSpare1543] +type TRuleVariation1517 = 'GContextFree TVariation1601 +type TNonSpare535 = 'GNonSpare "390" "Flight Plan Related Data" TRuleVariation1517 +type TUapItem535 = 'GUapItem TNonSpare535 +type TNonSpare1141 = 'GNonSpare "HEIGHT" "Measured 3-D Height" TRuleVariation268 +type TVariation1591 = 'GCompound '[ 'Just TNonSpare1854, 'Just TNonSpare1565, 'Just TNonSpare1141, 'Just TNonSpare1362, 'Just TNonSpare1357, 'Just TNonSpare2137] +type TRuleVariation1507 = 'GContextFree TVariation1591 +type TNonSpare521 = 'GNonSpare "340" "Measured Information" TRuleVariation1507 +type TUapItem521 = 'GUapItem TNonSpare521 +type TRecord52 = 'GRecord '[ TUapItem46, TUapItem598, TUapItem59, TUapItem228, TUapItem297, TUapItem283, TUapItem410, TUapItem436, TUapItem212, TUapItem471, TUapItem528, TUapItem155, TUapItem251, TUapItem508, TUapItem420, TUapItem513, TUapItem341, TUapItem325, TUapItem340, TUapItem450, TUapItem535, TUapItem498, TUapItem517, TUapItem306, TUapItem324, TUapItem566, TUapItem561, TUapItem521, TUapItem598, TUapItem598, TUapItem598, TUapItem598, TUapItem598, TUapItem594, TUapItem596] +type TUap46 = 'GUap TRecord52 +type TAsterix62 = 'GAsterixBasic 62 ('GEdition 1 19) TUap46 +type TNonSpare735 = 'GNonSpare "BDSDATA" "BDS Register DATA" TRuleVariation1395 +type TVariation1548 = 'GCompound '[ 'Just TNonSpare623, 'Just TNonSpare1189, 'Just TNonSpare1388, 'Just TNonSpare1182, 'Just TNonSpare1995, 'Just TNonSpare1798, 'Just TNonSpare1077, 'Just TNonSpare2038, 'Just TNonSpare2033, 'Just TNonSpare856, 'Just TNonSpare1792, 'Just TNonSpare615, 'Just TNonSpare753, 'Just TNonSpare1127, 'Just TNonSpare1674, 'Just TNonSpare1990, 'Just TNonSpare1985, 'Just TNonSpare1116, 'Just TNonSpare2234, 'Just TNonSpare1379, 'Just TNonSpare999, 'Just TNonSpare1570, 'Just TNonSpare1095, 'Just TNonSpare1610, 'Just TNonSpare735, 'Just TNonSpare1178, 'Just TNonSpare1320, 'Just TNonSpare749] +type TRuleVariation1464 = 'GContextFree TVariation1548 +type TNonSpare527 = 'GNonSpare "380" "Aircraft Derived Data" TRuleVariation1464 +type TUapItem527 = 'GUapItem TNonSpare527 +type TContent180 = 'GContentTable '[ '(0, "Default value"), '(1, "Age of the last received MLAT track updateis higher than system dependent threshold")] +type TRuleContent180 = 'GContextFree TContent180 +type TVariation952 = 'GElement 6 1 TRuleContent180 +type TRuleVariation921 = 'GContextFree TVariation952 +type TNonSpare1400 = 'GNonSpare "MLAT" "" TRuleVariation921 +type TItem605 = 'GItem TNonSpare1400 +type TVariation1441 = 'GExtended '[ 'Just TItem626, 'Just TItem989, 'Just TItem629, 'Just TItem1002, 'Just TItem182, 'Nothing, 'Just TItem967, 'Just TItem1133, 'Just TItem1131, 'Just TItem360, 'Just TItem53, 'Just TItem1037, 'Just TItem465, 'Nothing, 'Just TItem74, 'Just TItem584, 'Just TItem591, 'Just TItem598, 'Just TItem585, 'Nothing, 'Just TItem237, 'Just TItem769, 'Just TItem1008, 'Just TItem586, 'Just TItem49, 'Just TItem1043, 'Just TItem36, 'Nothing, 'Just TItem939, 'Just TItem311, 'Just TItem734, 'Just TItem361, 'Nothing, 'Just TItem300, 'Just TItem298, 'Just TItem299, 'Just TItem946, 'Just TItem451, 'Just TItem455, 'Just TItem605, 'Nothing] +type TRuleVariation1357 = 'GContextFree TVariation1441 +type TNonSpare252 = 'GNonSpare "080" "Track Status" TRuleVariation1357 +type TUapItem252 = 'GUapItem TNonSpare252 +type TRecord51 = 'GRecord '[ TUapItem46, TUapItem598, TUapItem59, TUapItem228, TUapItem297, TUapItem283, TUapItem410, TUapItem436, TUapItem212, TUapItem471, TUapItem527, TUapItem155, TUapItem252, TUapItem508, TUapItem420, TUapItem513, TUapItem341, TUapItem325, TUapItem340, TUapItem450, TUapItem535, TUapItem498, TUapItem517, TUapItem306, TUapItem324, TUapItem566, TUapItem561, TUapItem521, TUapItem598, TUapItem598, TUapItem598, TUapItem598, TUapItem598, TUapItem594, TUapItem596] +type TUap45 = 'GUap TRecord51 +type TAsterix63 = 'GAsterixBasic 62 ('GEdition 1 20) TUap45 +type TNonSpare296 = 'GNonSpare "105" "Calculated Position In WGS-84 Co-ordinates" TRuleVariation1135 +type TUapItem296 = 'GUapItem TNonSpare296 +type TNonSpare411 = 'GNonSpare "185" "Calculated Track Velocity (Cartesian)" TRuleVariation1269 +type TUapItem411 = 'GUapItem TNonSpare411 +type TNonSpare614 = 'GNonSpare "ACS" "ACAS Resolution Advisory Report" TRuleVariation400 +type TVariation1547 = 'GCompound '[ 'Just TNonSpare623, 'Just TNonSpare1189, 'Just TNonSpare1388, 'Just TNonSpare1182, 'Just TNonSpare1995, 'Just TNonSpare1798, 'Just TNonSpare1077, 'Just TNonSpare2038, 'Just TNonSpare2033, 'Just TNonSpare856, 'Just TNonSpare1792, 'Just TNonSpare614, 'Just TNonSpare753, 'Just TNonSpare1127, 'Just TNonSpare1674, 'Just TNonSpare1990, 'Just TNonSpare1985, 'Just TNonSpare1116, 'Just TNonSpare2234, 'Just TNonSpare1379, 'Just TNonSpare999, 'Just TNonSpare1570, 'Just TNonSpare1095, 'Just TNonSpare1610, 'Just TNonSpare735, 'Just TNonSpare1178, 'Just TNonSpare1320, 'Just TNonSpare749] +type TRuleVariation1463 = 'GContextFree TVariation1547 +type TNonSpare526 = 'GNonSpare "380" "Aircraft Derived Data" TRuleVariation1463 +type TUapItem526 = 'GUapItem TNonSpare526 +type TContent182 = 'GContentTable '[ '(0, "Default value"), '(1, "Age of the last received Mode-5 interrogation track update is higher than system dependent threshold")] +type TRuleContent182 = 'GContextFree TContent182 +type TVariation39 = 'GElement 0 1 TRuleContent182 +type TRuleVariation39 = 'GContextFree TVariation39 +type TNonSpare1316 = 'GNonSpare "M5I" "" TRuleVariation39 +type TItem561 = 'GItem TNonSpare1316 +type TVariation1442 = 'GExtended '[ 'Just TItem626, 'Just TItem989, 'Just TItem629, 'Just TItem1002, 'Just TItem182, 'Nothing, 'Just TItem967, 'Just TItem1133, 'Just TItem1131, 'Just TItem360, 'Just TItem53, 'Just TItem1037, 'Just TItem465, 'Nothing, 'Just TItem74, 'Just TItem584, 'Just TItem591, 'Just TItem598, 'Just TItem585, 'Nothing, 'Just TItem237, 'Just TItem769, 'Just TItem1008, 'Just TItem586, 'Just TItem49, 'Just TItem1043, 'Just TItem36, 'Nothing, 'Just TItem939, 'Just TItem311, 'Just TItem734, 'Just TItem361, 'Nothing, 'Just TItem300, 'Just TItem298, 'Just TItem299, 'Just TItem946, 'Just TItem451, 'Just TItem455, 'Just TItem605, 'Nothing, 'Just TItem561, 'Just TItem9, 'Nothing] +type TRuleVariation1358 = 'GContextFree TVariation1442 +type TNonSpare253 = 'GNonSpare "080" "Track Status" TRuleVariation1358 +type TUapItem253 = 'GUapItem TNonSpare253 +type TNonSpare509 = 'GNonSpare "290" "System Track Update Ages" TRuleVariation1521 +type TUapItem509 = 'GUapItem TNonSpare509 +type TNonSpare419 = 'GNonSpare "200" "Mode of Movement" TRuleVariation1225 +type TUapItem419 = 'GUapItem TNonSpare419 +type TNonSpare1383 = 'GNonSpare "MFL" "Measured Flight Level Age" TRuleVariation242 +type TNonSpare1360 = 'GNonSpare "MDA" "Mode 3/A Age" TRuleVariation242 +type TNonSpare1571 = 'GNonSpare "POS" "Position Age" TRuleVariation242 +type TNonSpare1096 = 'GNonSpare "GAL" "Geometric Altitude Age" TRuleVariation242 +type TNonSpare1611 = 'GNonSpare "PUN" "Position Uncertainty Age" TRuleVariation242 +type TNonSpare1331 = 'GNonSpare "MB" "BDS Register Data Age" TRuleVariation242 +type TVariation1580 = 'GCompound '[ 'Just TNonSpare1383, 'Just TNonSpare1348, 'Just TNonSpare1351, 'Just TNonSpare1360, 'Just TNonSpare1353, 'Just TNonSpare1355, 'Just TNonSpare1389, 'Just TNonSpare1181, 'Just TNonSpare1996, 'Just TNonSpare1800, 'Just TNonSpare1078, 'Just TNonSpare2031, 'Just TNonSpare850, 'Just TNonSpare1793, 'Just TNonSpare616, 'Just TNonSpare756, 'Just TNonSpare1130, 'Just TNonSpare1675, 'Just TNonSpare1992, 'Just TNonSpare1986, 'Just TNonSpare1121, 'Just TNonSpare2235, 'Just TNonSpare1380, 'Just TNonSpare1000, 'Just TNonSpare1571, 'Just TNonSpare1096, 'Just TNonSpare1611, 'Just TNonSpare1331, 'Just TNonSpare1179, 'Just TNonSpare1321, 'Just TNonSpare752] +type TRuleVariation1496 = 'GContextFree TVariation1580 +type TNonSpare512 = 'GNonSpare "295" "Track Data Ages" TRuleVariation1496 +type TUapItem512 = 'GUapItem TNonSpare512 +type TNonSpare342 = 'GNonSpare "136" "Measured Flight Level" TRuleVariation279 +type TUapItem342 = 'GUapItem TNonSpare342 +type TNonSpare339 = 'GNonSpare "135" "Calculated Track Barometric Altitude" TRuleVariation1172 +type TUapItem339 = 'GUapItem TNonSpare339 +type TNonSpare449 = 'GNonSpare "220" "Calculated Rate of Climb/Descent" TRuleVariation299 +type TUapItem449 = 'GUapItem TNonSpare449 +type TRecord48 = 'GRecord '[ TUapItem46, TUapItem598, TUapItem59, TUapItem228, TUapItem296, TUapItem283, TUapItem411, TUapItem436, TUapItem212, TUapItem471, TUapItem526, TUapItem155, TUapItem253, TUapItem509, TUapItem419, TUapItem512, TUapItem342, TUapItem325, TUapItem339, TUapItem449, TUapItem535, TUapItem498, TUapItem517, TUapItem306, TUapItem324, TUapItem566, TUapItem561, TUapItem521, TUapItem598, TUapItem598, TUapItem598, TUapItem598, TUapItem598, TUapItem594, TUapItem596] +type TUap42 = 'GUap TRecord48 +type TAsterix64 = 'GAsterixBasic 62 ('GEdition 1 21) TUap42 +type TNonSpare65 = 'GNonSpare "015" "Service Identification" TRuleVariation171 +type TUapItem65 = 'GUapItem TNonSpare65 +type TNonSpare116 = 'GNonSpare "030" "Time of Message" TRuleVariation376 +type TUapItem116 = 'GUapItem TNonSpare116 +type TNonSpare185 = 'GNonSpare "050" "Sensor Identifier" TRuleVariation1196 +type TUapItem185 = 'GUapItem TNonSpare185 +type TContent432 = 'GContentTable '[ '(0, "Operational"), '(1, "Degraded"), '(2, "Initialization"), '(3, "Not currently connected")] +type TRuleContent430 = 'GContextFree TContent432 +type TVariation112 = 'GElement 0 2 TRuleContent430 +type TRuleVariation112 = 'GContextFree TVariation112 +type TNonSpare860 = 'GNonSpare "CON" "" TRuleVariation112 +type TItem207 = 'GItem TNonSpare860 +type TContent447 = 'GContentTable '[ '(0, "PSR GO"), '(1, "PSR NOGO")] +type TRuleContent445 = 'GContextFree TContent447 +type TVariation590 = 'GElement 2 1 TRuleContent445 +type TRuleVariation578 = 'GContextFree TVariation590 +type TNonSpare1598 = 'GNonSpare "PSR" "" TRuleVariation578 +type TItem770 = 'GItem TNonSpare1598 +type TContent473 = 'GContentTable '[ '(0, "SSR GO"), '(1, "SSR NOGO")] +type TRuleContent471 = 'GContextFree TContent473 +type TVariation682 = 'GElement 3 1 TRuleContent471 +type TRuleVariation670 = 'GContextFree TVariation682 +type TNonSpare1920 = 'GNonSpare "SSR" "" TRuleVariation670 +type TItem1009 = 'GItem TNonSpare1920 +type TContent271 = 'GContentTable '[ '(0, "MDS GO"), '(1, "MDS NOGO")] +type TRuleContent269 = 'GContextFree TContent271 +type TVariation755 = 'GElement 4 1 TRuleContent269 +type TRuleVariation743 = 'GContextFree TVariation755 +type TNonSpare1364 = 'GNonSpare "MDS" "" TRuleVariation743 +type TItem587 = 'GItem TNonSpare1364 +type TContent11 = 'GContentTable '[ '(0, "ADS GO"), '(1, "ADS NOGO")] +type TRuleContent11 = 'GContextFree TContent11 +type TVariation847 = 'GElement 5 1 TRuleContent11 +type TRuleVariation816 = 'GContextFree TVariation847 +type TNonSpare626 = 'GNonSpare "ADS" "" TRuleVariation816 +type TItem50 = 'GItem TNonSpare626 +type TContent272 = 'GContentTable '[ '(0, "MLT GO"), '(1, "MLT NOGO")] +type TRuleContent270 = 'GContextFree TContent272 +type TVariation967 = 'GElement 6 1 TRuleContent270 +type TRuleVariation936 = 'GContextFree TVariation967 +type TNonSpare1401 = 'GNonSpare "MLT" "" TRuleVariation936 +type TItem606 = 'GItem TNonSpare1401 +type TContent484 = 'GContentTable '[ '(0, "System is released for operational use"), '(1, "Operational use of System is inhibited")] +type TRuleContent482 = 'GContextFree TContent484 +type TVariation80 = 'GElement 0 1 TRuleContent482 +type TRuleVariation80 = 'GContextFree TVariation80 +type TNonSpare1518 = 'GNonSpare "OPS" "Operational Release Status of the System" TRuleVariation80 +type TItem713 = 'GItem TNonSpare1518 +type TNonSpare1534 = 'GNonSpare "OXT" "Transmission Subsystem Overload Status" TRuleVariation538 +type TItem728 = 'GItem TNonSpare1534 +type TVariation668 = 'GElement 3 1 TRuleContent305 +type TRuleVariation656 = 'GContextFree TVariation668 +type TNonSpare1435 = 'GNonSpare "MSC" "Monitoring System Connected Status" TRuleVariation656 +type TItem636 = 'GItem TNonSpare1435 +type TContent174 = 'GContentTable '[ '(0, "Default (no meaning)"), '(1, "No plots being received")] +type TRuleContent174 = 'GContextFree TContent174 +type TVariation872 = 'GElement 5 1 TRuleContent174 +type TRuleVariation841 = 'GContextFree TVariation872 +type TNonSpare1497 = 'GNonSpare "NPW" "No Plot Warning" TRuleVariation841 +type TItem692 = 'GItem TNonSpare1497 +type TVariation1426 = 'GExtended '[ 'Just TItem207, 'Just TItem770, 'Just TItem1009, 'Just TItem587, 'Just TItem50, 'Just TItem606, 'Nothing, 'Just TItem713, 'Just TItem707, 'Just TItem728, 'Just TItem636, 'Just TItem1146, 'Just TItem692, 'Just TItem26, 'Nothing] +type TRuleVariation1342 = 'GContextFree TVariation1426 +type TNonSpare205 = 'GNonSpare "060" "Sensor Configuration and Status" TRuleVariation1342 +type TUapItem205 = 'GUapItem TNonSpare205 +type TContent657 = 'GContentQuantity 'GSigned ('GNumInt ('GZ 'GPlus 1)) "ms" +type TRuleContent655 = 'GContextFree TContent657 +type TVariation274 = 'GElement 0 16 TRuleContent655 +type TRuleVariation266 = 'GContextFree TVariation274 +type TNonSpare229 = 'GNonSpare "070" "Time Stamping Bias" TRuleVariation266 +type TUapItem229 = 'GUapItem TNonSpare229 +type TContent679 = 'GContentQuantity 'GSigned ('GNumDiv ('GNumInt ('GZ 'GPlus 1)) ('GNumInt ('GZ 'GPlus 100000))) "" +type TRuleContent677 = 'GContextFree TContent679 +type TVariation285 = 'GElement 0 16 TRuleContent677 +type TRuleVariation277 = 'GContextFree TVariation285 +type TNonSpare1911 = 'GNonSpare "SRG" "Mode S Range Gain" TRuleVariation277 +type TItem1004 = 'GItem TNonSpare1911 +type TVariation300 = 'GElement 0 16 TRuleContent703 +type TRuleVariation292 = 'GContextFree TVariation300 +type TNonSpare1904 = 'GNonSpare "SRB" "Mode S Range Bias" TRuleVariation292 +type TItem998 = 'GItem TNonSpare1904 +type TVariation1274 = 'GGroup 0 '[ TItem1004, TItem998] +type TRuleVariation1213 = 'GContextFree TVariation1274 +type TNonSpare246 = 'GNonSpare "080" "SSR / Mode S Range Gain and Bias" TRuleVariation1213 +type TUapItem246 = 'GUapItem TNonSpare246 +type TContent737 = 'GContentQuantity 'GSigned ('GNumDiv ('GNumInt ('GZ 'GPlus 360)) ('GNumPow ('GZ 'GPlus 2) ('GZ 'GPlus 16))) "°" +type TRuleContent735 = 'GContextFree TContent737 +type TVariation313 = 'GElement 0 16 TRuleContent735 +type TRuleVariation305 = 'GContextFree TVariation313 +type TNonSpare255 = 'GNonSpare "081" "SSR Mode S Azimuth Bias" TRuleVariation305 +type TUapItem255 = 'GUapItem TNonSpare255 +type TNonSpare1587 = 'GNonSpare "PRG" "PSR Range Gain" TRuleVariation277 +type TItem762 = 'GItem TNonSpare1587 +type TNonSpare1580 = 'GNonSpare "PRB" "PSR Range Bias" TRuleVariation292 +type TItem755 = 'GItem TNonSpare1580 +type TVariation1222 = 'GGroup 0 '[ TItem762, TItem755] +type TRuleVariation1168 = 'GContextFree TVariation1222 +type TNonSpare268 = 'GNonSpare "090" "PSR Range Gain and Bias" TRuleVariation1168 +type TUapItem268 = 'GUapItem TNonSpare268 +type TNonSpare276 = 'GNonSpare "091" "PSR Azimuth Bias" TRuleVariation305 +type TUapItem276 = 'GUapItem TNonSpare276 +type TNonSpare278 = 'GNonSpare "092" "PSR Elevation Bias" TRuleVariation305 +type TUapItem278 = 'GUapItem TNonSpare278 +type TRecord24 = 'GRecord '[ TUapItem37, TUapItem65, TUapItem116, TUapItem185, TUapItem205, TUapItem229, TUapItem246, TUapItem255, TUapItem268, TUapItem276, TUapItem278, TUapItem598, TUapItem594, TUapItem596] +type TUap22 = 'GUap TRecord24 +type TAsterix65 = 'GAsterixBasic 63 ('GEdition 1 6) TUap22 +type TVariation470 = 'GElement 1 1 TRuleContent509 +type TRuleVariation458 = 'GContextFree TVariation470 +type TNonSpare2184 = 'GNonSpare "VAL" "Test Target Failure Status Values" TRuleVariation458 +type TItem1209 = 'GItem TNonSpare2184 +type TVariation1145 = 'GGroup 0 '[ TItem320, TItem1209] +type TRuleVariation1098 = 'GContextFree TVariation1145 +type TNonSpare2121 = 'GNonSpare "TTF" "Test Target Failure Status from Sensor" TRuleVariation1098 +type TItem1152 = 'GItem TNonSpare2121 +type TVariation675 = 'GElement 3 1 TRuleContent391 +type TRuleVariation663 = 'GContextFree TVariation675 +type TNonSpare2175 = 'GNonSpare "VAL" "Indication of Spoofing Attack Values" TRuleVariation663 +type TItem1200 = 'GItem TNonSpare2175 +type TVariation1388 = 'GGroup 2 '[ TItem321, TItem1200] +type TRuleVariation1307 = 'GContextFree TVariation1388 +type TNonSpare1901 = 'GNonSpare "SPO" "Indication of Spoofing Attack from Sensor" TRuleVariation1307 +type TItem995 = 'GItem TNonSpare1901 +type TVariation1427 = 'GExtended '[ 'Just TItem207, 'Just TItem770, 'Just TItem1009, 'Just TItem587, 'Just TItem50, 'Just TItem606, 'Nothing, 'Just TItem713, 'Just TItem707, 'Just TItem728, 'Just TItem636, 'Just TItem1146, 'Just TItem692, 'Just TItem26, 'Nothing, 'Just TItem1152, 'Just TItem995, 'Just TItem21, 'Nothing] +type TRuleVariation1343 = 'GContextFree TVariation1427 +type TNonSpare206 = 'GNonSpare "060" "Sensor Configuration and Status" TRuleVariation1343 +type TUapItem206 = 'GUapItem TNonSpare206 +type TRecord25 = 'GRecord '[ TUapItem37, TUapItem65, TUapItem116, TUapItem185, TUapItem206, TUapItem229, TUapItem246, TUapItem255, TUapItem268, TUapItem276, TUapItem278, TUapItem598, TUapItem594, TUapItem596] +type TUap23 = 'GUap TRecord25 +type TAsterix66 = 'GAsterixBasic 63 ('GEdition 1 7) TUap23 +type TContent620 = 'GContentTable '[ '(1, "SDPS Status"), '(2, "End of Batch"), '(3, "Service Status Report")] +type TRuleContent618 = 'GContextFree TContent620 +type TVariation207 = 'GElement 0 8 TRuleContent618 +type TRuleVariation199 = 'GContextFree TVariation207 +type TNonSpare9 = 'GNonSpare "000" "Message Type" TRuleVariation199 +type TUapItem9 = 'GUapItem TNonSpare9 +type TNonSpare61 = 'GNonSpare "015" "Service Identification" TRuleVariation171 +type TUapItem61 = 'GUapItem TNonSpare61 +type TNonSpare115 = 'GNonSpare "030" "Time of Message" TRuleVariation376 +type TUapItem115 = 'GUapItem TNonSpare115 +type TNonSpare77 = 'GNonSpare "020" "Batch Number" TRuleVariation211 +type TUapItem77 = 'GUapItem TNonSpare77 +type TContent435 = 'GContentTable '[ '(0, "Operational"), '(1, "Degraded"), '(2, "Not currently connected"), '(3, "Unknown")] +type TRuleContent433 = 'GContextFree TContent435 +type TVariation115 = 'GElement 0 2 TRuleContent433 +type TRuleVariation115 = 'GContextFree TVariation115 +type TNonSpare1482 = 'GNonSpare "NOGO" "" TRuleVariation115 +type TItem678 = 'GItem TNonSpare1482 +type TContent142 = 'GContentTable '[ '(0, "Default"), '(1, "Overload")] +type TRuleContent142 = 'GContextFree TContent142 +type TVariation540 = 'GElement 2 1 TRuleContent142 +type TRuleVariation528 = 'GContextFree TVariation540 +type TNonSpare1525 = 'GNonSpare "OVL" "" TRuleVariation528 +type TItem719 = 'GItem TNonSpare1525 +type TContent115 = 'GContentTable '[ '(0, "Default"), '(1, "Invalid Time Source")] +type TRuleContent115 = 'GContextFree TContent115 +type TVariation644 = 'GElement 3 1 TRuleContent115 +type TRuleVariation632 = 'GContextFree TVariation644 +type TNonSpare2111 = 'GNonSpare "TSV" "" TRuleVariation632 +type TItem1144 = 'GItem TNonSpare2111 +type TContent411 = 'GContentTable '[ '(0, "Not applicable"), '(1, "SDPS-1 selected"), '(2, "SDPS-2 selected"), '(3, "SDPS-3 selected")] +type TRuleContent409 = 'GContextFree TContent411 +type TVariation794 = 'GElement 4 2 TRuleContent409 +type TRuleVariation782 = 'GContextFree TVariation794 +type TNonSpare1605 = 'GNonSpare "PSS" "Processing System Status" TRuleVariation782 +type TItem772 = 'GItem TNonSpare1605 +type TNonSpare1964 = 'GNonSpare "STTN" "Track Re-numbering Indication" TRuleVariation898 +type TItem1039 = 'GItem TNonSpare1964 +type TVariation1210 = 'GGroup 0 '[ TItem678, TItem719, TItem1144, TItem772, TItem1039, TItem29] +type TRuleVariation1158 = 'GContextFree TVariation1210 +type TNonSpare149 = 'GNonSpare "040" "SDPS Configuration and Status" TRuleVariation1158 +type TUapItem149 = 'GUapItem TNonSpare149 +type TContent621 = 'GContentTable '[ '(1, "Service degradation"), '(2, "Service degradation ended"), '(3, "Main radar out of service"), '(4, "Service interrupted by the operator"), '(5, "Service interrupted due to contingency"), '(6, "Ready for service restart after contingency"), '(7, "Service ended by the operator"), '(8, "Failure of user main radar"), '(9, "Service restarted by the operator"), '(10, "Main radar becoming operational"), '(11, "Main radar becoming degraded"), '(12, "Service continuity interrupted due to disconnection with adjacent unit"), '(13, "Service continuity restarted"), '(14, "Service synchronised on backup radar"), '(15, "Service synchronised on main radar"), '(16, "Main and backup radar, if any, failed")] +type TRuleContent619 = 'GContextFree TContent621 +type TVariation208 = 'GElement 0 8 TRuleContent619 +type TRuleVariation200 = 'GContextFree TVariation208 +type TNonSpare187 = 'GNonSpare "050" "Service Status Report" TRuleVariation200 +type TUapItem187 = 'GUapItem TNonSpare187 +type TRecord47 = 'GRecord '[ TUapItem46, TUapItem9, TUapItem61, TUapItem115, TUapItem77, TUapItem149, TUapItem187, TUapItem598, TUapItem598, TUapItem598, TUapItem598, TUapItem598, TUapItem594, TUapItem596] +type TUap41 = 'GUap TRecord47 +type TAsterix67 = 'GAsterixBasic 65 ('GEdition 1 4) TUap41 +type TAsterix68 = 'GAsterixBasic 65 ('GEdition 1 5) TUap41 +type TAsterix69 = 'GAsterixBasic 65 ('GEdition 1 6) TUap41 +type TNonSpare787 = 'GNonSpare "CEN" "Centre Identifier" TRuleVariation171 +type TItem161 = 'GItem TNonSpare787 +type TNonSpare1574 = 'GNonSpare "POS" "Workstation Identifier" TRuleVariation171 +type TItem749 = 'GItem TNonSpare1574 +type TVariation1115 = 'GGroup 0 '[ TItem161, TItem749] +type TRuleVariation1073 = 'GContextFree TVariation1115 +type TNonSpare49 = 'GNonSpare "010" "Destination ID" TRuleVariation1073 +type TUapItem49 = 'GUapItem TNonSpare49 +type TNonSpare84 = 'GNonSpare "020" "Source ID" TRuleVariation1073 +type TUapItem84 = 'GUapItem TNonSpare84 +type TContent605 = 'GContentTable '[ '(1, "Flight plan creation"), '(2, "Flight plan modification"), '(3, "Flight plan repetition"), '(4, "Manual flight plan deletion"), '(5, "Automatic flight plan deletion"), '(6, "Flight is beyond extraction area boundary"), '(251, "Short term conflict alert"), '(252, "Correlations"), '(253, "Decorrelations"), '(254, "Start of background loop"), '(255, "End of background loop")] +type TRuleContent603 = 'GContextFree TContent605 +type TVariation195 = 'GElement 0 8 TRuleContent603 +type TRuleVariation187 = 'GContextFree TVariation195 +type TNonSpare109 = 'GNonSpare "030" "Message Type" TRuleVariation187 +type TUapItem109 = 'GUapItem TNonSpare109 +type TNonSpare147 = 'GNonSpare "040" "Plan Reference Number" TRuleVariation259 +type TUapItem147 = 'GUapItem TNonSpare147 +type TNonSpare175 = 'GNonSpare "050" "Callsign" TRuleVariation398 +type TUapItem175 = 'GUapItem TNonSpare175 +type TNonSpare202 = 'GNonSpare "060" "Present Mode 3A" TRuleVariation380 +type TUapItem202 = 'GUapItem TNonSpare202 +type TNonSpare226 = 'GNonSpare "070" "Next Mode 3A" TRuleVariation380 +type TUapItem226 = 'GUapItem TNonSpare226 +type TNonSpare243 = 'GNonSpare "080" "Departure Aerodrome" TRuleVariation380 +type TUapItem243 = 'GUapItem TNonSpare243 +type TNonSpare259 = 'GNonSpare "090" "Destination Aerodrome" TRuleVariation380 +type TUapItem259 = 'GUapItem TNonSpare259 +type TNonSpare1100 = 'GNonSpare "GAT" "General Air Traffic" TRuleVariation0 +type TItem383 = 'GItem TNonSpare1100 +type TNonSpare1506 = 'GNonSpare "OAT" "Operational Air Traffic" TRuleVariation402 +type TItem701 = 'GItem TNonSpare1506 +type TNonSpare889 = 'GNonSpare "CPL" "Complete Flight Plan" TRuleVariation815 +type TItem226 = 'GItem TNonSpare889 +type TNonSpare1899 = 'GNonSpare "SPN" "Short Flight Plan" TRuleVariation898 +type TItem993 = 'GItem TNonSpare1899 +type TVariation1164 = 'GGroup 0 '[ TItem383, TItem701, TItem13, TItem226, TItem993, TItem29] +type TRuleVariation1117 = 'GContextFree TVariation1164 +type TNonSpare293 = 'GNonSpare "100" "Type Flags" TRuleVariation1117 +type TUapItem293 = 'GUapItem TNonSpare293 +type TNonSpare1150 = 'GNonSpare "HLD" "Aircraft is in Hold State" TRuleVariation402 +type TItem419 = 'GItem TNonSpare1150 +type TNonSpare1776 = 'GNonSpare "RVQ" "Aircraft is RVSM Equipped" TRuleVariation512 +type TItem905 = 'GItem TNonSpare1776 +type TNonSpare1774 = 'GNonSpare "RVC" "Aircraft is RVSM Capable" TRuleVariation622 +type TItem904 = 'GItem TNonSpare1774 +type TNonSpare1780 = 'GNonSpare "RVX" "Aircraft is RVSM Exempted" TRuleVariation712 +type TItem909 = 'GItem TNonSpare1780 +type TVariation1032 = 'GGroup 0 '[ TItem0, TItem419, TItem905, TItem904, TItem909, TItem25] +type TRuleVariation1001 = 'GContextFree TVariation1032 +type TNonSpare309 = 'GNonSpare "110" "Status Flags" TRuleVariation1001 +type TUapItem309 = 'GUapItem TNonSpare309 +type TVariation268 = 'GElement 0 16 TRuleContent634 +type TRuleVariation260 = 'GContextFree TVariation268 +type TNonSpare1479 = 'GNonSpare "NOA" "Number of Aircraft" TRuleVariation260 +type TItem675 = 'GItem TNonSpare1479 +type TItem1093 = 'GItem TNonSpare2047 +type TNonSpare2257 = 'GNonSpare "WT" "Wake Turbulence" TRuleVariation209 +type TItem1275 = 'GItem TNonSpare2257 +type TVariation1209 = 'GGroup 0 '[ TItem675, TItem1093, TItem1275] +type TRuleVariation1157 = 'GContextFree TVariation1209 +type TNonSpare312 = 'GNonSpare "120" "Aircraft Type" TRuleVariation1157 +type TUapItem312 = 'GUapItem TNonSpare312 +type TNonSpare326 = 'GNonSpare "130" "Cleared Flight Level" TRuleVariation356 +type TUapItem326 = 'GUapItem TNonSpare326 +type TContent618 = 'GContentTable '[ '(1, "P, point"), '(2, "B, point with bearing and distance"), '(3, "LS, latitude/longitude position short format"), '(4, "LL, latitude/longitude position long format"), '(5, "X, x/y co-ordinate position"), '(6, "G, georeference position"), '(14, "E, airport")] +type TRuleContent616 = 'GContextFree TContent618 +type TVariation205 = 'GElement 0 8 TRuleContent616 +type TRuleVariation197 = 'GContextFree TVariation205 +type TNonSpare1980 = 'GNonSpare "T" "Route Point Type" TRuleVariation197 +type TItem1050 = 'GItem TNonSpare1980 +type TVariation411 = 'GElement 0 88 TRuleContent634 +type TRuleVariation401 = 'GContextFree TVariation411 +type TNonSpare987 = 'GNonSpare "E" "Route Point Description Element" TRuleVariation401 +type TItem304 = 'GItem TNonSpare987 +type TVariation1283 = 'GGroup 0 '[ TItem1050, TItem304] +type TVariation1514 = 'GRepetitive ('GRepetitiveRegular 1) TVariation1283 +type TRuleVariation1430 = 'GContextFree TVariation1514 +type TNonSpare347 = 'GNonSpare "140" "Route Points, Description" TRuleVariation1430 +type TUapItem347 = 'GUapItem TNonSpare347 +type TContent701 = 'GContentQuantity 'GSigned ('GNumDiv ('GNumInt ('GZ 'GPlus 1)) ('GNumPow ('GZ 'GPlus 2) ('GZ 'GPlus 6))) "NM" +type TRuleContent699 = 'GContextFree TContent701 +type TVariation297 = 'GElement 0 16 TRuleContent699 +type TRuleVariation289 = 'GContextFree TVariation297 +type TNonSpare2283 = 'GNonSpare "X" "X Co-ordinate" TRuleVariation289 +type TItem1299 = 'GItem TNonSpare2283 +type TNonSpare2338 = 'GNonSpare "Y" "Y Co-ordinate" TRuleVariation289 +type TItem1350 = 'GItem TNonSpare2338 +type TVariation1372 = 'GGroup 0 '[ TItem1299, TItem1350] +type TVariation1528 = 'GRepetitive ('GRepetitiveRegular 1) TVariation1372 +type TRuleVariation1444 = 'GContextFree TVariation1528 +type TNonSpare369 = 'GNonSpare "150" "Route Points, Coordinates" TRuleVariation1444 +type TUapItem369 = 'GUapItem TNonSpare369 +type TNonSpare1149 = 'GNonSpare "HH" "Hours" TRuleVariation260 +type TItem418 = 'GItem TNonSpare1149 +type TNonSpare1403 = 'GNonSpare "MM" "Minutes" TRuleVariation260 +type TItem607 = 'GItem TNonSpare1403 +type TVariation1173 = 'GGroup 0 '[ TItem418, TItem607] +type TVariation1498 = 'GRepetitive ('GRepetitiveRegular 1) TVariation1173 +type TRuleVariation1414 = 'GContextFree TVariation1498 +type TNonSpare381 = 'GNonSpare "160" "Route Points, Time" TRuleVariation1414 +type TUapItem381 = 'GUapItem TNonSpare381 +type TVariation1474 = 'GRepetitive ('GRepetitiveRegular 1) TVariation364 +type TRuleVariation1390 = 'GContextFree TVariation1474 +type TNonSpare394 = 'GNonSpare "170" "Route Points, Flight Level" TRuleVariation1390 +type TUapItem394 = 'GUapItem TNonSpare394 +type TVariation1476 = 'GRepetitive ('GRepetitiveRegular 1) TVariation388 +type TRuleVariation1392 = 'GContextFree TVariation1476 +type TNonSpare408 = 'GNonSpare "180" "Route Points, Speed" TRuleVariation1392 +type TUapItem408 = 'GUapItem TNonSpare408 +type TNonSpare412 = 'GNonSpare "190" "Controller ID" TRuleVariation260 +type TUapItem412 = 'GUapItem TNonSpare412 +type TVariation1471 = 'GRepetitive ('GRepetitiveRegular 1) TVariation217 +type TRuleVariation1387 = 'GContextFree TVariation1471 +type TNonSpare417 = 'GNonSpare "200" "Field 18" TRuleVariation1387 +type TUapItem417 = 'GUapItem TNonSpare417 +type TNonSpare437 = 'GNonSpare "210" "Correlated Track Number" TRuleVariation259 +type TUapItem437 = 'GUapItem TNonSpare437 +type TNonSpare451 = 'GNonSpare "220" "Maximum Plan Count" TRuleVariation262 +type TUapItem451 = 'GUapItem TNonSpare451 +type TNonSpare462 = 'GNonSpare "230" "Number of Plans" TRuleVariation262 +type TUapItem462 = 'GUapItem TNonSpare462 +type TNonSpare1551 = 'GNonSpare "PLAN" "Plan Number" TRuleVariation259 +type TItem740 = 'GItem TNonSpare1551 +type TNonSpare2073 = 'GNonSpare "TRACK" "Track Number" TRuleVariation259 +type TItem1112 = 'GItem TNonSpare2073 +type TVariation1218 = 'GGroup 0 '[ TItem740, TItem1112] +type TVariation1504 = 'GRepetitive ('GRepetitiveRegular 1) TVariation1218 +type TRuleVariation1420 = 'GContextFree TVariation1504 +type TNonSpare469 = 'GNonSpare "240" "Newly Correlated Plans" TRuleVariation1420 +type TUapItem469 = 'GUapItem TNonSpare469 +type TNonSpare485 = 'GNonSpare "250" "Newly De-correlated Plans" TRuleVariation1388 +type TUapItem485 = 'GUapItem TNonSpare485 +type TNonSpare2074 = 'GNonSpare "TRACK1" "Track Number 1" TRuleVariation259 +type TItem1113 = 'GItem TNonSpare2074 +type TNonSpare2075 = 'GNonSpare "TRACK2" "Track Number 2" TRuleVariation259 +type TItem1114 = 'GItem TNonSpare2075 +type TVariation1291 = 'GGroup 0 '[ TItem1113, TItem1114] +type TVariation1518 = 'GRepetitive ('GRepetitiveRegular 1) TVariation1291 +type TRuleVariation1434 = 'GContextFree TVariation1518 +type TNonSpare486 = 'GNonSpare "251" "Tracks in Conflict" TRuleVariation1434 +type TUapItem486 = 'GUapItem TNonSpare486 +type TNonSpare407 = 'GNonSpare "171" "Route Points, Requested Flight Level" TRuleVariation1390 +type TUapItem407 = 'GUapItem TNonSpare407 +type TVariation1499 = 'GRepetitive ('GRepetitiveRegular 1) TVariation1193 +type TRuleVariation1415 = 'GContextFree TVariation1499 +type TNonSpare370 = 'GNonSpare "151" "Route Points, Geographic Position" TRuleVariation1415 +type TUapItem370 = 'GUapItem TNonSpare370 +type TRecord57 = 'GRecord '[ TUapItem49, TUapItem84, TUapItem109, TUapItem147, TUapItem175, TUapItem202, TUapItem226, TUapItem243, TUapItem259, TUapItem293, TUapItem309, TUapItem312, TUapItem326, TUapItem347, TUapItem369, TUapItem381, TUapItem394, TUapItem408, TUapItem412, TUapItem417, TUapItem437, TUapItem451, TUapItem462, TUapItem469, TUapItem485, TUapItem486, TUapItem407, TUapItem370] +type TUap51 = 'GUap TRecord57 +type TAsterix70 = 'GAsterixBasic 150 ('GEdition 3 0) TUap51 +type TNonSpare33 = 'GNonSpare "010" "Data Source Identifier" TRuleVariation1196 +type TUapItem33 = 'GUapItem TNonSpare33 +type TNonSpare63 = 'GNonSpare "015" "Service Identification" TRuleVariation171 +type TUapItem63 = 'GUapItem TNonSpare63 +type TContent625 = 'GContentTable '[ '(1, "System Position Report"), '(2, "System Bearing Report"), '(3, "System Position Report of conflicting transmission"), '(4, "System Detection End Report"), '(5, "Sensor Data Report")] +type TRuleContent623 = 'GContextFree TContent625 +type TVariation211 = 'GElement 0 8 TRuleContent623 +type TRuleVariation203 = 'GContextFree TVariation211 +type TNonSpare12 = 'GNonSpare "000" "Message Type" TRuleVariation203 +type TUapItem12 = 'GUapItem TNonSpare12 +type TNonSpare114 = 'GNonSpare "030" "Time of Day" TRuleVariation376 +type TUapItem114 = 'GUapItem TNonSpare114 +type TNonSpare148 = 'GNonSpare "040" "Report Number" TRuleVariation171 +type TUapItem148 = 'GUapItem TNonSpare148 +type TNonSpare273 = 'GNonSpare "090" "Radio Channel Name" TRuleVariation398 +type TUapItem273 = 'GUapItem TNonSpare273 +type TNonSpare1238 = 'GNonSpare "LAT" "Latitude in WGS-84" TRuleVariation384 +type TItem494 = 'GItem TNonSpare1238 +type TNonSpare1271 = 'GNonSpare "LON" "Longitude in WGS-84" TRuleVariation383 +type TItem525 = 'GItem TNonSpare1271 +type TVariation1190 = 'GGroup 0 '[ TItem494, TItem525] +type TRuleVariation1141 = 'GContextFree TVariation1190 +type TNonSpare184 = 'GNonSpare "050" "Position in WGS-84 Coordinates" TRuleVariation1141 +type TUapItem184 = 'GUapItem TNonSpare184 +type TNonSpare201 = 'GNonSpare "060" "Position in Cartesian Coordinates" TRuleVariation1302 +type TUapItem201 = 'GUapItem TNonSpare201 +type TContent778 = 'GContentQuantity 'GUnsigned ('GNumDiv ('GNumInt ('GZ 'GPlus 1)) ('GNumInt ('GZ 'GPlus 100))) "°" +type TRuleContent776 = 'GContextFree TContent778 +type TVariation332 = 'GElement 0 16 TRuleContent776 +type TRuleVariation324 = 'GContextFree TVariation332 +type TNonSpare215 = 'GNonSpare "070" "Local Bearing" TRuleVariation324 +type TUapItem215 = 'GUapItem TNonSpare215 +type TNonSpare247 = 'GNonSpare "080" "System Bearing" TRuleVariation324 +type TUapItem247 = 'GUapItem TNonSpare247 +type TNonSpare291 = 'GNonSpare "100" "Quality of Measurement" TRuleVariation171 +type TUapItem291 = 'GUapItem TNonSpare291 +type TContent759 = 'GContentQuantity 'GUnsigned ('GNumInt ('GZ 'GPlus 100)) "m" +type TRuleContent757 = 'GContextFree TContent759 +type TVariation239 = 'GElement 0 8 TRuleContent757 +type TRuleVariation231 = 'GContextFree TVariation239 +type TNonSpare301 = 'GNonSpare "110" "Estimated Uncertainty" TRuleVariation231 +type TUapItem301 = 'GUapItem TNonSpare301 +type TVariation1469 = 'GRepetitive ('GRepetitiveRegular 1) TVariation178 +type TRuleVariation1385 = 'GContextFree TVariation1469 +type TNonSpare317 = 'GNonSpare "120" "Contributing Sensors" TRuleVariation1385 +type TUapItem317 = 'GUapItem TNonSpare317 +type TNonSpare327 = 'GNonSpare "130" "Conflicting Transmitter Position in WGS-84 Coordinates" TRuleVariation1141 +type TUapItem327 = 'GUapItem TNonSpare327 +type TNonSpare343 = 'GNonSpare "140" "Conflicting Transmitter Position in Cartesian Coordinates" TRuleVariation1302 +type TUapItem343 = 'GUapItem TNonSpare343 +type TNonSpare367 = 'GNonSpare "150" "Conflicting Transmitter Estimated Uncertainty" TRuleVariation231 +type TUapItem367 = 'GUapItem TNonSpare367 +type TNonSpare382 = 'GNonSpare "160" "Track Number" TRuleVariation259 +type TUapItem382 = 'GUapItem TNonSpare382 +type TNonSpare395 = 'GNonSpare "170" "Sensor Identification" TRuleVariation171 +type TUapItem395 = 'GUapItem TNonSpare395 +type TContent672 = 'GContentQuantity 'GSigned ('GNumDiv ('GNumInt ('GZ 'GPlus 1)) ('GNumInt ('GZ 'GPlus 100))) "dBµV" +type TRuleContent670 = 'GContextFree TContent672 +type TVariation281 = 'GElement 0 16 TRuleContent670 +type TRuleVariation273 = 'GContextFree TVariation281 +type TNonSpare409 = 'GNonSpare "180" "Signal Level" TRuleVariation273 +type TUapItem409 = 'GUapItem TNonSpare409 +type TNonSpare413 = 'GNonSpare "190" "Signal Quality" TRuleVariation171 +type TUapItem413 = 'GUapItem TNonSpare413 +type TContent678 = 'GContentQuantity 'GSigned ('GNumDiv ('GNumInt ('GZ 'GPlus 1)) ('GNumInt ('GZ 'GPlus 100))) "°" +type TRuleContent676 = 'GContextFree TContent678 +type TVariation284 = 'GElement 0 16 TRuleContent676 +type TRuleVariation276 = 'GContextFree TVariation284 +type TNonSpare422 = 'GNonSpare "200" "Signal Elevation" TRuleVariation276 +type TUapItem422 = 'GUapItem TNonSpare422 +type TRecord14 = 'GRecord '[ TUapItem33, TUapItem63, TUapItem12, TUapItem114, TUapItem148, TUapItem273, TUapItem184, TUapItem201, TUapItem215, TUapItem247, TUapItem291, TUapItem301, TUapItem317, TUapItem327, TUapItem343, TUapItem367, TUapItem382, TUapItem395, TUapItem409, TUapItem413, TUapItem422, TUapItem596] +type TUap14 = 'GUap TRecord14 +type TAsterix71 = 'GAsterixBasic 205 ('GEdition 1 0) TUap14 +type TNonSpare44 = 'GNonSpare "010" "Data Source Identifier" TRuleVariation1196 +type TUapItem44 = 'GUapItem TNonSpare44 +type TContent630 = 'GContentTable '[ '(1, "Video Summary message"), '(2, "Video message")] +type TRuleContent628 = 'GContextFree TContent630 +type TVariation214 = 'GElement 0 8 TRuleContent628 +type TRuleVariation206 = 'GContextFree TVariation214 +type TNonSpare15 = 'GNonSpare "000" "Message Type" TRuleVariation206 +type TUapItem15 = 'GUapItem TNonSpare15 +type TNonSpare99 = 'GNonSpare "020" "Video Record Header" TRuleVariation381 +type TUapItem99 = 'GUapItem TNonSpare99 +type TNonSpare118 = 'GNonSpare "030" "Video Summary" TRuleVariation1387 +type TUapItem118 = 'GUapItem TNonSpare118 +type TContent825 = 'GContentQuantity 'GUnsigned ('GNumDiv ('GNumInt ('GZ 'GPlus 360)) ('GNumPow ('GZ 'GPlus 2) ('GZ 'GPlus 16))) "°" +type TRuleContent822 = 'GContextFree TContent825 +type TVariation358 = 'GElement 0 16 TRuleContent822 +type TRuleVariation350 = 'GContextFree TVariation358 +type TNonSpare1934 = 'GNonSpare "STARTAZ" "Start Azimuth of the Cells Group" TRuleVariation350 +type TItem1014 = 'GItem TNonSpare1934 +type TNonSpare1004 = 'GNonSpare "ENDAZ" "End Azimuth of the Cells Group" TRuleVariation350 +type TItem312 = 'GItem TNonSpare1004 +type TNonSpare1935 = 'GNonSpare "STARTRG" "Starting Range of the Cells Group, Expressed in Number of Cells" TRuleVariation381 +type TItem1015 = 'GItem TNonSpare1935 +type TVariation401 = 'GElement 0 32 TRuleContent750 +type TRuleVariation393 = 'GContextFree TVariation401 +type TNonSpare784 = 'GNonSpare "CELLDUR" "Video Cell Duration in Nano-seconds" TRuleVariation393 +type TItem158 = 'GItem TNonSpare784 +type TVariation1276 = 'GGroup 0 '[ TItem1014, TItem312, TItem1015, TItem158] +type TRuleVariation1215 = 'GContextFree TVariation1276 +type TNonSpare157 = 'GNonSpare "040" "Video Header Nano" TRuleVariation1215 +type TUapItem157 = 'GUapItem TNonSpare157 +type TContent742 = 'GContentQuantity 'GUnsigned ('GNumInt ('GZ 'GPlus 1)) "fs" +type TRuleContent740 = 'GContextFree TContent742 +type TVariation400 = 'GElement 0 32 TRuleContent740 +type TRuleVariation392 = 'GContextFree TVariation400 +type TNonSpare783 = 'GNonSpare "CELLDUR" "Video Cell Duration in Femto-seconds" TRuleVariation392 +type TItem157 = 'GItem TNonSpare783 +type TVariation1275 = 'GGroup 0 '[ TItem1014, TItem312, TItem1015, TItem157] +type TRuleVariation1214 = 'GContextFree TVariation1275 +type TNonSpare163 = 'GNonSpare "041" "Video Header Femto" TRuleVariation1214 +type TUapItem163 = 'GUapItem TNonSpare163 +type TContent357 = 'GContentTable '[ '(0, "No compression applied"), '(1, "Compression applied")] +type TRuleContent355 = 'GContextFree TContent357 +type TVariation62 = 'GElement 0 1 TRuleContent355 +type TRuleVariation62 = 'GContextFree TVariation62 +type TNonSpare757 = 'GNonSpare "C" "Data Compression Indicator" TRuleVariation62 +type TItem139 = 'GItem TNonSpare757 +type TContent613 = 'GContentTable '[ '(1, "Monobit Resolution (1 bit)"), '(2, "Low Resolution (2 bits)"), '(3, "Medium Resolution (4 bits)"), '(4, "High Resolution (8 bits)"), '(5, "Very High Resolution (16 bits)"), '(6, "Ultra High Resolution (32 bits)")] +type TRuleContent611 = 'GContextFree TContent613 +type TVariation200 = 'GElement 0 8 TRuleContent611 +type TRuleVariation192 = 'GContextFree TVariation200 +type TNonSpare1719 = 'GNonSpare "RES" "Bit Resolution" TRuleVariation192 +type TItem870 = 'GItem TNonSpare1719 +type TVariation1109 = 'GGroup 0 '[ TItem139, TItem10, TItem870] +type TRuleVariation1069 = 'GContextFree TVariation1109 +type TNonSpare173 = 'GNonSpare "048" "Video Cells Resolution & Data Compression Indicator" TRuleVariation1069 +type TUapItem173 = 'GUapItem TNonSpare173 +type TNonSpare1472 = 'GNonSpare "NBVB" "Number of 'valid' Octets" TRuleVariation262 +type TItem668 = 'GItem TNonSpare1472 +type TNonSpare1467 = 'GNonSpare "NBCELLS" "Number of 'valid' Cells" TRuleVariation357 +type TItem663 = 'GItem TNonSpare1467 +type TVariation1208 = 'GGroup 0 '[ TItem668, TItem663] +type TRuleVariation1156 = 'GContextFree TVariation1208 +type TNonSpare174 = 'GNonSpare "049" "Video Octets & Video Cells Counters" TRuleVariation1156 +type TUapItem174 = 'GUapItem TNonSpare174 +type TVariation1475 = 'GRepetitive ('GRepetitiveRegular 1) TVariation387 +type TRuleVariation1391 = 'GContextFree TVariation1475 +type TNonSpare191 = 'GNonSpare "050" "Video Block Low Data Volume" TRuleVariation1391 +type TUapItem191 = 'GUapItem TNonSpare191 +type TVariation412 = 'GElement 0 512 TRuleContent0 +type TVariation1480 = 'GRepetitive ('GRepetitiveRegular 1) TVariation412 +type TRuleVariation1396 = 'GContextFree TVariation1480 +type TNonSpare192 = 'GNonSpare "051" "Video Block Medium Data Volume" TRuleVariation1396 +type TUapItem192 = 'GUapItem TNonSpare192 +type TVariation413 = 'GElement 0 2048 TRuleContent0 +type TVariation1481 = 'GRepetitive ('GRepetitiveRegular 1) TVariation413 +type TRuleVariation1397 = 'GContextFree TVariation1481 +type TNonSpare193 = 'GNonSpare "052" "Video Block High Data Volume" TRuleVariation1397 +type TUapItem193 = 'GUapItem TNonSpare193 +type TNonSpare352 = 'GNonSpare "140" "Time of Day" TRuleVariation376 +type TUapItem352 = 'GUapItem TNonSpare352 +type TRecord45 = 'GRecord '[ TUapItem44, TUapItem15, TUapItem99, TUapItem118, TUapItem157, TUapItem163, TUapItem173, TUapItem174, TUapItem191, TUapItem192, TUapItem193, TUapItem352, TUapItem594, TUapItem596] +type TUap39 = 'GUap TRecord45 +type TAsterix72 = 'GAsterixBasic 240 ('GEdition 1 3) TUap39 +type TNonSpare66 = 'GNonSpare "015" "Service Identification" TRuleVariation171 +type TUapItem66 = 'GUapItem TNonSpare66 +type TNonSpare354 = 'GNonSpare "140" "Time of Day" TRuleVariation376 +type TUapItem354 = 'GUapItem TNonSpare354 +type TNonSpare768 = 'GNonSpare "CAT" "Category" TRuleVariation211 +type TItem146 = 'GItem TNonSpare768 +type TNonSpare1326 = 'GNonSpare "MAIN" "Main Version Number" TRuleVariation211 +type TItem568 = 'GItem TNonSpare1326 +type TNonSpare1967 = 'GNonSpare "SUB" "Sub Version Number" TRuleVariation211 +type TItem1042 = 'GItem TNonSpare1967 +type TVariation1111 = 'GGroup 0 '[ TItem146, TItem568, TItem1042] +type TVariation1491 = 'GRepetitive ('GRepetitiveRegular 1) TVariation1111 +type TRuleVariation1407 = 'GContextFree TVariation1491 +type TNonSpare569 = 'GNonSpare "550" "Category Version Number Report" TRuleVariation1407 +type TUapItem567 = 'GUapItem TNonSpare569 +type TRecord26 = 'GRecord '[ TUapItem37, TUapItem66, TUapItem354, TUapItem567, TUapItem598, TUapItem596, TUapItem594] +type TUap24 = 'GUap TRecord26 +type TAsterix73 = 'GAsterixBasic 247 ('GEdition 1 2) TUap24 +type TNonSpare570 = 'GNonSpare "550" "Category Version Number Report" TRuleVariation1407 +type TUapItem568 = 'GUapItem TNonSpare570 +type TRecord27 = 'GRecord '[ TUapItem37, TUapItem66, TUapItem354, TUapItem568, TUapItem598, TUapItem596, TUapItem594] +type TUap25 = 'GUap TRecord27 +type TAsterix74 = 'GAsterixBasic 247 ('GEdition 1 3) TUap25 + +-- Toplevel aliases + +type Cat_001_1_2 = TAsterix0 +type Cat_001_1_3 = TAsterix1 +type Cat_001_1_4 = TAsterix2 +type Cat_002_1_0 = TAsterix3 +type Cat_002_1_1 = TAsterix4 +type Cat_002_1_2 = TAsterix5 +type Cat_004_1_12 = TAsterix6 +type Cat_004_1_13 = TAsterix7 +type Cat_007_1_12 = TAsterix8 +type Cat_008_1_2 = TAsterix9 +type Cat_008_1_3 = TAsterix10 +type Cat_009_2_1 = TAsterix11 +type Cat_010_1_1 = TAsterix12 +type Cat_011_1_2 = TAsterix13 +type Cat_011_1_3 = TAsterix14 +type Cat_015_1_0 = TAsterix15 +type Cat_015_1_1 = TAsterix16 +type Cat_015_1_2 = TAsterix17 +type Cat_016_1_0 = TAsterix18 +type Cat_017_1_3 = TAsterix19 +type Cat_018_1_7 = TAsterix20 +type Cat_018_1_8 = TAsterix21 +type Cat_019_1_3 = TAsterix22 +type Cat_020_1_9 = TAsterix23 +type Cat_020_1_10 = TAsterix24 +type Cat_020_1_11 = TAsterix25 +type Cat_021_0_23 = TAsterix26 +type Cat_021_0_24 = TAsterix27 +type Cat_021_0_25 = TAsterix28 +type Cat_021_0_26 = TAsterix29 +type Ref_021_1_4 = TAsterix30 +type Ref_021_1_5 = TAsterix31 +type Cat_021_2_1 = TAsterix32 +type Cat_021_2_2 = TAsterix33 +type Cat_021_2_3 = TAsterix34 +type Cat_021_2_4 = TAsterix35 +type Cat_021_2_5 = TAsterix36 +type Cat_021_2_6 = TAsterix37 +type Cat_021_2_7 = TAsterix38 +type Cat_023_1_2 = TAsterix39 +type Cat_023_1_3 = TAsterix40 +type Cat_025_1_5 = TAsterix41 +type Cat_025_1_6 = TAsterix42 +type Cat_032_1_1 = TAsterix43 +type Cat_032_1_2 = TAsterix44 +type Cat_034_1_27 = TAsterix45 +type Cat_034_1_28 = TAsterix46 +type Cat_034_1_29 = TAsterix47 +type Ref_048_1_11 = TAsterix48 +type Ref_048_1_12 = TAsterix49 +type Ref_048_1_13 = TAsterix50 +type Cat_048_1_27 = TAsterix51 +type Cat_048_1_28 = TAsterix52 +type Cat_048_1_29 = TAsterix53 +type Cat_048_1_30 = TAsterix54 +type Cat_048_1_31 = TAsterix55 +type Cat_048_1_32 = TAsterix56 +type Ref_062_1_2 = TAsterix57 +type Ref_062_1_3 = TAsterix58 +type Cat_062_1_16 = TAsterix59 +type Cat_062_1_17 = TAsterix60 +type Cat_062_1_18 = TAsterix61 +type Cat_062_1_19 = TAsterix62 +type Cat_062_1_20 = TAsterix63 +type Cat_062_1_21 = TAsterix64 +type Cat_063_1_6 = TAsterix65 +type Cat_063_1_7 = TAsterix66 +type Cat_065_1_4 = TAsterix67 +type Cat_065_1_5 = TAsterix68 +type Cat_065_1_6 = TAsterix69 +type Cat_150_3_0 = TAsterix70 +type Cat_205_1_0 = TAsterix71 +type Cat_240_1_3 = TAsterix72 +type Cat_247_1_2 = TAsterix73 +type Cat_247_1_3 = TAsterix74 + +-- Manifest + +manifest :: [GAsterix 'ValueLevel] +manifest = + [ schema @Cat_001_1_2 Proxy + , schema @Cat_001_1_3 Proxy + , schema @Cat_001_1_4 Proxy + , schema @Cat_002_1_0 Proxy + , schema @Cat_002_1_1 Proxy + , schema @Cat_002_1_2 Proxy + , schema @Cat_004_1_12 Proxy + , schema @Cat_004_1_13 Proxy + , schema @Cat_007_1_12 Proxy + , schema @Cat_008_1_2 Proxy + , schema @Cat_008_1_3 Proxy + , schema @Cat_009_2_1 Proxy + , schema @Cat_010_1_1 Proxy + , schema @Cat_011_1_2 Proxy + , schema @Cat_011_1_3 Proxy + , schema @Cat_015_1_0 Proxy + , schema @Cat_015_1_1 Proxy + , schema @Cat_015_1_2 Proxy + , schema @Cat_016_1_0 Proxy + , schema @Cat_017_1_3 Proxy + , schema @Cat_018_1_7 Proxy + , schema @Cat_018_1_8 Proxy + , schema @Cat_019_1_3 Proxy + , schema @Cat_020_1_9 Proxy + , schema @Cat_020_1_10 Proxy + , schema @Cat_020_1_11 Proxy + , schema @Cat_021_0_23 Proxy + , schema @Cat_021_0_24 Proxy + , schema @Cat_021_0_25 Proxy + , schema @Cat_021_0_26 Proxy + , schema @Ref_021_1_4 Proxy + , schema @Ref_021_1_5 Proxy + , schema @Cat_021_2_1 Proxy + , schema @Cat_021_2_2 Proxy + , schema @Cat_021_2_3 Proxy + , schema @Cat_021_2_4 Proxy + , schema @Cat_021_2_5 Proxy + , schema @Cat_021_2_6 Proxy + , schema @Cat_021_2_7 Proxy + , schema @Cat_023_1_2 Proxy + , schema @Cat_023_1_3 Proxy + , schema @Cat_025_1_5 Proxy + , schema @Cat_025_1_6 Proxy + , schema @Cat_032_1_1 Proxy + , schema @Cat_032_1_2 Proxy + , schema @Cat_034_1_27 Proxy + , schema @Cat_034_1_28 Proxy + , schema @Cat_034_1_29 Proxy + , schema @Ref_048_1_11 Proxy + , schema @Ref_048_1_12 Proxy + , schema @Ref_048_1_13 Proxy + , schema @Cat_048_1_27 Proxy + , schema @Cat_048_1_28 Proxy + , schema @Cat_048_1_29 Proxy + , schema @Cat_048_1_30 Proxy + , schema @Cat_048_1_31 Proxy + , schema @Cat_048_1_32 Proxy + , schema @Ref_062_1_2 Proxy + , schema @Ref_062_1_3 Proxy + , schema @Cat_062_1_16 Proxy + , schema @Cat_062_1_17 Proxy + , schema @Cat_062_1_18 Proxy + , schema @Cat_062_1_19 Proxy + , schema @Cat_062_1_20 Proxy + , schema @Cat_062_1_21 Proxy + , schema @Cat_063_1_6 Proxy + , schema @Cat_063_1_7 Proxy + , schema @Cat_065_1_4 Proxy + , schema @Cat_065_1_5 Proxy + , schema @Cat_065_1_6 Proxy + , schema @Cat_150_3_0 Proxy + , schema @Cat_205_1_0 Proxy + , schema @Cat_240_1_3 Proxy + , schema @Cat_247_1_2 Proxy + , schema @Cat_247_1_3 Proxy + ] + diff --git a/src/Asterix/Schema.hs b/src/Asterix/Schema.hs new file mode 100644 --- /dev/null +++ b/src/Asterix/Schema.hs @@ -0,0 +1,770 @@ +-- | +-- Module: Asterix.Schema +-- +-- This module defines generic asterix structures which can be used as types +-- and as values. This imposes some complexity, mainly because of the fact that +-- in haskell, all type information is erased during program compilation. In +-- other words: normally types are only important when writting and compiling +-- the code, not when running it. Whatever is required at runtime must be +-- explicitely "created" during compile phase. +-- +-- A standard approach to convert type level information to the value level +-- equivalent is to use typeclasses and instances. Regular function don't work +-- in this case. +-- +-- An approach taken in this library is to have: +-- - generic structures from this module, for type or value level usecases; +-- - generated file where complete asterix specs are defined as types; +-- - conversion rules (as typeclasses and instances) from this module to have +-- runtime equivalent of complete asterix specs at value level too; +-- +-- Naming convention: +-- +-- * GSomething ... generic definition of 'Something' +-- It is indexed by 'Usecase' type parameter. +-- +-- * TSomething ... type level definition of 'Something', defined as: +-- type TSomething = GSomething 'TypeLevel +-- +-- * VSomething ... value level definition of 'Something', defined as: +-- type VSomething = GSomething 'ValueLevel +-- +-- The type level definitions (TSomething) are generated in a separate module. +-- The 'schema' function from Schema typeclass converts from +-- TSomething -> VSomething, such that any specification part can also be +-- used at runtime. + +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE PolyKinds #-} +{-# LANGUAGE TypeFamilyDependencies #-} +{-# LANGUAGE UndecidableInstances #-} + +module Asterix.Schema +( module Asterix.Schema +, module Data.Proxy +) where + +import Data.Proxy +import Data.Text +import Data.Type.Bool +import Data.Type.Equality +import Data.Type.Ord +import GHC.TypeLits + +-- | Type or value level usecase. +data Usecase + = TypeLevel + | ValueLevel + +-- | Generic Int is 'Nat' or 'Integer'. +type family GInt (u :: Usecase) = r | r -> u where + GInt 'TypeLevel = Nat + GInt 'ValueLevel = Int + +type TInt = GInt 'TypeLevel +type VInt = GInt 'ValueLevel + +-- | Integer in the interval [0..7]. +newtype Int8 = Int8 { unInt8 :: Int } + deriving (Show, Eq) + +class KnownNat8 (n :: Nat) where + natVal8 :: Proxy n -> Int8 + +instance (KnownNat n, n <= 7) => KnownNat8 n where + natVal8 = Int8 . fromIntegral . natVal + +-- | Generic Text is 'Symbol' or 'Text'. +type family GText (u :: Usecase) = r | r -> u where + GText 'TypeLevel = Symbol + GText 'ValueLevel = Text + +type TText = GText 'TypeLevel +type VText = GText 'ValueLevel + +-- Generic asterix schema + +-- | Rule. +data GRule (u :: Usecase) t + = GContextFree t + | GDependent [[GText u]] t [([GInt u], t)] +deriving instance Show t => Show (GRule 'ValueLevel t) + +type TRule = GRule 'TypeLevel +type VRule = GRule 'ValueLevel + +-- | String type. +data GStringType + = GStringAscii + | GStringICAO + | GStringOctal + deriving Show + +type TStringType = GStringType +type VStringType = GStringType + +-- | Signed or unsigned. +data GSignedness + = GSigned + | GUnsigned + deriving Show + +type TSignedness = GSignedness +type VSignedness = GSignedness + +-- | Plus or minus. +data GPlusMinus + = GPlus + | GMinus + deriving Show + +type TPlusMinus = GPlusMinus +type VPlusMinus = GPlusMinus + +-- | Positive or negative integer numbers. +data GZ (u :: Usecase) = GZ GPlusMinus (GInt u) +deriving instance Show (GZ 'ValueLevel) + +type TZ = GZ 'TypeLevel +type VZ = GZ 'ValueLevel + +-- | A number without rounding errors. +data GNumber (u :: Usecase) + = GNumInt (GZ u) + | GNumDiv (GNumber u) (GNumber u) + | GNumPow (GZ u) (GZ u) +deriving instance Show (GNumber 'ValueLevel) + +type TNumber = GNumber 'TypeLevel +type VNumber = GNumber 'ValueLevel + +-- | BDS type. +data GBdsType (u :: Usecase) + = GBdsWithAddress + | GBdsAt (Maybe (GInt u)) +deriving instance Show (GBdsType 'ValueLevel) + +type TBdsType = GBdsType 'TypeLevel +type VBdsType = GBdsType 'ValueLevel + +-- | Type of content. +data GContent (u :: Usecase) + = GContentRaw + | GContentTable [(GInt u, GText u)] + | GContentString GStringType + | GContentInteger GSignedness + | GContentQuantity GSignedness (GNumber u) (GText u) + | GContentBds (GBdsType u) +deriving instance Show (GContent 'ValueLevel) + +type TContent = GContent 'TypeLevel +type VContent = GContent 'ValueLevel + +-- | Repetitive type. +data GRepetitiveType (u :: Usecase) + = GRepetitiveRegular (GInt u) + | GRepetitiveFx +deriving instance Show (GRepetitiveType 'ValueLevel) + +type TRepetitiveType = GRepetitiveType 'TypeLevel +type VRepetitiveType = GRepetitiveType 'ValueLevel + +-- | Explicit type. +data GExplicitType + = GReservedExpansion + | GSpecialPurpose + deriving Show + +type TExplicitType = GExplicitType +type VExplicitType = GExplicitType + +-- | Variation. +data GVariation (u :: Usecase) + = GElement (GInt u) (GInt u) (GRule u (GContent u)) -- offset size + | GGroup (GInt u) [GItem u] -- offset items + | GExtended [Maybe (GItem u)] + | GRepetitive (GRepetitiveType u) (GVariation u) + | GExplicit (Maybe GExplicitType) + | GCompound [Maybe (GNonSpare u)] +deriving instance Show (GVariation 'ValueLevel) + +type TVariation = GVariation 'TypeLevel +type VVariation = GVariation 'ValueLevel + +-- | NonSpare. +data GNonSpare (u :: Usecase) + = GNonSpare (GText u) (GText u) (GRule u (GVariation u)) -- name, title +deriving instance Show (GNonSpare 'ValueLevel) + +type TNonSpare = GNonSpare 'TypeLevel +type VNonSpare = GNonSpare 'ValueLevel + +-- | Item. +data GItem (u :: Usecase) + = GSpare (GInt u) (GInt u) -- offset size + | GItem (GNonSpare u) +deriving instance Show (GItem 'ValueLevel) + +type TItem = GItem 'TypeLevel +type VItem = GItem 'ValueLevel + +-- | UAP Item. +data GUapItem (u :: Usecase) + = GUapItem (GNonSpare u) + | GUapItemSpare + | GUapItemRFS +deriving instance Show (GUapItem 'ValueLevel) + +type TUapItem = GUapItem 'TypeLevel +type VUapItem = GUapItem 'ValueLevel + +-- | Record. +newtype GRecord (u :: Usecase) = GRecord [GUapItem u] +deriving instance Show (GRecord 'ValueLevel) + +type TRecord = GRecord 'TypeLevel +type VRecord = GRecord 'ValueLevel + +-- | UAP selector. +data GUapSelector (u :: Usecase) = GUapSelector [GText u] [(GInt u, GText u)] +deriving instance Show (GUapSelector 'ValueLevel) + +type TUapSelector = GUapSelector 'TypeLevel +type VUapSelector = GUapSelector 'ValueLevel + +-- | User application profile. +data GUap (u :: Usecase) + = GUap (GRecord u) + | GUaps [(GText u, GRecord u)] (Maybe (GUapSelector u)) +deriving instance Show (GUap 'ValueLevel) + +type TUap = GUap 'TypeLevel +type VUap = GUap 'ValueLevel + +-- | Datablock. +data GDatablock (u :: Usecase) = GDatablock (GInt u) (GUap u) -- cat uap +deriving instance Show (GDatablock 'ValueLevel) + +type TDatablock = GDatablock 'TypeLevel +type VDatablock = GDatablock 'ValueLevel + +-- | Expansion. +data GExpansion (u :: Usecase) = GExpansion (Maybe (GInt u)) [Maybe (GNonSpare u)] +deriving instance Show (GExpansion 'ValueLevel) + +type TExpansion = GExpansion 'TypeLevel +type VExpansion = GExpansion 'ValueLevel + +-- | Edition. +data GEdition (u :: Usecase) = GEdition (GInt u) (GInt u) -- major, minor +deriving instance Show (GEdition 'ValueLevel) + +type TEdition = GEdition 'TypeLevel +type VEdition = GEdition 'ValueLevel + +deriving instance Eq VEdition +instance Ord VEdition where + compare (GEdition a1 b1) (GEdition a2 b2) + = compare a1 a2 + <> compare b1 b2 + +-- | Toplevel asterix structure. +data GAsterix (u :: Usecase) + = GAsterixBasic (GInt u) (GEdition u) (GUap u) -- cat + | GAsterixExpansion (GInt u) (GEdition u) (GExpansion u) -- cat +deriving instance Show (GAsterix 'ValueLevel) + +type TAsterix = GAsterix 'TypeLevel +type VAsterix = GAsterix 'ValueLevel + +-- | Convert structures from type level 't' to value level 'a', +-- with 'schema' function. +class Schema t a where + schema :: Proxy t -> a + +instance KnownNat n => Schema n Int where + schema _ = fromIntegral $ natVal @n Proxy + +instance KnownNat8 n => Schema n Int8 where + schema _ = natVal8 @n Proxy + +instance KnownSymbol s => Schema s Text where + schema _ = Data.Text.pack $ symbolVal @s Proxy + +instance Schema 'Nothing (Maybe a) where + schema _ = Nothing + +instance + ( Schema t a + ) => Schema ('Just t) (Maybe a) where + schema _ = Just (schema @t Proxy) + +instance Schema '[] [a] where + schema _ = [] + +instance + ( Schema t a + , Schema ts [a] + ) => Schema (t ': ts) [a] where + schema _ = schema @t Proxy : schema @ts Proxy + +instance + ( Schema t1 a1 + , Schema t2 a2 + ) => Schema '(t1, t2) (a1, a2) where + schema _ = (schema @t1 Proxy, schema @t2 Proxy) + +instance + ( Schema t (f 'ValueLevel) + ) => Schema + ('GContextFree (t :: f 'TypeLevel)) + (GRule 'ValueLevel (f 'ValueLevel)) where + schema _ = GContextFree (schema @t Proxy) + +instance + ( Schema lst1 [[Text]] + , Schema t (f 'ValueLevel) + , Schema lst2 [([Int], f ValueLevel)] + ) => Schema + ('GDependent lst1 (t :: f 'TypeLevel) lst2) + (GRule 'ValueLevel (f 'ValueLevel)) where + schema _= GDependent + (schema @lst1 Proxy) + (schema @t Proxy) + (schema @lst2 Proxy) + +instance Schema 'GStringAscii GStringType where + schema _ = GStringAscii + +instance Schema 'GStringICAO GStringType where + schema _ = GStringICAO + +instance Schema 'GStringOctal GStringType where + schema _ = GStringOctal + +instance Schema 'GSigned GSignedness where + schema _ = GSigned + +instance Schema 'GUnsigned GSignedness where + schema _ = GUnsigned + +instance Schema 'GPlus GPlusMinus where + schema _ = GPlus + +instance Schema 'GMinus GPlusMinus where + schema _ = GMinus + +instance + ( Schema pm GPlusMinus + , Schema n Int + ) => Schema ('GZ pm n) VZ where + schema _ = GZ (schema @pm Proxy) (schema @n Proxy) + +instance + ( Schema z VZ + ) => Schema ('GNumInt z) VNumber where + schema _ = GNumInt (schema @z Proxy) + +instance + ( Schema n1 (GNumber ValueLevel) + , Schema n2 (GNumber ValueLevel) + ) => Schema ('GNumDiv n1 n2) VNumber where + schema _ = GNumDiv (schema @n1 Proxy) (schema @n2 Proxy) + +instance + ( Schema a (GZ ValueLevel) + , Schema b (GZ ValueLevel) + ) => Schema ('GNumPow a b) VNumber where + schema _ = GNumPow (schema @a Proxy) (schema @b Proxy) + +instance Schema 'GBdsWithAddress VBdsType where + schema _ = GBdsWithAddress + +instance + ( Schema ma (Maybe Int) + ) => Schema ('GBdsAt ma) VBdsType where + schema _ = GBdsAt (schema @ma Proxy) + +instance Schema 'GContentRaw VContent where + schema _ = GContentRaw + +instance + ( Schema lst [(Int, Text)] + ) => Schema ('GContentTable lst) VContent where + schema _ = GContentTable (schema @lst @[(Int, Text)] Proxy) + +instance + ( Schema st GStringType + ) => Schema ('GContentString st) VContent where + schema _ = GContentString (schema @st Proxy) + +instance + ( Schema sig GSignedness + ) => Schema ('GContentInteger sig) VContent where + schema _ = GContentInteger (schema @sig Proxy) + +instance + ( Schema sig GSignedness + , Schema lsb (GNumber ValueLevel) + , Schema unit Text + ) => Schema ('GContentQuantity sig lsb unit) VContent where + schema _ = GContentQuantity + (schema @sig Proxy) + (schema @lsb Proxy) + (schema @unit Proxy) + +instance + ( Schema bt (GBdsType ValueLevel) + ) => Schema ('GContentBds bt) VContent where + schema _ = GContentBds (schema @bt Proxy) + +instance + ( Schema n Int + ) => Schema ('GRepetitiveRegular n) VRepetitiveType where + schema _ = GRepetitiveRegular (schema @n Proxy) + +instance Schema 'GRepetitiveFx VRepetitiveType where + schema _ = GRepetitiveFx + +instance Schema 'GReservedExpansion GExplicitType where + schema _ = GReservedExpansion + +instance Schema 'GSpecialPurpose GExplicitType where + schema _ = GSpecialPurpose + +instance + ( Schema o Int8 + , Schema n Int + , Schema rule (VRule VContent) + ) => Schema ('GElement o n rule) VVariation where + schema _ = GElement + (unInt8 $ schema @o Proxy) + (schema @n Proxy) + (schema @rule Proxy) + +instance + ( Schema o Int8 + , Schema ts [VItem] + ) => Schema ('GGroup o ts) VVariation where + schema _ = GGroup (unInt8 $ schema @o Proxy) (schema @ts Proxy) + +instance + ( Schema lst [Maybe VItem] + ) => Schema ('GExtended lst) VVariation where + schema _ = GExtended (schema @lst Proxy) + +instance + ( Schema rt VRepetitiveType + , Schema var VVariation + ) => Schema ('GRepetitive rt var) VVariation where + schema _ = GRepetitive (schema @rt Proxy) (schema @var Proxy) + +instance + ( Schema met (Maybe GExplicitType) + ) => Schema ('GExplicit met) VVariation where + schema _ = GExplicit (schema @met Proxy) + +instance + ( Schema lst [Maybe VNonSpare] + ) => Schema ('GCompound lst) VVariation where + schema _ = GCompound (schema @lst Proxy) + +instance + ( Schema name Text + , Schema title Text + , Schema rule (VRule VVariation) + ) => Schema ('GNonSpare name title rule) VNonSpare where + schema _ = GNonSpare + (schema @name Proxy) + (schema @title Proxy) + (schema @rule Proxy) + +instance + ( Schema o Int8 + , Schema n Int + ) => Schema ('GSpare o n) VItem where + schema _ = GSpare (unInt8 $ schema @o Proxy) (schema @n Proxy) + +instance + ( Schema nsp VNonSpare + ) => Schema ('GItem nsp) VItem where + schema _ = GItem (schema @nsp Proxy) + +instance + ( Schema nsp VNonSpare + ) => Schema ('GUapItem nsp) VUapItem where + schema _ = GUapItem (schema @nsp Proxy) + +instance Schema 'GUapItemSpare VUapItem where + schema _ = GUapItemSpare + +instance Schema 'GUapItemRFS VUapItem where + schema _ = GUapItemRFS + +instance + ( Schema lst [VUapItem] + ) => Schema ('GRecord lst) VRecord where + schema _ = GRecord (schema @lst Proxy) + +instance + ( Schema iname [Text] + , Schema lst [(Int, Text)] + ) => Schema ('GUapSelector iname lst) VUapSelector where + schema _ = GUapSelector (schema @iname Proxy) (schema @lst Proxy) + +instance + ( Schema rec VRecord + ) => Schema ('GUap rec) VUap where + schema _ = GUap (schema @rec Proxy) + +instance + ( Schema lst [(Text, VRecord)] + , Schema msel (Maybe VUapSelector) + ) => Schema ('GUaps lst msel) VUap where + schema _ = GUaps (schema @lst Proxy) (schema @msel Proxy) + +instance + ( Schema cat Int + , Schema uap VUap + ) => Schema ('GDatablock cat uap) VDatablock where + schema _ = GDatablock (schema @cat Proxy) (schema @uap Proxy) + +instance + ( Schema mn (Maybe Int) + , Schema lst [Maybe VNonSpare] + ) => Schema ('GExpansion mn lst) VExpansion where + schema _ = GExpansion (schema @mn Proxy) (schema @lst Proxy) + +instance + ( Schema a Int + , Schema b Int + ) => Schema ('GEdition a b) VEdition where + schema _ = GEdition (schema @a Proxy) (schema @b Proxy) + +instance + ( Schema cat Int + , Schema ed VEdition + , Schema uap VUap + ) => Schema ('GAsterixBasic cat ed uap) VAsterix where + schema _ = GAsterixBasic + (schema @cat Proxy) + (schema @ed Proxy) + (schema @uap Proxy) + +instance + ( name ~ VText + , uap ~ 'GUaps lst msel + , Schema lst [(VText, VRecord)] + ) => Schema ('GAsterixBasic cat ed uap) [(name, VRecord)] where + schema _ = schema @lst Proxy + +instance + ( Schema cat Int + , Schema ed VEdition + , Schema exp VExpansion + ) => Schema ('GAsterixExpansion cat ed exp) VAsterix where + schema _ = GAsterixExpansion + (schema @cat Proxy) + (schema @ed Proxy) + (schema @exp Proxy) + +-- | TypeError wrapper. +type Unspecified (t :: k) + = TypeError ('Text "Unspecified " :<>: ShowType t) + +-- | Name is not defined. +type NotDefined (name :: Symbol) + = TypeError ('Text "Not defined: " :<>: 'Text name) + +-- | Type level lookup. +type family Lookup (name :: Symbol) (lst :: [(Symbol, k)]) :: k where + Lookup name '[] = NotDefined name + Lookup name1 ( '(name2, uap) ': ts) = If + (name1 == name2) + uap + (Lookup name1 ts) + +-- | Statically known bit sizes. +type BitSizeOf :: k -> Nat +type family BitSizeOf t where + BitSizeOf '[] = 0 + BitSizeOf (t ': ts) = BitSizeOf t + BitSizeOf ts + BitSizeOf ('GElement o n rc) = n + BitSizeOf ('GGroup o lst) = BitSizeOf lst + BitSizeOf ('GContextFree t) = BitSizeOf t + BitSizeOf ('GDependent lst1 t lst2) = BitSizeOf t + BitSizeOf ('GSpare o n) = n + BitSizeOf ('GNonSpare name title rv) = BitSizeOf rv + BitSizeOf ('GItem nsp) = BitSizeOf nsp + BitSizeOf other = Unspecified other + +-- | Extract category. +type CategoryOf :: k -> Nat +type family CategoryOf t where + CategoryOf ('GAsterixBasic cat ed uap) = cat + CategoryOf ('GDatablock cat uap) = cat + CategoryOf other = Unspecified other + +-- | Extract record type from single uap basic asterix. +type RecordOf :: TAsterix -> TRecord +type family RecordOf t where + RecordOf ('GAsterixBasic cat ed ('GUap rec)) = rec + RecordOf other = Unspecified other + +-- | Extract record type from multiple uap basic asterix. +type RecordOfUap :: TAsterix -> Symbol -> TRecord +type family RecordOfUap t name where + RecordOfUap ('GAsterixBasic cat ed ('GUaps lst sel)) name + = Lookup name lst + RecordOfUap other name = Unspecified other + +-- | Get Datablock type. +type family DatablockOf (t :: TAsterix) :: TDatablock where + DatablockOf ('GAsterixBasic cat ed uap) = 'GDatablock cat uap + DatablockOf other = Unspecified other + +-- | Get Expansion type. +type family ExpansionOf (t :: GAsterix u) :: GExpansion u where + ExpansionOf ('GAsterixExpansion cat ed exp) = exp + ExpansionOf other = Unspecified other + +-- | Extract first group of extension. +type family ExtendedFirstGroup (lst :: [Maybe a]) :: [a] where + ExtendedFirstGroup '[] = '[] + ExtendedFirstGroup ('Nothing ': ts) = '[] + ExtendedFirstGroup ('Just t ': ts) = t ': ExtendedFirstGroup ts + +-- | Does extended end with Fx? +type family ExtendedTrailingFx (lst :: [Maybe a]) :: Bool where + ExtendedTrailingFx '[] = 'False + ExtendedTrailingFx ('Nothing ': ts) = 'True + ExtendedTrailingFx ('Just t ': ts) = ExtendedTrailingFx ts + +-- | Remaining extended items. +type family ExtendedRemainingItems (lst :: [Maybe a]) :: [Maybe a] where + ExtendedRemainingItems '[] = '[] + ExtendedRemainingItems ('Nothing ': ts) = ts + ExtendedRemainingItems ('Just t ': ts) = ExtendedRemainingItems ts + +-- | Extract record type from datablock type. +type family TypeOfRecord (t :: TDatablock) :: TRecord where + TypeOfRecord ('GDatablock cat ('GUap rec)) = rec + TypeOfRecord db = TypeError ('Text "Not defined") + +-- | Does this datablock contain multiple UAPs? +type family IsMultiUap (t :: GDatablock u) :: Bool where + IsMultiUap ('GDatablock cat ('GUap rec)) = 'False + IsMultiUap ('GDatablock cat ('GUaps lst sel)) = 'True + +-- | Find UAP name, based on given record. +type family UapName r lst :: Symbol where + UapName r '[] = TypeError ('Text "Wrong record" :<>: ShowType r) + UapName r1 ( '(name, r2) ': ts) = If + (r1 == r2) + name + (UapName r1 ts) + +-- | Find group subitem by name. +type family LookupGroup (name :: Symbol) (lst :: [TItem]) :: Nat where + LookupGroup name '[] = NotDefined name + LookupGroup name ('GSpare o n ': ts) = 1 + LookupGroup name ts + LookupGroup name ('GItem ('GNonSpare name1 title rv) ': ts) = If + (name1 == name) 0 (1 + LookupGroup name ts) + +-- | Find extended subitem by name. +type family LookupExtended (name :: Symbol) (lst :: [Maybe TItem]) :: Nat where + LookupExtended name '[] = NotDefined name + LookupExtended name ('Nothing ': ts) = 1 + LookupExtended name ts + LookupExtended name ('Just ('GSpare o n) ': ts) = 1 + LookupExtended name ts + LookupExtended name ('Just ('GItem ('GNonSpare name1 title rv)) ': ts) = If + (name1 == name) 0 (1 + LookupExtended name ts) + +-- | Find compound subitem by name. +type family LookupCompound (name :: Symbol) (lst :: [Maybe TNonSpare]) :: Nat where + LookupCompound name '[] = NotDefined name + LookupCompound name ('Nothing ': ts) = 1 + LookupCompound name ts + LookupCompound name ('Just ('GNonSpare name1 title rv) ': ts) = If + (name1 == name) 0 (1 + LookupCompound name ts) + +-- | Find record subitem by name. +type family LookupRecord (name :: Symbol) (lst :: [TUapItem]) :: Nat where + LookupRecord name '[] = NotDefined name + LookupRecord name ('GUapItem ('GNonSpare name1 title rv) ': ts) = If + (name1 == name) 0 (1 + LookupRecord name ts) + LookupRecord name ('GUapItemSpare ': ts) = 1 + LookupRecord name ts + LookupRecord name ('GUapItemRFS ': ts) = 1 + LookupRecord name ts + +-- | Extract NonSpares from uap item listing. +type family RecordNonSpares (t :: [TUapItem]) :: [TNonSpare] + where + RecordNonSpares '[] = '[] + RecordNonSpares ('GUapItem nsp ': ts) = nsp ': RecordNonSpares ts + RecordNonSpares ('GUapItemSpare ': ts) = RecordNonSpares ts + RecordNonSpares ('GUapItemRFS ': ts) = RecordNonSpares ts + +-- | Extract NonSpares from item listing. +type family ItemNonSpares (t :: [TItem]) :: [TNonSpare] + where + ItemNonSpares '[] = '[] + ItemNonSpares ('GSpare o2 n2 ': ts) = ItemNonSpares ts + ItemNonSpares ('GItem nsp ': ts) = nsp ': ItemNonSpares ts + +-- | Type level list filtering. +type family FilterMaybe (lst :: [Maybe a]) :: [a] where + FilterMaybe '[] = '[] + FilterMaybe ('Nothing ': ts) = FilterMaybe ts + FilterMaybe ('Just t ': ts) = t ': FilterMaybe ts + +-- | Prepend name. +type family PrependName t where + PrependName '[] = '[] + PrependName ('GNonSpare name title rv ': ts) + = '(name, 'GNonSpare name title rv) ': PrependName ts + +-- | Overloaded type level function to extract subtype from parent, based on name. +type (~>) :: k -> Symbol -> TNonSpare +type family (~>) t name where + (~>) ('GGroup o lst) name + = Lookup name (PrependName (ItemNonSpares lst)) + (~>) ('GExtended lst) name + = Lookup name (PrependName (ItemNonSpares (FilterMaybe lst))) + (~>) ('GRepetitive rt var) name + = var ~> name + (~>) ('GCompound lst) name + = Lookup name (PrependName (FilterMaybe lst)) + (~>) ('GNonSpare pname title ('GContextFree ('GGroup o lst))) name + = 'GGroup o lst ~> name + (~>) ('GNonSpare pname title ('GContextFree ('GExtended lst))) name + = 'GExtended lst ~> name + (~>) ('GNonSpare pname title ('GContextFree ('GRepetitive rt var))) name + = 'GRepetitive rt var ~> name + (~>) ('GNonSpare pname title ('GContextFree ('GCompound lst))) name + = 'GCompound lst ~> name + (~>) ('GRecord lst) name + = Lookup name (PrependName (RecordNonSpares lst)) + (~>) ('GExpansion mn lst) name + = Lookup name (PrependName (FilterMaybe lst)) + (~>) ('GAsterixBasic cat ed ('GUap ('GRecord lst))) name + = Lookup name (PrependName (RecordNonSpares lst)) + (~>) ('GAsterixExpansion cat ed ('GExpansion mn lst)) name + = 'GExpansion mn lst ~> name + (~>) k name = TypeError ('Text "Undefined argument: " :<>: ShowType k) + +-- | Extract dependent rule. +type family DepRule2 lst ix where + DepRule2 ('(ix1, t) ': ts) ix = If (ix1 == ix) t (DepRule2 ts ix) + DepRule2 t ix = TypeError ('Text "Undefined rule: " :<>: ShowType ix) +type family DepRule t ix where + DepRule ('GNonSpare name title ('GDependent lst1 d lst2)) ix = DepRule2 lst2 ix + +-- | All of the given types in a non-empty list must be the same, +-- return that type. Usage example: +-- type TSacSic = SameType '[ Cat034 ~> "010", Cat048 ~> "010"] +type family SameType (t :: [k]) :: k where + SameType '[] = TypeError ('Text "Empty list") + SameType (t ': '[]) = t + SameType (t1 ': t2 ': ts) = If + (t1 == t2) + (SameType (t2 ': ts)) + (TypeError ('Text "Type mismatch")) + diff --git a/test/Common.hs b/test/Common.hs new file mode 100644 --- /dev/null +++ b/test/Common.hs @@ -0,0 +1,49 @@ +{-# LANGUAGE LambdaCase #-} + +module Common where + +import Data.Char +import Data.Maybe +import Test.Tasty.HUnit + +import Asterix.Base +import Asterix.Coding + +approximately :: (Ord a, Fractional a) => a -> a -> a -> Bool +approximately err a b = abs (b - a) / a < err + +assertApproximately :: (Ord a, Fractional a) => + String -> a -> a -> a -> Assertion +assertApproximately name err a b = assertEqual name True + (approximately err a b) + +assertUint :: Unparsing Bits t => Integer -> t -> Assertion +assertUint n obj = assertEqual "uint" n (asUint obj) + +assertUnparse :: Unparsing Bits t => String -> t -> Assertion +assertUnparse s obj = assertEqual "unparse" + (debugBits @Bits $ byteStringToBits (fromJust $ unhexlify s)) + (debugBits @Bits $ unparse obj) + +assertOne :: [a] -> IO a +assertOne [x] = pure x +assertOne _ = assertFailure "expecting list of length 1" + +data StResult + = Bin String + | Hex String + +checkBits :: Unparsing Bits a => String -> a -> StResult -> Assertion +checkBits name x = \case + Bin y -> assertEqual name y (debugBits s) + Hex y -> assertEqual name y + (hexlify $ builderToByteStringSlow $ bitsToBuilder s) + where + s = unparse x + +rStrip :: String -> String +rStrip + = reverse + . dropWhile isSpace + . reverse + diff --git a/test/Generated.hs b/test/Generated.hs new file mode 100644 --- /dev/null +++ b/test/Generated.hs @@ -0,0 +1,444 @@ +-- | Asterix specifications + +-- This file is generated, DO NOT EDIT! +-- For more details, see: +-- - https://github.com/zoranbosnjak/asterix-specs + +-- Types are BIG, disable depth checking. +{-# OPTIONS_GHC -freduction-depth=0 #-} + +{-# LANGUAGE DataKinds #-} + +module Generated where + +import Asterix.Schema + +-- Asterix types + +type TContent0 = 'GContentRaw +type TRuleContent0 = 'GContextFree TContent0 +type TVariation7 = 'GElement 0 8 TRuleContent0 +type TRuleVariation7 = 'GContextFree TVariation7 +type TNonSpare84 = 'GNonSpare "SAC" "System Area Code" TRuleVariation7 +type TItem34 = 'GItem TNonSpare84 +type TNonSpare87 = 'GNonSpare "SIC" "System Identification Code" TRuleVariation7 +type TItem37 = 'GItem TNonSpare87 +type TVariation44 = 'GGroup 0 '[ TItem34, TItem37] +type TRuleVariation40 = 'GContextFree TVariation44 +type TNonSpare3 = 'GNonSpare "010" "Data Source Identifier" TRuleVariation40 +type TUapItem3 = 'GUapItem TNonSpare3 +type TContent7 = 'GContentTable '[ '(1, "Message 1"), '(2, "Message 2"), '(3, "Message 3")] +type TRuleContent7 = 'GContextFree TContent7 +type TVariation9 = 'GElement 0 8 TRuleContent7 +type TRuleVariation9 = 'GContextFree TVariation9 +type TNonSpare0 = 'GNonSpare "000" "Message Type" TRuleVariation9 +type TUapItem0 = 'GUapItem TNonSpare0 +type TNonSpare80 = 'GNonSpare "R" "Raw" TRuleVariation7 +type TContent4 = 'GContentTable '[ '(0, "Test 0"), '(1, "Test 1"), '(2, "Test 2"), '(3, "Test 3")] +type TRuleContent4 = 'GContextFree TContent4 +type TVariation8 = 'GElement 0 8 TRuleContent4 +type TRuleVariation8 = 'GContextFree TVariation8 +type TNonSpare88 = 'GNonSpare "T" "Table" TRuleVariation8 +type TContent9 = 'GContentString 'GStringAscii +type TRuleContent9 = 'GContextFree TContent9 +type TVariation22 = 'GElement 0 56 TRuleContent9 +type TRuleVariation22 = 'GContextFree TVariation22 +type TNonSpare81 = 'GNonSpare "S1" "String Ascii" TRuleVariation22 +type TContent10 = 'GContentString 'GStringICAO +type TRuleContent10 = 'GContextFree TContent10 +type TVariation21 = 'GElement 0 48 TRuleContent10 +type TRuleVariation21 = 'GContextFree TVariation21 +type TNonSpare82 = 'GNonSpare "S2" "String ICAO" TRuleVariation21 +type TContent11 = 'GContentString 'GStringOctal +type TRuleContent11 = 'GContextFree TContent11 +type TVariation17 = 'GElement 0 24 TRuleContent11 +type TRuleVariation17 = 'GContextFree TVariation17 +type TNonSpare83 = 'GNonSpare "S3" "String Octal" TRuleVariation17 +type TContent13 = 'GContentInteger 'GUnsigned +type TRuleContent13 = 'GContextFree TContent13 +type TVariation11 = 'GElement 0 8 TRuleContent13 +type TRuleVariation11 = 'GContextFree TVariation11 +type TNonSpare60 = 'GNonSpare "I1" "Unsigned Integer" TRuleVariation11 +type TContent12 = 'GContentInteger 'GSigned +type TRuleContent12 = 'GContextFree TContent12 +type TVariation10 = 'GElement 0 8 TRuleContent12 +type TRuleVariation10 = 'GContextFree TVariation10 +type TNonSpare65 = 'GNonSpare "I2" "Signed Integer" TRuleVariation10 +type TContent15 = 'GContentQuantity 'GSigned ('GNumDiv ('GNumInt ('GZ 'GPlus 180)) ('GNumPow ('GZ 'GPlus 2) ('GZ 'GPlus 23))) "°" +type TRuleContent15 = 'GContextFree TContent15 +type TVariation19 = 'GElement 0 24 TRuleContent15 +type TRuleVariation19 = 'GContextFree TVariation19 +type TNonSpare75 = 'GNonSpare "Q1LAT" "Latitude in WGS.84 in Two's Complement Form" TRuleVariation19 +type TContent14 = 'GContentQuantity 'GSigned ('GNumDiv ('GNumInt ('GZ 'GPlus 180)) ('GNumPow ('GZ 'GPlus 2) ('GZ 'GPlus 23))) "°" +type TRuleContent14 = 'GContextFree TContent14 +type TVariation18 = 'GElement 0 24 TRuleContent14 +type TRuleVariation18 = 'GContextFree TVariation18 +type TNonSpare76 = 'GNonSpare "Q2LON" "Longitude in WGS.84 in Two's Complement Form" TRuleVariation18 +type TContent17 = 'GContentQuantity 'GUnsigned ('GNumInt ('GZ 'GPlus 1)) "kt" +type TRuleContent17 = 'GContextFree TContent17 +type TVariation16 = 'GElement 0 16 TRuleContent17 +type TRuleVariation16 = 'GContextFree TVariation16 +type TNonSpare77 = 'GNonSpare "Q3" "Unsigned Quantity" TRuleVariation16 +type TContent16 = 'GContentQuantity 'GUnsigned ('GNumInt ('GZ 'GPlus 1)) "" +type TRuleContent16 = 'GContextFree TContent16 +type TVariation12 = 'GElement 0 8 TRuleContent16 +type TRuleVariation12 = 'GContextFree TVariation12 +type TNonSpare78 = 'GNonSpare "Q4" "Quantity No Unit" TRuleVariation12 +type TContent18 = 'GContentQuantity 'GUnsigned ('GNumDiv ('GNumInt ('GZ 'GMinus 1)) ('GNumInt ('GZ 'GPlus 2))) "" +type TRuleContent18 = 'GContextFree TContent18 +type TVariation13 = 'GElement 0 8 TRuleContent18 +type TRuleVariation13 = 'GContextFree TVariation13 +type TNonSpare79 = 'GNonSpare "Q5" "Negative Lsb" TRuleVariation13 +type TContent24 = 'GContentBds 'GBdsWithAddress +type TRuleContent19 = 'GContextFree TContent24 +type TVariation25 = 'GElement 0 64 TRuleContent19 +type TRuleVariation25 = 'GContextFree TVariation25 +type TNonSpare42 = 'GNonSpare "B1" "Bds With Address" TRuleVariation25 +type TContent25 = 'GContentBds ('GBdsAt 'Nothing) +type TRuleContent20 = 'GContextFree TContent25 +type TVariation23 = 'GElement 0 56 TRuleContent20 +type TRuleVariation23 = 'GContextFree TVariation23 +type TNonSpare43 = 'GNonSpare "B2" "Bds At Unknown Address" TRuleVariation23 +type TContent26 = 'GContentBds ('GBdsAt ('Just 48)) +type TRuleContent21 = 'GContextFree TContent26 +type TVariation24 = 'GElement 0 56 TRuleContent21 +type TRuleVariation24 = 'GContextFree TVariation24 +type TNonSpare44 = 'GNonSpare "B3" "Bds At Known Address" TRuleVariation24 +type TVariation69 = 'GCompound '[ 'Just TNonSpare80, 'Just TNonSpare88, 'Just TNonSpare81, 'Just TNonSpare82, 'Just TNonSpare83, 'Just TNonSpare60, 'Just TNonSpare65, 'Just TNonSpare75, 'Just TNonSpare76, 'Just TNonSpare77, 'Just TNonSpare78, 'Just TNonSpare79, 'Just TNonSpare42, 'Just TNonSpare43, 'Just TNonSpare44] +type TRuleVariation64 = 'GContextFree TVariation69 +type TNonSpare4 = 'GNonSpare "020" "Different Contents" TRuleVariation64 +type TUapItem4 = 'GUapItem TNonSpare4 +type TContent1 = 'GContentTable '[ '(0, "Air Speed = IAS, LSB (Bit-1) = 2^-14 NM/s"), '(1, "Air Speed = Mach, LSB (Bit-1) = 0.001")] +type TRuleContent1 = 'GContextFree TContent1 +type TVariation1 = 'GElement 0 1 TRuleContent1 +type TRuleVariation1 = 'GContextFree TVariation1 +type TNonSpare74 = 'GNonSpare "IM" "" TRuleVariation1 +type TItem33 = 'GItem TNonSpare74 +type TContent23 = 'GContentQuantity 'GUnsigned ('GNumDiv ('GNumInt ('GZ 'GPlus 1)) ('GNumPow ('GZ 'GPlus 2) ('GZ 'GPlus 14))) "NM/s" +type TContent20 = 'GContentQuantity 'GUnsigned ('GNumDiv ('GNumInt ('GZ 'GPlus 1)) ('GNumInt ('GZ 'GPlus 1000))) "Mach" +type TRuleContent23 = 'GDependent '[ '[ "030", "IM"]] TContent0 '[ '( '[ 0], TContent23), '( '[ 1], TContent20)] +type TVariation28 = 'GElement 1 15 TRuleContent23 +type TRuleVariation28 = 'GContextFree TVariation28 +type TNonSpare73 = 'GNonSpare "IAS" "" TRuleVariation28 +type TItem32 = 'GItem TNonSpare73 +type TVariation43 = 'GGroup 0 '[ TItem33, TItem32] +type TRuleVariation39 = 'GContextFree TVariation43 +type TNonSpare6 = 'GNonSpare "030" "Simple Dependent Item" TRuleVariation39 +type TUapItem6 = 'GUapItem TNonSpare6 +type TContent19 = 'GContentQuantity 'GUnsigned ('GNumDiv ('GNumInt ('GZ 'GPlus 1)) ('GNumInt ('GZ 'GPlus 2))) "unit1" +type TContent21 = 'GContentQuantity 'GUnsigned ('GNumDiv ('GNumInt ('GZ 'GPlus 1)) ('GNumPow ('GZ 'GPlus 2) ('GZ 'GPlus 2))) "unit2" +type TContent22 = 'GContentQuantity 'GUnsigned ('GNumDiv ('GNumInt ('GZ 'GPlus 1)) ('GNumPow ('GZ 'GPlus 2) ('GZ 'GPlus 3))) "unit3" +type TRuleContent22 = 'GDependent '[ '[ "010", "SAC"], '[ "010", "SIC"]] TContent0 '[ '( '[ 1, 1], TContent19), '( '[ 1, 2], TContent21), '( '[ 2, 1], TContent22)] +type TVariation14 = 'GElement 0 8 TRuleContent22 +type TRuleVariation14 = 'GContextFree TVariation14 +type TNonSpare7 = 'GNonSpare "031" "Double Dependent Item" TRuleVariation14 +type TUapItem7 = 'GUapItem TNonSpare7 +type TNonSpare53 = 'GNonSpare "I1" "" TRuleVariation7 +type TVariation4 = 'GElement 0 4 TRuleContent0 +type TRuleVariation4 = 'GContextFree TVariation4 +type TNonSpare89 = 'GNonSpare "TID" "Identification of Conflict Categories Definition Table" TRuleVariation4 +type TItem38 = 'GItem TNonSpare89 +type TVariation33 = 'GElement 4 3 TRuleContent0 +type TContent6 = 'GContentTable '[ '(0, "Test0"), '(1, "Test1"), '(2, "Test2")] +type TRuleContent6 = 'GContextFree TContent6 +type TVariation34 = 'GElement 4 3 TRuleContent6 +type TContent8 = 'GContentTable '[ '(3, "Test3"), '(4, "Test4")] +type TRuleContent8 = 'GContextFree TContent8 +type TVariation35 = 'GElement 4 3 TRuleContent8 +type TContent5 = 'GContentTable '[ '(0, "Test0"), '(1, "Test1")] +type TRuleContent5 = 'GContextFree TContent5 +type TVariation32 = 'GElement 4 1 TRuleContent5 +type TRuleVariation32 = 'GContextFree TVariation32 +type TNonSpare55 = 'GNonSpare "I1" "" TRuleVariation32 +type TItem18 = 'GItem TNonSpare55 +type TItem5 = 'GSpare 5 2 +type TVariation49 = 'GGroup 4 '[ TItem18, TItem5] +type TRuleVariation65 = 'GDependent '[ '[ "000"], '[ "031", "CC", "TID"]] TVariation33 '[ '( '[ 1, 1], TVariation34), '( '[ 1, 2], TVariation35), '( '[ 2, 1], TVariation49)] +type TNonSpare46 = 'GNonSpare "CP" "Conflict Properties Class" TRuleVariation65 +type TItem9 = 'GItem TNonSpare46 +type TContent2 = 'GContentTable '[ '(0, "LOW"), '(1, "HIGH")] +type TRuleContent2 = 'GContextFree TContent2 +type TVariation37 = 'GElement 7 1 TRuleContent2 +type TRuleVariation35 = 'GContextFree TVariation37 +type TNonSpare47 = 'GNonSpare "CS" "Conflict Severity" TRuleVariation35 +type TItem10 = 'GItem TNonSpare47 +type TVariation47 = 'GGroup 0 '[ TItem38, TItem9, TItem10] +type TRuleVariation43 = 'GContextFree TVariation47 +type TNonSpare45 = 'GNonSpare "CC" "Conflict Classification" TRuleVariation43 +type TVariation67 = 'GCompound '[ 'Just TNonSpare53, 'Just TNonSpare45] +type TRuleVariation62 = 'GContextFree TVariation67 +type TNonSpare10 = 'GNonSpare "032" "Nested Dependent Item" TRuleVariation62 +type TUapItem10 = 'GUapItem TNonSpare10 +type TVariation6 = 'GElement 0 7 TRuleContent0 +type TRuleVariation6 = 'GContextFree TVariation6 +type TNonSpare52 = 'GNonSpare "I1" "" TRuleVariation6 +type TItem15 = 'GItem TNonSpare52 +type TItem7 = 'GSpare 7 2 +type TVariation27 = 'GElement 1 6 TRuleContent0 +type TRuleVariation27 = 'GContextFree TVariation27 +type TNonSpare63 = 'GNonSpare "I2" "" TRuleVariation27 +type TItem24 = 'GItem TNonSpare63 +type TItem8 = 'GSpare 7 9 +type TVariation40 = 'GGroup 0 '[ TItem15, TItem7, TItem24, TItem8] +type TRuleVariation38 = 'GContextFree TVariation40 +type TNonSpare12 = 'GNonSpare "040" "Spare Items" TRuleVariation38 +type TUapItem12 = 'GUapItem TNonSpare12 +type TNonSpare15 = 'GNonSpare "051" "Element" TRuleVariation7 +type TUapItem15 = 'GUapItem TNonSpare15 +type TVariation5 = 'GElement 0 6 TRuleContent0 +type TRuleVariation5 = 'GContextFree TVariation5 +type TNonSpare51 = 'GNonSpare "I1" "" TRuleVariation5 +type TItem14 = 'GItem TNonSpare51 +type TItem6 = 'GSpare 6 2 +type TNonSpare62 = 'GNonSpare "I2" "" TRuleVariation7 +type TItem23 = 'GItem TNonSpare62 +type TNonSpare67 = 'GNonSpare "I3" "" TRuleVariation4 +type TItem27 = 'GItem TNonSpare67 +type TItem4 = 'GSpare 4 8 +type TVariation36 = 'GElement 4 4 TRuleContent0 +type TRuleVariation34 = 'GContextFree TVariation36 +type TNonSpare70 = 'GNonSpare "I4" "" TRuleVariation34 +type TItem29 = 'GItem TNonSpare70 +type TVariation39 = 'GGroup 0 '[ TItem14, TItem6, TItem23, TItem27, TItem4, TItem29] +type TRuleVariation37 = 'GContextFree TVariation39 +type TNonSpare16 = 'GNonSpare "052" "Group" TRuleVariation37 +type TUapItem16 = 'GUapItem TNonSpare16 +type TVariation0 = 'GElement 0 1 TRuleContent0 +type TRuleVariation0 = 'GContextFree TVariation0 +type TNonSpare50 = 'GNonSpare "I1" "" TRuleVariation0 +type TItem13 = 'GItem TNonSpare50 +type TVariation3 = 'GElement 0 2 TRuleContent0 +type TRuleVariation3 = 'GContextFree TVariation3 +type TNonSpare66 = 'GNonSpare "I3" "" TRuleVariation3 +type TItem26 = 'GItem TNonSpare66 +type TItem1 = 'GSpare 2 1 +type TVariation31 = 'GElement 3 4 TRuleContent0 +type TRuleVariation31 = 'GContextFree TVariation31 +type TNonSpare69 = 'GNonSpare "I4" "" TRuleVariation31 +type TItem28 = 'GItem TNonSpare69 +type TNonSpare71 = 'GNonSpare "I5" "" TRuleVariation6 +type TItem30 = 'GItem TNonSpare71 +type TVariation52 = 'GExtended '[ 'Just TItem13, 'Just TItem24, 'Nothing, 'Just TItem26, 'Just TItem1, 'Just TItem28, 'Nothing, 'Just TItem30, 'Nothing] +type TRuleVariation47 = 'GContextFree TVariation52 +type TNonSpare17 = 'GNonSpare "053" "Extended With Trailing Fx" TRuleVariation47 +type TUapItem17 = 'GUapItem TNonSpare17 +type TNonSpare72 = 'GNonSpare "I5" "" TRuleVariation7 +type TItem31 = 'GItem TNonSpare72 +type TVariation53 = 'GExtended '[ 'Just TItem13, 'Just TItem24, 'Nothing, 'Just TItem26, 'Just TItem1, 'Just TItem28, 'Nothing, 'Just TItem31] +type TRuleVariation48 = 'GContextFree TVariation53 +type TNonSpare18 = 'GNonSpare "054" "Extended Without Trailing Fx" TRuleVariation48 +type TUapItem18 = 'GUapItem TNonSpare18 +type TVariation57 = 'GRepetitive ('GRepetitiveRegular 1) TVariation7 +type TRuleVariation52 = 'GContextFree TVariation57 +type TNonSpare19 = 'GNonSpare "061" "Repetitive Regular" TRuleVariation52 +type TUapItem19 = 'GUapItem TNonSpare19 +type TItem16 = 'GItem TNonSpare53 +type TVariation42 = 'GGroup 0 '[ TItem16, TItem23] +type TVariation58 = 'GRepetitive ('GRepetitiveRegular 1) TVariation42 +type TRuleVariation53 = 'GContextFree TVariation58 +type TNonSpare20 = 'GNonSpare "062" "Repetitive With Group" TRuleVariation53 +type TUapItem20 = 'GUapItem TNonSpare20 +type TVariation59 = 'GRepetitive 'GRepetitiveFx TVariation6 +type TRuleVariation54 = 'GContextFree TVariation59 +type TNonSpare21 = 'GNonSpare "063" "Repetitive Fx" TRuleVariation54 +type TUapItem21 = 'GUapItem TNonSpare21 +type TNonSpare61 = 'GNonSpare "I2" "" TRuleVariation6 +type TItem22 = 'GItem TNonSpare61 +type TVariation41 = 'GGroup 0 '[ TItem16, TItem22] +type TVariation60 = 'GRepetitive 'GRepetitiveFx TVariation41 +type TRuleVariation55 = 'GContextFree TVariation60 +type TNonSpare22 = 'GNonSpare "064" "Repetitive Fx With Group" TRuleVariation55 +type TUapItem22 = 'GUapItem TNonSpare22 +type TVariation61 = 'GExplicit 'Nothing +type TRuleVariation56 = 'GContextFree TVariation61 +type TNonSpare23 = 'GNonSpare "071" "Explicit None" TRuleVariation56 +type TUapItem23 = 'GUapItem TNonSpare23 +type TVariation62 = 'GExplicit ('Just 'GReservedExpansion) +type TRuleVariation57 = 'GContextFree TVariation62 +type TNonSpare24 = 'GNonSpare "072" "Explicit RE" TRuleVariation57 +type TUapItem24 = 'GUapItem TNonSpare24 +type TVariation63 = 'GExplicit ('Just 'GSpecialPurpose) +type TRuleVariation58 = 'GContextFree TVariation63 +type TNonSpare25 = 'GNonSpare "073" "Explicit SP" TRuleVariation58 +type TUapItem25 = 'GUapItem TNonSpare25 +type TUapItem42 = 'GUapItemSpare +type TUapItem43 = 'GUapItemRFS +type TVariation64 = 'GCompound '[ 'Just TNonSpare53] +type TRuleVariation59 = 'GContextFree TVariation64 +type TNonSpare26 = 'GNonSpare "091" "Compound With One Element" TRuleVariation59 +type TUapItem26 = 'GUapItem TNonSpare26 +type TVariation65 = 'GCompound '[ 'Just TNonSpare53, 'Nothing, 'Just TNonSpare62] +type TRuleVariation60 = 'GContextFree TVariation65 +type TNonSpare27 = 'GNonSpare "092" "Compound With Two Elements" TRuleVariation60 +type TUapItem27 = 'GUapItem TNonSpare27 +type TNonSpare68 = 'GNonSpare "I3" "" TRuleVariation7 +type TVariation66 = 'GCompound '[ 'Just TNonSpare53, 'Nothing, 'Just TNonSpare62, 'Nothing, 'Nothing, 'Nothing, 'Nothing, 'Just TNonSpare68] +type TRuleVariation61 = 'GContextFree TVariation66 +type TNonSpare28 = 'GNonSpare "093" "Compound With Three Elements" TRuleVariation61 +type TUapItem28 = 'GUapItem TNonSpare28 +type TNonSpare48 = 'GNonSpare "EP" "Element Populated Bit" TRuleVariation0 +type TItem11 = 'GItem TNonSpare48 +type TVariation26 = 'GElement 1 1 TRuleContent0 +type TRuleVariation26 = 'GContextFree TVariation26 +type TNonSpare91 = 'GNonSpare "VAL" "Value" TRuleVariation26 +type TItem40 = 'GItem TNonSpare91 +type TVariation38 = 'GGroup 0 '[ TItem11, TItem40] +type TRuleVariation36 = 'GContextFree TVariation38 +type TNonSpare85 = 'GNonSpare "SG1" "" TRuleVariation36 +type TItem35 = 'GItem TNonSpare85 +type TVariation29 = 'GElement 2 1 TRuleContent0 +type TRuleVariation29 = 'GContextFree TVariation29 +type TNonSpare49 = 'GNonSpare "EP" "Element Populated Bit" TRuleVariation29 +type TItem12 = 'GItem TNonSpare49 +type TVariation30 = 'GElement 3 1 TRuleContent0 +type TRuleVariation30 = 'GContextFree TVariation30 +type TNonSpare92 = 'GNonSpare "VAL" "Value" TRuleVariation30 +type TItem41 = 'GItem TNonSpare92 +type TVariation48 = 'GGroup 2 '[ TItem12, TItem41] +type TRuleVariation44 = 'GContextFree TVariation48 +type TNonSpare86 = 'GNonSpare "SG2" "" TRuleVariation44 +type TItem36 = 'GItem TNonSpare86 +type TItem3 = 'GSpare 4 4 +type TVariation46 = 'GGroup 0 '[ TItem35, TItem36, TItem3] +type TRuleVariation42 = 'GContextFree TVariation46 +type TNonSpare30 = 'GNonSpare "101" "Nested Groups" TRuleVariation42 +type TUapItem30 = 'GUapItem TNonSpare30 +type TItem2 = 'GSpare 4 3 +type TVariation45 = 'GGroup 0 '[ TItem35, TItem36, TItem2] +type TRuleVariation41 = 'GContextFree TVariation45 +type TNonSpare64 = 'GNonSpare "I2" "" TRuleVariation41 +type TItem25 = 'GItem TNonSpare64 +type TVariation54 = 'GExtended '[ 'Just TItem15, 'Nothing, 'Just TItem25, 'Nothing] +type TRuleVariation49 = 'GContextFree TVariation54 +type TNonSpare33 = 'GNonSpare "102" "Nested Groups Extended" TRuleVariation49 +type TUapItem33 = 'GUapItem TNonSpare33 +type TRecord9 = 'GRecord '[ TUapItem3, TUapItem0, TUapItem4, TUapItem6, TUapItem7, TUapItem10, TUapItem12, TUapItem15, TUapItem16, TUapItem17, TUapItem18, TUapItem19, TUapItem20, TUapItem21, TUapItem22, TUapItem23, TUapItem24, TUapItem25, TUapItem42, TUapItem43, TUapItem26, TUapItem27, TUapItem28, TUapItem30, TUapItem33] +type TUap3 = 'GUap TRecord9 +type TAsterix0 = 'GAsterixBasic 0 ('GEdition 1 0) TUap3 +type TExpansion1 = 'GExpansion ('Just 1) '[ 'Just TNonSpare53, 'Just TNonSpare62] +type TAsterix1 = 'GAsterixExpansion 0 ('GEdition 1 0) TExpansion1 +type TNonSpare37 = 'GNonSpare "200" "Test" TRuleVariation7 +type TUapItem37 = 'GUapItem TNonSpare37 +type TRecord10 = 'GRecord '[ TUapItem3, TUapItem0, TUapItem4, TUapItem6, TUapItem7, TUapItem10, TUapItem12, TUapItem15, TUapItem16, TUapItem17, TUapItem18, TUapItem19, TUapItem20, TUapItem21, TUapItem23, TUapItem24, TUapItem25, TUapItem42, TUapItem43, TUapItem26, TUapItem27, TUapItem28, TUapItem30, TUapItem33, TUapItem37] +type TUap4 = 'GUap TRecord10 +type TAsterix2 = 'GAsterixBasic 0 ('GEdition 1 1) TUap4 +type TExpansion2 = 'GExpansion ('Just 2) '[ 'Just TNonSpare53, 'Nothing, 'Nothing, 'Just TNonSpare62, 'Nothing, 'Nothing, 'Nothing, 'Nothing, 'Nothing, 'Nothing, 'Just TNonSpare68] +type TAsterix3 = 'GAsterixExpansion 0 ('GEdition 1 1) TExpansion2 +type TExpansion0 = 'GExpansion 'Nothing '[ 'Just TNonSpare53, 'Nothing, 'Nothing, 'Just TNonSpare62, 'Nothing, 'Nothing, 'Nothing, 'Nothing, 'Nothing, 'Nothing, 'Just TNonSpare68] +type TAsterix4 = 'GAsterixExpansion 0 ('GEdition 1 2) TExpansion0 +type TNonSpare2 = 'GNonSpare "010" "Data Source Identifier" TRuleVariation40 +type TUapItem2 = 'GUapItem TNonSpare2 +type TContent3 = 'GContentTable '[ '(0, "Plot"), '(1, "Track")] +type TRuleContent3 = 'GContextFree TContent3 +type TVariation2 = 'GElement 0 1 TRuleContent3 +type TRuleVariation2 = 'GContextFree TVariation2 +type TNonSpare90 = 'GNonSpare "TYP" "" TRuleVariation2 +type TItem39 = 'GItem TNonSpare90 +type TNonSpare54 = 'GNonSpare "I1" "" TRuleVariation27 +type TItem17 = 'GItem TNonSpare54 +type TVariation56 = 'GExtended '[ 'Just TItem39, 'Just TItem17, 'Nothing, 'Just TItem22, 'Nothing] +type TRuleVariation51 = 'GContextFree TVariation56 +type TNonSpare5 = 'GNonSpare "020" "Target Report Descriptor" TRuleVariation51 +type TUapItem5 = 'GUapItem TNonSpare5 +type TNonSpare8 = 'GNonSpare "031" "For Plots Only" TRuleVariation7 +type TUapItem8 = 'GUapItem TNonSpare8 +type TNonSpare11 = 'GNonSpare "040" "Common" TRuleVariation7 +type TUapItem11 = 'GUapItem TNonSpare11 +type TNonSpare13 = 'GNonSpare "041" "For Plots Only" TRuleVariation7 +type TUapItem13 = 'GUapItem TNonSpare13 +type TRecord7 = 'GRecord '[ TUapItem2, TUapItem5, TUapItem8, TUapItem42, TUapItem11, TUapItem13] +type TVariation15 = 'GElement 0 16 TRuleContent0 +type TRuleVariation15 = 'GContextFree TVariation15 +type TNonSpare9 = 'GNonSpare "032" "For Tracks Only" TRuleVariation15 +type TUapItem9 = 'GUapItem TNonSpare9 +type TNonSpare14 = 'GNonSpare "042" "For Tracks Only" TRuleVariation15 +type TUapItem14 = 'GUapItem TNonSpare14 +type TRecord8 = 'GRecord '[ TUapItem2, TUapItem5, TUapItem42, TUapItem9, TUapItem11, TUapItem14] +type TUap5 = 'GUaps '[ '("plot", TRecord7), '("track", TRecord8)] ('Just ('GUapSelector '[ "020", "TYP"] '[ '( 0, "plot"), '( 1, "track")])) +type TAsterix5 = 'GAsterixBasic 1 ('GEdition 1 0) TUap5 +type TNonSpare1 = 'GNonSpare "010" "" TRuleVariation7 +type TUapItem1 = 'GUapItem TNonSpare1 +type TNonSpare29 = 'GNonSpare "101" "" TRuleVariation7 +type TUapItem29 = 'GUapItem TNonSpare29 +type TNonSpare32 = 'GNonSpare "102" "" TRuleVariation7 +type TUapItem32 = 'GUapItem TNonSpare32 +type TRecord2 = 'GRecord '[ TUapItem1, TUapItem29, TUapItem32] +type TNonSpare38 = 'GNonSpare "201" "" TRuleVariation15 +type TUapItem38 = 'GUapItem TNonSpare38 +type TNonSpare39 = 'GNonSpare "202" "" TRuleVariation15 +type TUapItem39 = 'GUapItem TNonSpare39 +type TRecord5 = 'GRecord '[ TUapItem1, TUapItem38, TUapItem39] +type TVariation20 = 'GElement 0 32 TRuleContent0 +type TRuleVariation20 = 'GContextFree TVariation20 +type TNonSpare40 = 'GNonSpare "301" "" TRuleVariation20 +type TUapItem40 = 'GUapItem TNonSpare40 +type TRecord6 = 'GRecord '[ TUapItem1, TUapItem40] +type TRecord1 = 'GRecord '[ TUapItem1] +type TUap6 = 'GUaps '[ '("uap1", TRecord2), '("uap2", TRecord5), '("uap3", TRecord6), '("uap4", TRecord1)] 'Nothing +type TAsterix6 = 'GAsterixBasic 2 ('GEdition 1 0) TUap6 +type TNonSpare41 = 'GNonSpare "302" "" TRuleVariation20 +type TUapItem41 = 'GUapItem TNonSpare41 +type TRecord4 = 'GRecord '[ TUapItem1, TUapItem29, TUapItem32, TUapItem43, TUapItem38, TUapItem43, TUapItem39, TUapItem40, TUapItem43, TUapItem42, TUapItem41] +type TUap2 = 'GUap TRecord4 +type TAsterix7 = 'GAsterixBasic 3 ('GEdition 1 0) TUap2 +type TRecord3 = 'GRecord '[ TUapItem1, TUapItem29, TUapItem32, TUapItem38, TUapItem39, TUapItem40, TUapItem42, TUapItem41] +type TUap1 = 'GUap TRecord3 +type TAsterix8 = 'GAsterixBasic 4 ('GEdition 1 0) TUap1 +type TNonSpare56 = 'GNonSpare "I1" "Test" TRuleVariation6 +type TItem19 = 'GItem TNonSpare56 +type TVariation55 = 'GExtended '[ 'Just TItem19, 'Nothing] +type TRuleVariation50 = 'GContextFree TVariation55 +type TNonSpare31 = 'GNonSpare "101" "Single1" TRuleVariation50 +type TUapItem31 = 'GUapItem TNonSpare31 +type TItem0 = 'GSpare 0 4 +type TRuleVariation33 = 'GContextFree TVariation33 +type TNonSpare58 = 'GNonSpare "I1" "Test" TRuleVariation33 +type TItem20 = 'GItem TNonSpare58 +type TVariation50 = 'GExtended '[ 'Just TItem0, 'Just TItem20, 'Nothing] +type TRuleVariation45 = 'GContextFree TVariation50 +type TNonSpare34 = 'GNonSpare "102" "Single2" TRuleVariation45 +type TUapItem34 = 'GUapItem TNonSpare34 +type TNonSpare59 = 'GNonSpare "I1" "Test" TRuleVariation34 +type TItem21 = 'GItem TNonSpare59 +type TVariation51 = 'GExtended '[ 'Just TItem0, 'Just TItem21] +type TRuleVariation46 = 'GContextFree TVariation51 +type TNonSpare35 = 'GNonSpare "103" "Single3" TRuleVariation46 +type TUapItem35 = 'GUapItem TNonSpare35 +type TNonSpare57 = 'GNonSpare "I1" "Test" TRuleVariation7 +type TVariation68 = 'GCompound '[ 'Just TNonSpare57] +type TRuleVariation63 = 'GContextFree TVariation68 +type TNonSpare36 = 'GNonSpare "104" "Single4" TRuleVariation63 +type TUapItem36 = 'GUapItem TNonSpare36 +type TRecord0 = 'GRecord '[ TUapItem0, TUapItem31, TUapItem34, TUapItem35, TUapItem36] +type TUap0 = 'GUap TRecord0 +type TAsterix9 = 'GAsterixBasic 5 ('GEdition 1 0) TUap0 + +-- Toplevel aliases + +type Cat_000_1_0 = TAsterix0 +type Ref_000_1_0 = TAsterix1 +type Cat_000_1_1 = TAsterix2 +type Ref_000_1_1 = TAsterix3 +type Ref_000_1_2 = TAsterix4 +type Cat_001_1_0 = TAsterix5 +type Cat_002_1_0 = TAsterix6 +type Cat_003_1_0 = TAsterix7 +type Cat_004_1_0 = TAsterix8 +type Cat_005_1_0 = TAsterix9 + +-- Manifest + +manifest :: [GAsterix 'ValueLevel] +manifest = + [ schema @Cat_000_1_0 Proxy + , schema @Ref_000_1_0 Proxy + , schema @Cat_000_1_1 Proxy + , schema @Ref_000_1_1 Proxy + , schema @Ref_000_1_2 Proxy + , schema @Cat_001_1_0 Proxy + , schema @Cat_002_1_0 Proxy + , schema @Cat_003_1_0 Proxy + , schema @Cat_004_1_0 Proxy + , schema @Cat_005_1_0 Proxy + ] + diff --git a/test/Main.hs b/test/Main.hs new file mode 100644 --- /dev/null +++ b/test/Main.hs @@ -0,0 +1,20 @@ +module Main (main) where + +import Test.Tasty + +import qualified TestAsterix +import qualified TestBits +import qualified TestCoding +import qualified TestRawDatablock + +tests :: TestTree +tests = testGroup "Tests" + [ TestBits.tests + , TestRawDatablock.tests + , TestAsterix.tests + , TestCoding.tests + ] + +main :: IO () +main = defaultMain tests + diff --git a/test/TestAsterix.hs b/test/TestAsterix.hs new file mode 100644 --- /dev/null +++ b/test/TestAsterix.hs @@ -0,0 +1,1260 @@ +-- asterix item manipulation unit tests + +-- Remark: Keep asterix test scenarios synchronized between implementations. + +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE LambdaCase #-} + +module TestAsterix (tests) where + +import Control.Monad +import qualified Data.ByteString as BS +import Data.Either +import Data.Function ((&)) +import qualified Data.List.NonEmpty as NE +import Data.Maybe +import Test.Tasty +import Test.Tasty.HUnit + +import Asterix.Base +import Asterix.Coding + +import Common +import Generated as Gen + +tests :: TestTree +tests = testGroup "Asterix" + [ testCase "create" testCreate + , testCase "ruleVar context free" testRuleVariationContextFree + , testCase "ruleVar dependent" testRuleVariationDependent + , testCase "ruleCont context free" testRuleContentContextFree + , testCase "ruleCont dependent1" testRuleContentDependent1 + , testCase "ruleCont dependent2" testRuleContentDependent2 + , testCase "contentRaw" testContentRaw + , testCase "contentTable" testContentTable + , testCase "contentStringAscii" testContentStringAscii + , testCase "contentStringICAO" testContentStringICAO + , testCase "contentStringOctal" testContentStringOctal + , testCase "contentIntegerUnsigned" testContentIntegerUnsigned + , testCase "contentIntegerSigned" testContentIntegerSigned + , testCase "contentQuantityUnsigned" testContentQuantityUnsigned + , testCase "contentQuantitySigned" testContentQuantitySigned + , testCase "contentBdsWithAddress" testContntBdsWithAddress + , testCase "testGroup1" testGroup1 + , testCase "testGroup2" testGroup2 + , testCase "testGroup3" testGroup3 + , testCase "testExtended1" testExtended1 + , testCase "testExtended2" testExtended2 + , testCase "testExtended3" testExtended3 + , testCase "testExtended4" testExtended4 + , testCase "testExtended5" testExtended5 + , testCase "testRepetitive1" testRepetitive1 + , testCase "testRepetitive2" testRepetitive2 + , testCase "testRepetitive3" testRepetitive3 + , testCase "testExplicit0" testExplicit0 + , testCase "testExplicit1" testExplicit1 + , testCase "testExplicit2" testExplicit2 + , testCase "testExplicit3a" testExplicit3a + , testCase "testExplicit3b" testExplicit3b + , testCase "testExplicit3c" testExplicit3c + , testCase "testCompound0" testCompound0 + , testCase "testCompound1" testCompound1 + , testCase "testCompoundSet" testCompoundSet + , testCase "testCompoundDel" testCompoundDel + , testCase "testRecordEmpty" testRecordEmpty + , testCase "testRecord0RFS" testRecord0RFS + , testCase "testRecord1RFS" testRecord1RFS + , testCase "testRecordMultipleRFS" testRecordMultipleRFS + , testCase "testRecordSetItem" testRecordSetItem + , testCase "testRecordDelItem" testRecordDelItem + , testCase "testMultipleUAPS" testMultipleUAPS + , testCase "testCreateDatagram" testCreateDatagram + , testCase "testParse1" testParse1 + , testCase "testParse2" testParse2 + , testCase "testParse3" testParse3 + , testCase "testParse4" testParse4 + , testCase "testParse5" testParse5 + , testCase "testParse6" testParse6 + , testCase "testParseNonblocking" testParseNonblocking + , testCase "testEmpty" testEmpty + ] + +testCreate :: Assertion +testCreate = do + let _ = record nil :: Record (RecordOf Cat_000_1_0) + _ = record ( item @"010" 1 *: nil) :: Record (RecordOf Cat_000_1_0) + _ = record ( item @"000" 1 *: item @"010" 2 *: nil) + :: Record (RecordOf Cat_000_1_0) + -- The following line (if uncommented) shall not compile + -- _ = record ( item @"nonexistingitem" 1 : nil) :: Record (RecordOf Cat_000_1_0) + pure () + +testRuleVariationContextFree :: Assertion +testRuleVariationContextFree = do + let obj :: NonSpare (Cat_000_1_0 ~> "000") = 0x01 + checkBits "i000" obj (Hex "01") + assertUint 1 obj + +testRuleVariationDependent :: Assertion +testRuleVariationDependent = do + let obj :: Variation (DepRule (Cat_000_1_0 ~> "032" ~> "CC" ~> "CP") + '[ 1, 2]) = 4 + assertUint 4 obj + -- create complete record with that object + let rec1 :: Record (RecordOf Cat_000_1_0) + rec1 = record + ( item @"032" ( compound + ( item @"CC" ( group + ( item @"TID" 0 + *: item @"CP" (fromInteger $ asUint obj) + *: item @"CS" 0 + *: nil)) + *: nil)) + *: nil) + -- try to unparse and parse the record + bs = toByteString $ unparse @SBuilder rec1 + act = parseRecord @StrictParsing (schema @(RecordOf Cat_000_1_0) Proxy) + result = parse act bs + urec2 <- either (assertFailure . show) pure result + let rec2 :: Record (RecordOf Cat_000_1_0) = Record urec2 + i032 = fromJust $ getItem @"032" rec2 + itemCC = fromJust $ getItem @"CC" $ getVariation i032 + itemCP = getItem @"CP" $ getVariation itemCC + -- try to cast to all variation cases + let fromRight' = \case + Left (ParsingError e) -> error (show e) + Right val -> val + var0 = getVariation itemCP + var1 = fromRight' $ getDepVariation @'[ 1, 1] itemCP + var2 = fromRight' $ getDepVariation @'[ 1, 2] itemCP + var3 = fromRight' $ getDepVariation @'[ 2, 1] itemCP + assertUint 4 var0 + assertUint 4 var1 + assertUint 4 var2 + assertUint 4 var3 + assertUint 1 (getItem @"I1" var3) + assertEqual "spares" [0::Integer] (bitsToNum <$> getSpares var3) + +testRuleContentContextFree :: Assertion +testRuleContentContextFree = do + let obj :: NonSpare (Cat_000_1_0 ~> "030" ~> "IM") = 1 + assertUint 1 obj + +testRuleContentDependent1 :: Assertion +testRuleContentDependent1 = do + let obj :: NonSpare (Cat_000_1_0 ~> "030" ~> "IAS") = 1 + assertUint 1 obj + let obj1 :: NonSpare (Cat_000_1_0 ~> "030" ~> "IAS") + obj1 = quantity @"NM/s" @('Just 0) 1.2 + assertApproximately "conv1" 0.01 1.2 (asQuantity @"NM/s" @('Just 0) obj1) + let obj2 :: NonSpare (Cat_000_1_0 ~> "030" ~> "IAS") + obj2 = quantity @"Mach" @('Just 1) 0.8 + assertApproximately "conv2" 0.01 0.8 (asQuantity @"Mach" @('Just 1) obj2) + +testRuleContentDependent2 :: Assertion +testRuleContentDependent2 = do + let obj :: NonSpare (Cat_000_1_0 ~> "031") = 1 + assertUint 1 obj + let obj0 :: NonSpare (Cat_000_1_0 ~> "031") + obj0 = quantity @"unit1" @('Just 0) 12.3 + assertApproximately "obj0" 0.02 12.3 (asQuantity @"unit1" @('Just 0) obj0) + let obj1 :: NonSpare (Cat_000_1_0 ~> "031") + obj1 = quantity @"unit2" @('Just 1) 13.4 + assertApproximately "obj1" 0.01 13.4 (asQuantity @"unit2" @('Just 1) obj1) + let obj2 :: NonSpare (Cat_000_1_0 ~> "031") + obj2 = quantity @"unit3" @('Just 2) 10.0 + assertApproximately "obj2" 0.01 10.0 (asQuantity @"unit3" @('Just 2) obj2) + +testContentRaw :: Assertion +testContentRaw = do + let obj :: NonSpare (Cat_000_1_0 ~> "010" ~> "SAC") = 0x01 + assertUnparse "01" obj + assertUint 1 obj + +testContentTable :: Assertion +testContentTable = do + let obj :: NonSpare (Cat_000_1_0 ~> "000") = 0x01 + assertUnparse "01" obj + assertUint 1 obj + +testContentStringAscii :: Assertion +testContentStringAscii = do + let obj1 :: NonSpare (Cat_000_1_0 ~> "020" ~> "S1") = 0x01 + assertUnparse "00000000000001" obj1 + assertUint 1 obj1 + let sample = "test" + obj2 :: NonSpare (Cat_000_1_0 ~> "020" ~> "S1") = string sample + assertUnparse "74657374202020" obj2 + assertUint 0x74657374202020 obj2 + assertEqual "string" sample (rStrip $ asString obj2) + +testContentStringICAO :: Assertion +testContentStringICAO = do + let obj1 :: NonSpare (Cat_000_1_0 ~> "020" ~> "S2") = 0x01 + assertUint 1 obj1 + assertUnparse "000000000001" obj1 + let sample = "S5LJ" + obj2 :: NonSpare (Cat_000_1_0 ~> "020" ~> "S2") = string sample + assertUnparse "4F530A820820" obj2 + assertUint 0x4F530A820820 obj2 + assertEqual "string" sample (rStrip $ asString obj2) + +testContentStringOctal :: Assertion +testContentStringOctal = do + let obj1 :: NonSpare (Cat_000_1_0 ~> "020" ~> "S3") = 0x01 + assertUnparse "000001" obj1 + assertUint 1 obj1 + let sample = "1234" + obj2 :: NonSpare (Cat_000_1_0 ~> "020" ~> "S3") = string sample + assertUnparse "29C000" obj2 + assertUint 0x29C000 obj2 + assertEqual "string" (sample <> "0000") (asString obj2) + +testContentIntegerUnsigned :: Assertion +testContentIntegerUnsigned = do + let obj1 :: NonSpare (Cat_000_1_0 ~> "020" ~> "I1") = 0x01 + assertUnparse "01" obj1 + assertUint 1 obj1 + let obj2 :: NonSpare (Cat_000_1_0 ~> "020" ~> "I1") = -1 + assertUnparse "FF" obj2 + assertUint 255 obj2 + assertEqual "integer" (255::Integer) (asInteger obj2) + +testContentIntegerSigned :: Assertion +testContentIntegerSigned = do + let obj1 :: NonSpare (Cat_000_1_0 ~> "020" ~> "I2") = 0x01 + assertUnparse "01" obj1 + let obj2 :: NonSpare (Cat_000_1_0 ~> "020" ~> "I2") = -1 + assertUnparse "FF" obj2 + assertUint 0xff obj2 + assertEqual "integer" ((-1)::Integer) (asInteger obj2) + +testContentQuantityUnsigned :: Assertion +testContentQuantityUnsigned = do + let obj1 :: NonSpare (Cat_000_1_0 ~> "020" ~> "Q3") = 0x01 + assertUnparse "0001" obj1 + let sample = 123.4 + obj2 :: NonSpare (Cat_000_1_0 ~> "020" ~> "Q3") = quantity sample + assertUint 0x007B obj2 + assertUnparse "007B" obj2 + let obj3 :: NonSpare (Cat_000_1_0 ~> "020" ~> "Q3") = quantity @"kt" sample + assertUnparse "007B" obj3 + assertEqual "conv1" + ((round $ unQuantity sample) :: Integer) + (round $ unQuantity $ asQuantity obj3) + assertEqual "conv1" + ((round $ unQuantity sample) :: Integer) + (round $ unQuantity $ asQuantity @"kt" obj3) + +testContentQuantitySigned :: Assertion +testContentQuantitySigned = do + let obj1 :: NonSpare (Cat_000_1_0 ~> "020" ~> "Q2LON") = 0x01 + one = asQuantity obj1 + assertUnparse "000001" obj1 + let sample = 123.4 + obj2 :: NonSpare (Cat_000_1_0 ~> "020" ~> "Q2LON") = quantity sample + assertEqual "conv1" + (round (unQuantity sample / (180 / (2 ^ (23::Int))))) + (asUint @Integer obj2) + let obj3 :: NonSpare (Cat_000_1_0 ~> "020" ~> "Q2LON") = quantity @"°" sample + assertEqual "conv1" + (round (unQuantity sample / (180 / (2 ^ (23::Int))))) + (asUint @Integer obj3) + assertEqual "conv2" + ((round $ unQuantity sample) :: Integer) + (round $ unQuantity $ asQuantity obj3) + assertEqual "conv2" + ((round $ unQuantity sample) :: Integer) + (round $ unQuantity $ asQuantity @"°" obj3) + let obj4 :: NonSpare (Cat_000_1_0 ~> "020" ~> "Q2LON") = 0xffffff + assertUnparse "ffffff" obj4 + assertEqual "compare1" LT (compare (asQuantity obj4) 0) + assertEqual "compare2" EQ (compare (asQuantity obj4) (-one)) + +testContntBdsWithAddress :: Assertion +testContntBdsWithAddress = do + let obj :: NonSpare (Cat_000_1_0 ~> "020" ~> "B1") = 0x01 + assertUnparse "0000000000000001" obj + assertUint 0x01 obj + +testGroup1 :: Assertion +testGroup1 = do + let obj1 :: NonSpare (Cat_000_1_0 ~> "010") = 0x0102 + assertUnparse "0102" obj1 + assertUint 0x0102 obj1 + let obj2 :: NonSpare (Cat_000_1_0 ~> "010") = group ( 0x01 *: 0x02 *: nil) + assertUnparse "0102" obj2 + assertUint 0x0102 obj2 + let obj3 :: NonSpare (Cat_000_1_0 ~> "010") = group + ( item @"SAC" 0x01 + *: 0x02 + *: nil) + assertUnparse "0102" obj3 + assertUint 0x0102 obj3 + let obj4 :: NonSpare (Cat_000_1_0 ~> "010") = group + ( item @"SAC" 0x01 + *: item @"SIC" 0x02 + *: nil) + assertUnparse "0102" obj4 + assertUint 0x0102 obj4 + assertUint 0x01 (getItem @"SAC" obj4) + assertUint 0x02 (getItem @"SIC" obj4) + assertEqual "spares" [] (getSpares obj4) + +testGroup2 :: Assertion +testGroup2 = do + let obj :: NonSpare (Cat_000_1_0 ~> "040") = group + ( 1 *: 2 *: item @"I2" 3 *: 4 *: nil) + assertUnparse "030604" obj + assertUint 1 (getItem @"I1" obj) + assertUint 3 (getItem @"I2" obj) + assertEqual "spares" [2::Integer, 4] (bitsToNum <$> getSpares obj) + +testGroup3 :: Assertion +testGroup3 = do + let obj :: NonSpare (Cat_000_1_0 ~> "101") = 0x12 + assertUnparse "12" obj + +testExtended1 :: Assertion +testExtended1 = do + let act = parseNonSpare (schema @(RecordOf Cat_000_1_0 ~> "053") Proxy) + bs = fromJust $ unhexlify "80" + env = Env parsingStore bs + result = runParsing act env 0 + (_obj, o) <- either (assertFailure . show) pure result + assertEqual "leftover" True (o == endOffset bs) + let obj2 :: NonSpare (Cat_000_1_0 ~> "053") = extended + ( 1 *: item @"I2" 2 *: fx *: nil) + assertUnparse "84" obj2 + let var = getVariation obj2 + assertUint 1 (fromJust $ getItem @"I1" var) + assertUint 2 (fromJust $ getItem @"I2" var) + assertEqual "I3" True (isNothing $ getItem @"I3" var) + assertEqual "I4" True (isNothing $ getItem @"I4" var) + assertEqual "I5" True (isNothing $ getItem @"I5" var) + assertEqual "spares" [] (getExtendedSpares var) + + let obj2a :: NonSpare (Cat_000_1_0 ~> "053") = extendedGroups + ( 0x42 *: nil) -- 0x42 = div 0x84 2, but we use Num instance + assertEqual "unparse" (unparse @Bits obj2) (unparse @Bits obj2a) + + let obj3 :: NonSpare (Cat_000_1_0 ~> "053") = extendedGroups + ( group (item @"I1" 1 *: item @"I2" 2 *: nil) *: nil) + assertEqual "unparse" (unparse @Bits obj2) (unparse @Bits obj3) + assertEqual "spares" [] (getExtendedSpares $ getVariation obj3) + + let obj4 :: NonSpare (Cat_000_1_0 ~> "053") = extendedGroups + ( group (1 *: 2 *: nil) + *: group (1 *: 0 *: 2 *: nil) + *: nil ) + assertUnparse "8544" obj4 + assertEqual "spares" [0::Integer] + (fmap bitsToNum $ getExtendedSpares $ getVariation obj4) + + let obj5 :: NonSpare (Cat_000_1_0 ~> "053") = extendedGroups + (1 *: 2 *: nil) + assertUnparse "0304" obj5 + + let obj6 :: NonSpare (Cat_000_1_0 ~> "053") = extendedGroups + (1 *: 2 *: 3 *: nil) + assertUnparse "030506" obj6 + let obj6a :: NonSpare (Cat_000_1_0 ~> "053") = extendedGroups + (1 *: 2 *: group (3 *: nil) *: nil) + var6 = getVariation obj6 + assertEqual "unparse" (unparse @Bits obj6) (unparse @Bits obj6a) + assertEqual "I3" True (isJust $ getItem @"I3" var6) + assertEqual "I4" True (isJust $ getItem @"I4" var6) + assertEqual "I5" True (isJust $ getItem @"I5" var6) + +testExtended2 :: Assertion +testExtended2 = do + let act = parseNonSpare (schema @(RecordOf Cat_000_1_0 ~> "054") Proxy) + bs = fromJust $ unhexlify "80" + env = Env parsingStore bs + result = runParsing act env 0 + (_obj, o) <- either (assertFailure . show) pure result + assertEqual "leftover" True (o == endOffset bs) + let obj2 :: NonSpare (Cat_000_1_0 ~> "054") = extended + ( 1 *: item @"I2" 2 *: fx *: nil) + assertUnparse "84" obj2 + let obj2a :: NonSpare (Cat_000_1_0 ~> "054") = extendedGroups + ( 0x42 *: nil) -- 0x42 = div 0x84 2, but we use Num instance + assertEqual "unparse" (unparse @Bits obj2) (unparse @Bits obj2a) + let obj3 :: NonSpare (Cat_000_1_0 ~> "054") = extendedGroups + ( group (item @"I1" 1 *: 2 *: nil) + *: nil) + assertEqual "unparse" (unparse @Bits obj2) (unparse @Bits obj3) + let obj4 :: NonSpare (Cat_000_1_0 ~> "054") = extendedGroups + ( group (1 *: 2 *: nil) + *: group (1 *: 0 *: 2 *: nil) + *: nil) + assertUnparse "8544" obj4 + let obj5 :: NonSpare (Cat_000_1_0 ~> "054") = extendedGroups + ( 1 *: 2 *: nil) + assertUnparse "0304" obj5 + let obj6 :: NonSpare (Cat_000_1_0 ~> "054") = extendedGroups + ( 1 *: 2 *: 3 *: nil) + assertUnparse "030503" obj6 + let obj7 :: NonSpare (Cat_000_1_0 ~> "054") = extendedGroups + ( group (1 *: 2 *: nil) + *: group (3 *: 0 *: 4 *: nil) + *: group (5 *: nil) + *: nil) + s7 = toByteString $ bitsToSBuilder $ unparse @Bits obj7 + act8 = parseNonSpare (schema @(RecordOf Cat_000_1_0 ~> "054") Proxy) + res8 = parse @StrictParsing act8 s7 + uobj8 <- either (assertFailure . show) pure res8 + let obj8 :: NonSpare (Cat_000_1_0 ~> "054") = NonSpare uobj8 + var8 = getVariation obj8 + assertUint 1 (fromJust $ getItem @"I1" var8) + assertUint 2 (fromJust $ getItem @"I2" var8) + assertUint 3 (fromJust $ getItem @"I3" var8) + assertUint 4 (fromJust $ getItem @"I4" var8) + assertUint 5 (fromJust $ getItem @"I5" var8) + +testExtended3 :: Assertion +testExtended3 = do + do + let obj :: NonSpare (Cat_000_1_0 ~> "102") = extendedGroups + ( 1 *: 2 *: nil) + assertUnparse "0304" obj + do + let obj :: NonSpare (Cat_000_1_0 ~> "102") = extendedGroups + ( group (1 *: nil) + *: group (2 *: nil) + *: nil ) + assertUnparse "0304" obj + do + let obj :: NonSpare (Cat_000_1_0 ~> "102") = extendedGroups + ( group (1 *: nil) + *: group ( group (0 *: 0 *: 2 *: nil) *: nil) + *: nil ) + assertUnparse "0304" obj + do + let obj :: NonSpare (Cat_000_1_0 ~> "102") = extendedGroups + ( group (1 *: nil) + *: group ( group (item @"SG1" 0 *: 0 *: 2 *: nil) *: nil) + *: nil ) + assertUnparse "0304" obj + +testExtended4 :: Assertion +testExtended4 = do + -- Create extended sample with last FX bit set to '1' (wrong). + -- Parsing shall fail in this case. + let act = parseNonSpare (schema @(RecordOf Cat_000_1_0 ~> "053") Proxy) + bs = fromJust $ unhexlify "010101" + env = Env parsingStore bs + result = runParsing act env 0 + assertEqual "failure" True (isLeft result) + +testExtended5 :: Assertion +testExtended5 = do + -- check modifyExtendedSubitemIfPresent function + let o1, o2, o3 :: NonSpare (Cat_000_1_0 ~> "053") + o1 = extended ( 1 *: item @"I2" 2 *: fx *: nil) + o2 = extended ( 1 *: item @"I2" 5 *: fx *: nil) + o3 = modifyExtendedSubitemIfPresent @"I2" (const 2) o2 -- present + o4 = modifyExtendedSubitemIfPresent @"I3" (const 0) o1 -- not present + o5 = modifyExtendedSubitemIfPresent @"I5" (const 0) o1 -- not present + assertEqual "failure o3" (unparse @Bits o1) (unparse o3) + assertEqual "failure o4" (unparse @Bits o1) (unparse o4) + assertEqual "failure o5" (unparse @Bits o1) (unparse o5) + let o6, o7, o8 :: NonSpare (Cat_000_1_0 ~> "053") + o6 = extended ( 1 *: 2 *: fx *: item @"I3" 3 *: spare *: 4 *: fx *: nil) + o7 = extended ( 1 *: 2 *: fx *: item @"I3" 0 *: spare *: 4 *: fx *: nil) + o8 = modifyExtendedSubitemIfPresent @"I3" (const 3) o7 -- present + assertEqual "failure o8" (unparse @Bits o6) (unparse o8) + +testRepetitive1 :: Assertion +testRepetitive1 = do + let obj :: NonSpare (RecordOf Cat_000_1_0 ~> "061") = repetitive [1,2,3] + assertUnparse "03010203" obj + let lst = getRepetitiveItems $ getVariation obj + assertEqual "val" [1, 2, 3] $ fmap (asUint @Int) lst + +testRepetitive2 :: Assertion +testRepetitive2 = do + let obj :: NonSpare (RecordOf Cat_000_1_0 ~> "062") = repetitive + [ 1 + , group (item @"I1" 2 *: 3 *: nil) + , 4 + ] + assertUnparse "03000102030004" obj + let lst = getRepetitiveItems $ getVariation obj + assertEqual "val" [1, 0x0203, 4] $ fmap (asUint @Int) lst + +testRepetitive3 :: Assertion +testRepetitive3 = do + let obj :: NonSpare (RecordOf Cat_000_1_0 ~> "063") = repetitive (1 NE.:| [2, 3]) + assertUnparse "030506" obj + let lst = getRepetitiveItems $ getVariation obj + assertEqual "val" [1, 2, 3] $ fmap (asUint @Int) lst + +testExplicit0 :: Assertion +testExplicit0 = do + let bs = fromJust $ unhexlify "00" + act = parseNonSpare (schema @(RecordOf Cat_000_1_0 ~> "071") Proxy) + result = parse @StrictParsing act bs + assertEqual "result" True (isLeft result) + +testExplicit1 :: Assertion +testExplicit1 = do + let obj :: NonSpare (RecordOf Cat_000_1_0 ~> "071") + obj = explicit $ fromJust $ unhexlify "010203" + assertUnparse "04010203" obj + assertEqual "data" + (byteStringToBits (fromJust $ unhexlify "010203")) + (getExplicitData $ getVariation obj) + +testExplicit2 :: Assertion +testExplicit2 = do + let obj :: Expansion (ExpansionOf Ref_000_1_0) + obj = expansion + ( item @"I1" 1 + *: item @"I2" 2 + *: nil ) + bs = toByteString $ unparse @SBuilder obj + act = parseExpansion (schema @(ExpansionOf Ref_000_1_0) Proxy) + result = parse @StrictParsing act bs + uobj2 <- either (assertFailure . show) pure result + let obj2 :: Expansion (ExpansionOf Ref_000_1_0) = Expansion uobj2 + i1 = fromJust $ getItem @"I1" obj2 + i2 = fromJust $ getItem @"I2" obj2 + assertUint 1 i1 + assertUint 2 i2 + +testExplicit3a :: Assertion +testExplicit3a = do + let re :: Expansion (ExpansionOf Ref_000_1_1) -- without FX + re = expansion + ( item @"I1" 1 + *: item @"I2" 2 + *: item @"I3" 3 + *: nil ) + r :: Record (RecordOf Cat_000_1_0) + r = record + ( item @"010" 0x0102 + *: item @"072" (explicit re) + *: nil ) + let act = parseRecord (schema @(RecordOf Cat_000_1_0) Proxy) + bs = toByteString $ unparse @SBuilder r + result = parse @StrictParsing act bs + ur2 <- either (assertFailure . show) pure result + let r2 :: Record (RecordOf Cat_000_1_0) = Record ur2 + i072 = fromJust $ getItem @"072" r2 + s = getExplicitData $ getVariation i072 + assertUnparse "9020010203" s + let act3 = parseExpansion (schema @(ExpansionOf Ref_000_1_1) Proxy) + bs3 = toByteString $ bitsToBuilder s + result3 = parse @StrictParsing act3 bs3 + uobj3 <- either (assertFailure . show) pure result3 + let obj3 :: Expansion (ExpansionOf Ref_000_1_1) = Expansion uobj3 + i1 = fromJust $ getItem @"I1" obj3 + i2 = fromJust $ getItem @"I2" obj3 + i3 = fromJust $ getItem @"I3" obj3 + assertUint 1 i1 + assertUint 2 i2 + assertUint 3 i3 + +testExplicit3b :: Assertion +testExplicit3b = do + let re :: Expansion (ExpansionOf Ref_000_1_2) -- with FX + re = expansion + ( item @"I1" 1 + *: item @"I2" 2 + *: item @"I3" 3 + *: nil ) + r :: Record (RecordOf Cat_000_1_0) + r = record + ( item @"010" 0x0102 + *: item @"072" (explicit re) + *: nil ) + let act = parseRecord (schema @(RecordOf Cat_000_1_0) Proxy) + bs = toByteString $ unparse @SBuilder r + result = parse @StrictParsing act bs + ur2 <- either (assertFailure . show) pure result + let r2 :: Record (RecordOf Cat_000_1_0) = Record ur2 + i072 = fromJust $ getItem @"072" r2 + s = getExplicitData $ getVariation i072 + assertUnparse "9110010203" s + let act3 = parseExpansion (schema @(ExpansionOf Ref_000_1_2) Proxy) + bs3 = toByteString $ bitsToBuilder s + result3 = parse @StrictParsing act3 bs3 + uobj3 <- either (assertFailure . show) pure result3 + let obj3 :: Expansion (ExpansionOf Ref_000_1_2) = Expansion uobj3 + i1 = fromJust $ getItem @"I1" obj3 + i2 = fromJust $ getItem @"I2" obj3 + i3 = fromJust $ getItem @"I3" obj3 + assertUint 1 i1 + assertUint 2 i2 + assertUint 3 i3 + +testExplicit3c :: Assertion +testExplicit3c = do + let re :: Expansion (ExpansionOf Ref_000_1_2) -- with FX + re = expansion + ( item @"I1" 1 + *: item @"I2" 2 + *: nil ) + r :: Record (RecordOf Cat_000_1_0) + r = record + ( item @"010" 0x0102 + *: item @"072" (explicit re) + *: nil ) + let act = parseRecord (schema @(RecordOf Cat_000_1_0) Proxy) + bs = toByteString $ unparse @SBuilder r + result = parse @StrictParsing act bs + ur2 <- either (assertFailure . show) pure result + let r2 :: Record (RecordOf Cat_000_1_0) = Record ur2 + i072 = fromJust $ getItem @"072" r2 + s = getExplicitData $ getVariation i072 + assertUnparse "900102" s + let act3 = parseExpansion (schema @(ExpansionOf Ref_000_1_2) Proxy) + bs3 = toByteString $ bitsToBuilder s + result3 = parse @StrictParsing act3 bs3 + uobj3 <- either (assertFailure . show) pure result3 + let obj3 :: Expansion (ExpansionOf Ref_000_1_2) = Expansion uobj3 + i1 = fromJust $ getItem @"I1" obj3 + i2 = fromJust $ getItem @"I2" obj3 + i3 = getItem @"I3" obj3 + assertUint 1 i1 + assertUint 2 i2 + assertEqual "i3" True (isNothing i3) + +testCompound0 :: Assertion +testCompound0 = do + let bs = fromJust $ unhexlify "0100" + act = parseNonSpare (schema @(RecordOf Cat_000_1_0 ~> "091") Proxy) + result = parse @StrictParsing act bs + assertEqual "result" True (isLeft result) + +testCompound1 :: Assertion +testCompound1 = do + let obj :: NonSpare (RecordOf Cat_000_1_0 ~> "093") + -- The following line (if uncommented) shall not compile + -- obj = compound (item @"nonexistingitem" 1 *: nil) + obj = compound nil + assertUnparse "00" obj + let obj1 :: NonSpare (RecordOf Cat_000_1_0 ~> "093") + obj1 = compound + ( item @"I1" 1 + -- The following line (if uncommented) shall not compile + -- *: item @"I1" 2 + *: nil ) + assertEqual "I1" True (isJust $ getItem @"I1" $ getVariation obj1) + assertEqual "I2" True (isNothing $ getItem @"I2" $ getVariation obj1) + assertEqual "I3" True (isNothing $ getItem @"I3" $ getVariation obj1) + assertUnparse "8001" obj1 + let obj12 :: NonSpare (RecordOf Cat_000_1_0 ~> "093") + obj12 = compound + ( item @"I1" 1 + *: item @"I2" 2 + *: nil ) + assertEqual "I1" True (isJust $ getItem @"I1" $ getVariation obj12) + assertEqual "I2" True (isJust $ getItem @"I2" $ getVariation obj12) + assertEqual "I3" True (isNothing $ getItem @"I3" $ getVariation obj12) + assertUnparse "A00102" obj12 + let obj13 :: NonSpare (RecordOf Cat_000_1_0 ~> "093") + obj13 = compound + ( item @"I1" 1 + *: item @"I3" 3 + *: nil ) + assertEqual "I1" True (isJust $ getItem @"I1" $ getVariation obj13) + assertEqual "I2" True (isNothing $ getItem @"I2" $ getVariation obj13) + assertEqual "I3" True (isJust $ getItem @"I3" $ getVariation obj13) + assertUnparse "81800103" obj13 + let obj123 :: NonSpare (RecordOf Cat_000_1_0 ~> "093") + obj123 = compound + ( item @"I1" 1 + *: item @"I2" 2 + *: item @"I3" 3 + *: nil ) + assertEqual "I1" True (isJust $ getItem @"I1" $ getVariation obj123) + assertEqual "I2" True (isJust $ getItem @"I2" $ getVariation obj123) + assertEqual "I3" True (isJust $ getItem @"I3" $ getVariation obj123) + assertUnparse "A180010203" obj123 + -- order shall make no difference + let t2, t3, t4, t5, t6 :: NonSpare (RecordOf Cat_000_1_0 ~> "093") + t2 = compound ( item @"I1" 1 *: item @"I3" 3 *: item @"I2" 2 *: nil ) + t3 = compound ( item @"I2" 2 *: item @"I1" 1 *: item @"I3" 3 *: nil ) + t4 = compound ( item @"I2" 2 *: item @"I3" 3 *: item @"I1" 1 *: nil ) + t5 = compound ( item @"I3" 3 *: item @"I1" 1 *: item @"I2" 2 *: nil ) + t6 = compound ( item @"I3" 3 *: item @"I2" 2 *: item @"I1" 1 *: nil ) + assertEqual "t2" (unparse @Bits obj123) (unparse t2) + assertEqual "t3" (unparse @Bits obj123) (unparse t3) + assertEqual "t4" (unparse @Bits obj123) (unparse t4) + assertEqual "t5" (unparse @Bits obj123) (unparse t5) + assertEqual "t6" (unparse @Bits obj123) (unparse t6) + +testCompoundSet :: Assertion +testCompoundSet = do + let obj1, obj2, obj2a, obj2b :: NonSpare (RecordOf Cat_000_1_0 ~> "093") + obj1 = compound ( item @"I1" 1 *: nil ) + obj2 = compound ( item @"I1" 1 *: item @"I2" 2 *: nil ) + obj2a = compound nil & setItem @"I1" 1 & setItem @"I2" 2 + obj2b = compound nil & setItem @"I1" 1 & maybeSetItem @"I2" (Just 2) + var1 = getVariation obj1 + var2Ref = getVariation obj2 + var2 = setItem @"I2" 2 var1 + assertEqual "setItemA" (unparse @Bits obj2) (unparse obj2a) + assertEqual "setItemB" (unparse @Bits obj2) (unparse obj2b) + assertEqual "setItem" (unparse @Bits var2Ref) (unparse var2) + +testCompoundDel :: Assertion +testCompoundDel = do + let obj123, obj13 :: NonSpare (RecordOf Cat_000_1_0 ~> "093") + obj123 = compound ( item @"I1" 1 *: item @"I2" 2 *: item @"I3" 3 *: nil ) + obj13 = compound ( item @"I1" 1 *: item @"I3" 3 *: nil ) + varRef = getVariation obj13 + var = delItem @"I2" (getVariation obj123) + assertEqual "delItem" (unparse @Bits varRef) (unparse var) + +testRecordEmpty :: Assertion +testRecordEmpty = do + let bs = fromJust $ unhexlify "0101010100" + env = Env parsingStore bs + actStrict = parseRecord @StrictParsing (schema @(RecordOf Cat_000_1_0) Proxy) + actPartial = parseRecord @PartialParsing (schema @(RecordOf Cat_000_1_0) Proxy) + assertEqual "strict" True $ isLeft $ runParsing actStrict env 0 + assertEqual "partial" True $ isRight $ runParsing actPartial env 0 + +testRecord0RFS :: Assertion +testRecord0RFS = do + let r0 :: Record (RecordOf Cat_004_1_0) = record nil + assertUnparse "00" r0 + assertEqual "item 010" True (isNothing $ getItem @"010" r0) + + let r1 :: Record (RecordOf Cat_004_1_0) = record + ( item @"010" 0x03 + *: nil ) + assertUnparse "8003" r1 + let i010 = fromJust $ getItem @"010" r1 + assertUint 0x03 i010 + + -- The following line (if uncommented) shall not compile + -- void $ pure (record (rfs @0 nil *: nil) :: (Record (RecordOf Cat_004_1_0))) + +testRecord1RFS :: Assertion +testRecord1RFS = do + let r0 :: Record (RecordOf Cat_000_1_0) = record nil + assertUnparse "00" r0 + assertEqual "item 000" True (isNothing $ getItem @"000" r0) + + let r1 :: Record (RecordOf Cat_000_1_0) = record + ( item @"000" 0x03 + *: nil ) + assertUnparse "4003" r1 + let i0 = fromJust $ getItem @"000" r1 + assertUint 0x03 i0 + + let r2a :: Record (RecordOf Cat_000_1_0) = record + ( item @"010" (group (item @"SAC" 0x01 *: item @"SIC" 0x02 *: nil)) + *: item @"000" 0x03 + *: nil ) + assertEqual "000" True (isJust $ getItem @"000" r2a) + let r2a010 = fromJust $ getItem @"010" r2a + assertUint 0x01 (getItem @"SAC" $ getVariation r2a010) + assertUint 0x02 (getItem @"SIC" $ getVariation r2a010) + + let r2b :: Record (RecordOf Cat_000_1_0) = record + ( item @"010" (group (item @"SAC" 0x01 *: 0x02 *: nil)) + *: item @"000" 0x03 + *: nil ) + r2c :: Record (RecordOf Cat_000_1_0) = record + ( item @"010" 0x0102 + *: item @"000" 0x03 + *: nil ) + forM_ [r2a, r2b, r2c] $ \r -> do + assertUnparse "C0010203" r + + let r3 :: Record (RecordOf Cat_000_1_0) = record + ( item @"032" (compound + ( item @"I1" 0x11 + *: item @"CC" (group + ( item @"TID" 5 + *: item @"CP" 3 + *: item @"CS" 1 + *: nil )) + *: nil )) + *: nil ) + assertUnparse "04C01157" r3 + + let withRfs :: Record (RecordOf Cat_000_1_0) = record + ( item @"000" 0x03 + *: rfs -- or rfs @0, to be explicit which rfs, but there is only one + ( item @"000" 0xAA + *: item @"000" 0x55 + *: item @"010" 0x1234 + *: item @"053" (extendedGroups (1 *: 2 *: nil)) + *: item @"054" (extendedGroups (1 *: 2 *: nil)) + *: item @"061" (repetitive [0xFF]) + *: nil ) + *: nil ) + bs = "410104030602AA02550112340A03040B03040C01FF" + bs' = fromJust $ unhexlify bs + assertUnparse bs withRfs + + let _i000 = fromJust $ getItem @"000" withRfs + assertEqual "010" True (isNothing $ getItem @"010" withRfs) + + assertEqual "rfs 000" [0xAA, 0x55] + (asUint @Integer <$> getRfsItem @"000" withRfs) + assertEqual "rfs 010" [0x1234] + (asUint @Integer <$> getRfsItem @"010" withRfs) + assertEqual "rfs 020" 0 (length $ getRfsItem @"020" withRfs) + assertEqual "rfs 053" 1 (length $ getRfsItem @"053" withRfs) + + -- Check parsing (with RFS) + let act = parseRecord (schema @(RecordOf Cat_000_1_0) Proxy) + result = parse @StrictParsing act bs' + withRfs2 <- either (assertFailure . show) pure result + assertUnparse bs withRfs2 + +testRecordMultipleRFS :: Assertion +testRecordMultipleRFS = do + let check r expected = do + assertUnparse expected r + let act = parseRecord (schema @(RecordOf Cat_003_1_0) Proxy) + bs = fromJust $ unhexlify expected + result = parse @StrictParsing act bs + readback <- either (assertFailure . show) pure result + assertEqual "readback" (toBits bs) (unparse readback) + r0 :: Record (RecordOf Cat_003_1_0) = record + ( item @"010" 0x01 + *: nil ) + r1 :: Record (RecordOf Cat_003_1_0) = record + ( item @"010" 0x01 + *: rfs @0 + ( item @"101" 0xAA + *: item @"102" 0x55 + *: nil ) + *: nil ) + r2 :: Record (RecordOf Cat_003_1_0) = record + ( item @"010" 0x01 + *: rfs @0 + ( item @"101" 0xAA + *: item @"102" 0x55 + *: nil ) + *: rfs @1 + ( item @"201" 0xF1 + *: item @"202" 0xF2 + *: nil ) + *: nil ) + r3 :: Record (RecordOf Cat_003_1_0) = record + ( item @"010" 0x01 + -- *: rfs @0 ... not specified + *: rfs @1 + ( item @"201" 0xF1 + *: item @"202" 0xF2 + *: nil ) + *: nil ) + r4 :: Record (RecordOf Cat_003_1_0) = record + ( item @"010" 0x01 + *: rfs @0 nil -- specified, but empty + -- The following line (if uncommented) shall not compile + -- *: rfs @0 nil + *: rfs @1 + ( item @"201" 0xF1 + *: item @"202" 0xF2 + *: nil ) + *: nil ) + check r0 "8001" + check r1 "90010202aa0355" + check r2 "94010202aa0355020500f10700f2" + check r3 "8401020500f10700f2" + check r4 "940100020500f10700f2" + +testRecordSetItem :: Assertion +testRecordSetItem = do + let r0, r1, r2 :: Record (RecordOf Cat_000_1_0) + r0 = setItem @"000" 0x03 (record nil) + r1 = record (item @"000" 0x03 *: nil) + r2 = record nil & maybeSetItem @"000" (Just 0x03) + assertEqual "unparse" (unparse @Bits r0) (unparse r1) + assertEqual "unparse" (unparse @Bits r0) (unparse r2) + +testRecordDelItem :: Assertion +testRecordDelItem = do + let r0, r1 :: Record (RecordOf Cat_000_1_0) + r0 = delItem @"010" (record + ( item @"010" ( group + ( item @"SAC" 0x01 *: 0x02 *: nil)) + *: item @"000" 0x03 + *: nil )) + r1 = record (item @"000" 0x03 *: nil) + assertEqual "unparse" (unparse @Bits r0) (unparse r1) + +testMultipleUAPS :: Assertion +testMultipleUAPS = do + let recPlot :: Record (RecordOfUap Cat_001_1_0 "plot") = record + ( item @"010" 1 + *: item @"020" (extended + ( item @"TYP" 0 *: item @"I1" 1 *: fx *: nil)) + *: item @"031" 0x03 + *: nil ) + assertUnparse "E000010203" recPlot + + let recTrack :: Record (RecordOfUap Cat_001_1_0 "track") = record + ( item @"010" 1 + *: item @"020" (extended + ( item @"TYP" 1 *: item @"I1" 2 *: fx *: nil)) + *: item @"032" 0x04 + *: nil ) + assertUnparse "D00001840004" recTrack + +testCreateDatagram :: Assertion +testCreateDatagram = do + let db0 :: Datablock (DatablockOf Cat_000_1_0) = datablock + ( record ( item @"010" 1 *: nil) + *: record ( item @"010" 2 *: nil) + *: nil ) + db1 :: Datablock (DatablockOf Cat_001_1_0) = datablock + ( (record ( item @"010" 1 *: nil) :: Record (RecordOfUap Cat_001_1_0 "plot")) + *: (record ( item @"010" 2 *: nil) :: Record (RecordOfUap Cat_001_1_0 "track")) + *: nil ) + datagram :: SBuilder = unparse db0 <> unparse db1 + assertEqual "unparse" + (fromJust $ unhexlify "000009800001800002010009800001800002") + (toByteString datagram) + +testParse1 :: Assertion +testParse1 = forM_ samples $ \sample -> do + let act = parseRecord (schema @(RecordOf Cat_000_1_0) Proxy) + bs = fromJust $ unhexlify sample + env = Env @StrictParsing parsingStore bs + result = runParsing act env 0 + (r, o) <- either (assertFailure . show) pure result + assertEqual "leftover" True (o == endOffset bs) + assertEqual "readback" (hexlify bs) + (hexlify $ builderToByteStringSlow $ sbData $ unparse r) + where + samples = + [ "4003" + , "C0010203" + , "04C01157" + , "410104030502000112340A03040B03040C01FF" + , "410104030602AA02550112340A03040B03040C01FF" + ] + +testParse2 :: Assertion +testParse2 = do + let r = record ( item @"010" 1 *: nil) :: Record (RecordOf Cat_000_1_0) + d :: Datablock (DatablockOf Cat_000_1_0) + d = datablock (r *: r *: r *: nil) + bs = toByteString $ unparse @SBuilder d + result1 = parseRawDatablocks bs + dbs <- either (assertFailure . show) pure result1 + db <- assertOne dbs + let act = parseRecords (schema @(RecordOf Cat_000_1_0) Proxy) + result = parse @StrictParsing act (getRawRecords db) + records <- either (assertFailure . show) pure result + assertEqual "len" 3 (length records) + forM_ (zip [0::Int ..] records) $ \(cnt, i) -> do + assertEqual ("unparse " <> show cnt) + (debugBits $ unparse @Bits r) + (debugBits $ unparse @Bits i) + +testParse3 :: Assertion +testParse3 = do + let recPlot :: Record (RecordOfUap Cat_001_1_0 "plot") + recPlot = record + ( item @"010" 0x0102 + *: item @"020" (extended + ( item @"TYP" 0 *: 0 *: fx *: nil)) + *: item @"031" 0 + *: nil ) + recTrack :: Record (RecordOfUap Cat_001_1_0 "track") + recTrack = record + ( item @"010" 0x0102 + *: item @"020" (extended + ( item @"TYP" 1 *: 0 *: fx *: nil)) + *: item @"032" 0 + *: nil ) + + -- plots + do + let _db :: Datablock (DatablockOf Cat_001_1_0) = datablock + ( recPlot *: recPlot *: nil) + bs = toByteString $ unparse @SBuilder _db + dbs <- either (assertFailure . show) pure (parseRawDatablocks bs) + db <- assertOne dbs + let bs2 = getRawRecords db + + -- try to parse as 'plots' + let act1 = parseRecords (schema @(RecordOfUap Cat_001_1_0 "plot") Proxy) + result1 <- either (assertFailure . show) pure + (parse @StrictParsing act1 bs2) + assertEqual "plots length plots" 2 (length result1) + forM_ (zip [0::Int ..] result1) $ \(cnt, r1) -> do + assertEqual ("unparse " <> show cnt) + (debugBits $ unparse @Bits recPlot) + (debugBits $ unparse @Bits r1) + + -- try to parse as 'tracks' + let act2 = parseRecords (schema @(RecordOfUap Cat_001_1_0 "track") Proxy) + result2 = parse @StrictParsing act2 bs2 + assertEqual "result2" True (isLeft result2) + + -- try to parse as any defined UAP + let act3 = parseRecordsTry Nothing (schema @Cat_001_1_0 Proxy) + result3s <- either (assertFailure . show) pure + (parse @StrictParsing act3 bs2) + result3 <- assertOne result3s + assertEqual "plots length inner" 2 (length result3) + forM_ (zip [0::Int ..] result3) $ \(cnt, (_name, r2)) -> do + assertEqual ("unparse " <> show cnt) + (debugBits $ unparse @Bits recPlot) + (debugBits $ unparse @Bits r2) + + -- tracks + do + let _db :: Datablock (DatablockOf Cat_001_1_0) = datablock + ( recTrack *: recTrack *: recTrack *: nil) + bs = toByteString $ unparse @SBuilder _db + dbs <- either (assertFailure . show) pure (parseRawDatablocks bs) + db <- assertOne dbs + let bs2 = getRawRecords db + + -- try to parse as 'plots' + let act1 = parseRecords (schema @(RecordOfUap Cat_001_1_0 "plot") Proxy) + result1 = parse @StrictParsing act1 bs2 + assertEqual "result1" True (isLeft result1) + + -- try to parse as 'tracks' + let act2 = parseRecords (schema @(RecordOfUap Cat_001_1_0 "track") Proxy) + result2 <- either (assertFailure . show) pure + (parse @StrictParsing act2 bs2) + assertEqual "tracks length plots" 3 (length result2) + forM_ (zip [0::Int ..] result2) $ \(cnt, r2) -> do + assertEqual ("unparse " <> show cnt) + (debugBits $ unparse @Bits recTrack) + (debugBits $ unparse @Bits r2) + + -- try to parse as any defined UAP + let act3 = parseRecordsTry Nothing (schema @Cat_001_1_0 Proxy) + result3s <- either (assertFailure . show) pure + (parse @StrictParsing act3 bs2) + result3 <- assertOne result3s + assertEqual "tracks length inner" 3 (length result3) + forM_ (zip [0::Int ..] result3) $ \(cnt, (_name, r2)) -> do + assertEqual ("unparse " <> show cnt) + (debugBits $ unparse @Bits recTrack) + (debugBits $ unparse @Bits r2) + + -- mixed + do + let records + = recPlot *: recPlot + *: recTrack *: recTrack *: recTrack *: nil + _db :: Datablock (DatablockOf Cat_001_1_0) = datablock records + bs = toByteString $ unparse @SBuilder _db + dbs <- either (assertFailure . show) pure (parseRawDatablocks bs) + db <- assertOne dbs + let bs2 = getRawRecords db + + -- try to parse as 'plots' + let act1 = parseRecords (schema @(RecordOfUap Cat_001_1_0 "plot") Proxy) + result1 = parse @StrictParsing act1 bs2 + assertEqual "result1" True (isLeft result1) + + -- try to parse as 'tracks' + let act2 = parseRecords (schema @(RecordOfUap Cat_001_1_0 "track") Proxy) + result2 = parse @StrictParsing act2 bs2 + assertEqual "result2" True (isLeft result2) + + -- try to parse as any defined UAP + let act3 = parseRecordsTry Nothing (schema @Cat_001_1_0 Proxy) + result3s <- either (assertFailure . show) pure + (parse @StrictParsing act3 bs2) + result3 <- assertOne result3s + let recordsRaw = foldHList @(Unparsing Bits) + (\r -> [unparse @Bits r]) + records + assertEqual "mixed length inner" (length recordsRaw) (length result3) + forM_ (zip recordsRaw result3) $ \(r1, (_name, r2)) -> do + assertEqual "unparse" r1 (unparse @Bits r2) + +testParse4 :: Assertion +testParse4 = do + let recPlot :: Record (RecordOfUap Cat_001_1_0 "plot") + recPlot = record ( item @"010" 0x0102 *: nil ) + recTrack :: Record (RecordOfUap Cat_001_1_0 "track") + recTrack = record ( item @"010" 0x0102 *: nil ) + + -- from '010' item, both records look the same + assertEqual "unparse" (unparse @Bits recPlot) (unparse @Bits recTrack) + + do -- one + let _db :: Datablock (DatablockOf Cat_001_1_0) + = datablock (recPlot *: nil) + bs = toByteString $ unparse @SBuilder _db + dbs <- either (assertFailure . show) pure (parseRawDatablocks bs) + db <- assertOne dbs + let bs2 = getRawRecords db + act = parseRecordsTry Nothing (schema @Cat_001_1_0 Proxy) + results <- either (assertFailure . show) pure + (parse @StrictParsing act bs2) + assertEqual "results" 2 (length results) + forM_ results $ \result -> do + assertEqual "result" 1 (length result) + let act1 = parseRecords (schema @(RecordOfUap Cat_001_1_0 "plot") Proxy) + result1 <- either (assertFailure . show) pure + (parse @StrictParsing act1 bs2) + assertEqual "result" 1 (length result1) + let act2 = parseRecords (schema @(RecordOfUap Cat_001_1_0 "track") Proxy) + result2 <- either (assertFailure . show) pure + (parse @StrictParsing act2 bs2) + assertEqual "result" 1 (length result2) + + do -- two + let _db :: Datablock (DatablockOf Cat_001_1_0) = datablock + (recPlot *: recPlot *: nil) + bs = toByteString $ unparse @SBuilder _db + dbs <- either (assertFailure . show) pure (parseRawDatablocks bs) + db <- assertOne dbs + let bs2 = getRawRecords db + act = parseRecordsTry Nothing (schema @Cat_001_1_0 Proxy) + results <- either (assertFailure . show) pure + (parse @StrictParsing act bs2) + assertEqual "results" 4 (length results) + forM_ results $ \result -> do + assertEqual "result" 2 (length result) + let act1 = parseRecords (schema @(RecordOfUap Cat_001_1_0 "plot") Proxy) + result1 <- either (assertFailure . show) pure + (parse @StrictParsing act1 bs2) + assertEqual "result" 2 (length result1) + let act2 = parseRecords (schema @(RecordOfUap Cat_001_1_0 "track") Proxy) + result2 <- either (assertFailure . show) pure + (parse @StrictParsing act2 bs2) + assertEqual "result" 2 (length result2) + + do -- three + let _db :: Datablock (DatablockOf Cat_001_1_0) = datablock + (recPlot *: recPlot *: recPlot *: nil) + bs = toByteString $ unparse @SBuilder _db + dbs <- either (assertFailure . show) pure (parseRawDatablocks bs) + db <- assertOne dbs + let bs2 = getRawRecords db + act = parseRecordsTry Nothing (schema @Cat_001_1_0 Proxy) + results <- either (assertFailure . show) pure + (parse @StrictParsing act bs2) + assertEqual "results" (2 ^ (3::Int)) (length results) + forM_ results $ \result -> do + assertEqual "result" 3 (length result) + let act1 = parseRecords (schema @(RecordOfUap Cat_001_1_0 "plot") Proxy) + result1 <- either (assertFailure . show) pure + (parse @StrictParsing act1 bs2) + assertEqual "result" 3 (length result1) + let act2 = parseRecords (schema @(RecordOfUap Cat_001_1_0 "track") Proxy) + result2 <- either (assertFailure . show) pure + (parse @StrictParsing act2 bs2) + assertEqual "result" 3 (length result2) + +testParse5 :: Assertion +testParse5 = do + -- Non-compatible items in multiple uaps. + let recPlot :: Record (RecordOfUap Cat_001_1_0 "plot") + recPlot = record ( item @"041" 0xff *: nil ) + recTrack :: Record (RecordOfUap Cat_001_1_0 "track") + recTrack = record ( item @"042" 0xffff *: nil ) + + bsPlot = toByteString $ unparse @SBuilder recPlot + bsTrack = toByteString $ unparse @SBuilder recTrack + + do + let act = parseRecordsTry Nothing (schema @Cat_001_1_0 Proxy) + results <- either (assertFailure . show) pure + (parse @StrictParsing act bsPlot) + result <- assertOne results + void $ assertOne result + + do + let act = parseRecordsTry Nothing (schema @Cat_001_1_0 Proxy) + results <- either (assertFailure . show) pure + (parse @StrictParsing act bsTrack) + result <- assertOne results + void $ assertOne result + +testParse6 :: Assertion +testParse6 = do + -- Check parse_any_uap with max_depth. + let sample = BS.pack (replicate 10 0) + sch = schema @Cat_001_1_0 Proxy + act1 = parseRecordsTry (Just 9) sch + act2 = parseRecordsTry (Just 10) sch + result1 = parse @StrictParsing act1 sample + assertEqual "failure" True (isLeft result1) + result2 <- either (assertFailure . show) pure + (parse @StrictParsing act2 sample) + assertEqual "result2" 1024 (length result2) + +testParseNonblocking :: Assertion +testParseNonblocking = do + -- We encode a single record with a new edition, where some items + -- are added to the spec. We try to parse it as an old edition. + + let + -- old edition record + record0 :: Record (RecordOf Cat_000_1_0) + record0 = record + ( item @"000" 0x00 + *: item @"010" 0x0102 + *: nil ) + + -- new edition record (added item '200') + record1 :: Record (RecordOf Cat_000_1_1) + record1 = record + ( item @"000" 0x00 + *: item @"010" 0x0102 + *: item @"200" 0xff + *: nil ) + + -- encode new record + s = toByteString $ unparse @SBuilder record1 + + -- try to parse as a list with both editions + assertEqual "result1" True (isLeft $ parse @StrictParsing + (parseRecords $ schema @(RecordOf Cat_000_1_0) Proxy) s) + assertEqual "result2" True (isRight $ parse @StrictParsing + (parseRecords $ schema @(RecordOf Cat_000_1_1) Proxy) s) + + -- single record parsing combinations + + -- parsing with new edition shall not fail, regardless of parsing mode + r1a <- either (assertFailure . show) pure + (parse @StrictParsing (parseRecord $ schema @(RecordOf Cat_000_1_1) Proxy) s) + r1b <- either (assertFailure . show) pure + (parse @PartialParsing (parseRecord $ schema @(RecordOf Cat_000_1_1) Proxy) s) + assertEqual "unparse" (unparse @Bits record1) (unparse r1a) + assertEqual "unparse" (unparse @Bits record1) (unparse r1b) + + -- old edition, partial parsing shall not fail + r2 <- either (assertFailure . show) pure (parse @PartialParsing + (parseRecord $ schema @(RecordOf Cat_000_1_0) Proxy) s) + assertEqual "unparse" (unparse @Bits record0) (unparse @Bits r2) + +testEmpty :: Assertion +testEmpty = do + -- Test 'is_empty' function + + -- repetitive + let rep1, rep2 :: NonSpare (RecordOf Cat_000_1_0 ~> "061") + rep1 = repetitive [1,2,3] + rep2 = repetitive [] + assertEqual "rep empty1" (isEmpty rep1) False + assertEqual "rep empty2" (isEmpty rep2) True + + -- compound + let comp1, comp2 :: NonSpare (RecordOf Cat_000_1_0 ~> "093") + comp1 = compound ( item @"I1" 1 *: nil) + comp2 = compound nil + assertEqual "comp empty1" (isEmpty comp1) False + assertEqual "comp empty2" (isEmpty comp2) True + + -- record + let rec1, rec2 :: Record (RecordOf Cat_000_1_0) + rec1 = record (item @"000" 1 *: nil) + rec2 = record nil + assertEqual "rec empty1" (isEmpty rec1) False + assertEqual "rec empty2" (isEmpty rec2) True + diff --git a/test/TestBits.hs b/test/TestBits.hs new file mode 100644 --- /dev/null +++ b/test/TestBits.hs @@ -0,0 +1,135 @@ +{-# LANGUAGE LambdaCase #-} + +module TestBits (tests) where + +import qualified Data.ByteString as BS + +import Test.Tasty +import Test.Tasty.HUnit +import Test.Tasty.QuickCheck as QC + +import Asterix.BitString + +tests :: TestTree +tests = testGroup "Bits" + [ testBitsConversion + , testBitsNumConversion + , testBitsDebug + , testBsToBools + , testIntToBools + , testIntToBoolsProp + , testBitsBoolsProp + , testBitsAppend + , testBitsAppendProp + ] + +testBitsConversion :: TestTree +testBitsConversion = QC.testProperty "conversion prop" $ \lst -> + let bs1 = BS.pack lst + bs2 = builderToByteStringSlow + $ bitsToBuilder + $ byteStringToBits bs1 + in bs1 == bs2 + +testBitsNumConversion :: TestTree +testBitsNumConversion = QC.testProperty "num conversion" $ \o lst -> + let o8 = mod (getNonNegative o) 8 + s = boolsToBits o8 lst + n = sum $ zipWith f [0..] (reverse lst) + in bitsToNum s == n + where + f i = \case + False -> 0 + True -> (2 :: Integer) ^ (i :: Int) + +testBitsDebug :: TestTree +testBitsDebug = testGroup "debugBits" (fmap check samples) + where + check (ix::Int, (x, y)) = testCase ("bits-" <> show ix) $ + debugBits x @?= y + samples = zip [1..] + [ (byteStringToBits $ BS.pack [], "") + , (byteStringToBits $ BS.pack [0xa5], "10100101") + , (byteStringToBits $ BS.pack [0xa5, 0x12], "10100101 00010010") + , (integerToBits 0 8 0x5a, "01011010") + , (integerToBits 1 8 0x5a, ".0101101 0.......") + , (integerToBits 2 8 0x5a, "..010110 10......") + , (integerToBits 2 7 0x5a, "..101101 0.......") + , (integerToBits 2 6 0x5a, "..011010") + , (integerToBits 1 6 0x5a, ".011010.") + , (integerToBits 0 1 0x01, "1.......") + , (integerToBits 1 1 0x01, ".1......") + , (integerToBits 2 1 0x01, "..1.....") + , (integerToBits 2 1 0x00, "..0.....") + , (integerToBits 0 16 0xff00, "11111111 00000000") + , (integerToBits 0 16 0x00ff, "00000000 11111111") + , (integerToBits 1 16 0x00ff, ".0000000 01111111 1.......") + ] + +testBsToBools :: TestTree +testBsToBools = testGroup "BsToBools" (fmap check samples) + where + check (x, y) = testCase (hexlify $ BS.pack x) $ + bitsToBools (byteStringToBits $ BS.pack x) @?= y + samples = + [ ([], []) + , ([0], [False, False, False, False, False, False, False, False]) + , ([0x5a], [False, True, False, True, True, False, True, False]) + , ([1,2], + [ False, False, False, False, False, False, False, True + , False, False, False, False, False, False, True, False + ]) + ] + +testIntToBools :: TestTree +testIntToBools = testGroup "IntToBools" (fmap check samples) + where + check (o, n, x, lst) = testCase (show (o, n, x)) $ + bitsToBools (integerToBits o n x) @?= lst + samples = + [ (0, 0, 0, []) + , (0, 8, 0x00, [False, False, False, False, False, False, False, False]) + , (0, 8, 0x5a, [False, True, False, True, True, False, True, False]) + , (1, 8, 0x5a, [False, True, False, True, True, False, True, False]) + , (1, 7, 0x01, [False, False, False, False, False, False, True]) + , (1, 7, 0x5a, [True, False, True, True, False, True, False]) + , (0, 8, 0xff, [True, True, True, True, True, True, True, True]) + ] + +testIntToBoolsProp :: TestTree +testIntToBoolsProp = QC.testProperty "intToBitsProp" $ \(NonNegative n) -> + forAll (elements [0..7]) $ \o -> + forAll (arbitrary `suchThat` (\val -> (Prelude.length val * 8) >= n)) $ \lst -> + let x = BS.foldl (\a w -> a * 256 + fromIntegral w) 0 (BS.pack lst) + b = integerToBits o n x + i = mconcat (fmap word8ToBools lst) + in bitsToBools b + === reverse (take n $ reverse i) + +testBitsBoolsProp :: TestTree +testBitsBoolsProp = QC.testProperty "Bits Bools prop" $ \lst -> + forAll (elements [0..7]) $ \o8 -> + bitsToBools (boolsToBits o8 lst) == lst + +testBitsAppend :: TestTree +testBitsAppend = testGroup "append" (fmap check samples) + where + (<+>) = appendBits + check (ix::Int, (x, y)) = testCase ("test-" <> show ix) $ + debugBits x @?= debugBits y + samples = zip [1..] + [ (integerToBits 0 0 0 <+> integerToBits 0 0 0, integerToBits 0 0 0) + , (integerToBits 0 8 0x12 <+> integerToBits 0 8 0x34, integerToBits 0 16 0x1234) + , (integerToBits 0 8 0x12 <+> integerToBits 0 12 0x345, integerToBits 0 20 0x12345) + , (integerToBits 0 4 0xa <+> integerToBits 4 4 0x5, integerToBits 0 8 0xa5) + , (integerToBits 1 2 1 <+> integerToBits 3 4 1, integerToBits 1 6 0x11) + ] + +testBitsAppendProp :: TestTree +testBitsAppendProp = QC.testProperty "append prop" $ \lst1 lst2 -> + forAll (elements [0..7]) $ \o8 -> + let b1 = boolsToBits o8 lst1 + b2 = boolsToBits (rightAlignment b1) lst2 + b = boolsToBits o8 (lst1 <> lst2) + in appendBits b1 b2 == b + diff --git a/test/TestCoding.hs b/test/TestCoding.hs new file mode 100644 --- /dev/null +++ b/test/TestCoding.hs @@ -0,0 +1,118 @@ +{-# LANGUAGE DataKinds #-} + +-- | Unsorted Coding tests + +module TestCoding (tests) where + +import Data.Word + +import Test.Tasty +import Test.Tasty.HUnit + +import Asterix.Coding +import Common +import Generated as Gen + +type Cat0_1_0 = Gen.Cat_000_1_0 +type Cat1_1_0 = Gen.Cat_001_1_0 + +tests :: TestTree +tests = testGroup "Coding" + [ testCase "create" testCreate + ] + +mkSac :: Word8 -> NonSpare (Cat0_1_0 ~> "010" ~> "SAC") +mkSac = fromIntegral + +mkSic :: Word8 -> NonSpare (Cat0_1_0 ~> "010" ~> "SIC") +mkSic = fromIntegral + +toItem :: NonSpare t -> Item ('GItem t) +toItem = Item . UItem . unNonSpare + +mkSacSic :: Word8 -> Word8 -> NonSpare (Cat0_1_0 ~> "010") +mkSacSic a b = group + ( item @"SAC" (toItem $ mkSac a) + *: item @"SIC" (toItem $ mkSic b) + *: nil) + +testCreate :: Assertion +testCreate = do + checkBits "i000" (0xa5 :: NonSpare (Cat0_1_0 ~> "000")) (Bin "10100101") + checkBits "i010" (0x0102 :: NonSpare (Cat0_1_0 ~> "010")) (Hex "0102") + checkBits "mkSacSic" (mkSacSic 0x03 0x04) (Hex "0304") + do + let nsp :: NonSpare (Cat0_1_0 ~> "010") + nsp = group + ( item @"SAC" 0x01 + *: item @"SIC" 0x02 + *: nil) + checkBits "i010b" nsp (Hex "0102") + do + let nsp :: NonSpare (Cat0_1_0 ~> "010") + nsp = group + ( item 0x01 + *: 0x02 + *: nil) + checkBits "i010c" nsp (Hex "0102") + + do + let nsp1 :: NonSpare (Cat0_1_0 ~> "040") + nsp1 = group + ( item @"I1" 0x7f + *: spare + *: item @"I2" 0x3f + *: abuseSpare 0x12 + *: nil) + nsp2 :: NonSpare (Cat0_1_0 ~> "040") + nsp2 = group + ( item @"I1" 0x7f + *: spare + *: item @"I2" 0x3f + *: 0x12 + *: nil) + result = Bin "11111110 01111110 00010010" + checkBits "i040a" nsp1 result + checkBits "i040b" nsp2 result + + do + let db :: Datablock (DatablockOf Cat0_1_0) + db = datablock nil + checkBits "empty db" db (Hex "000003") + + do + let + sacsic :: NonSpare (Cat0_1_0 ~> "010") + sacsic = group + ( item @"SAC" 0x02 + *: item @"SIC" 0x03 + *: nil ) + db :: Datablock (DatablockOf Cat0_1_0) + db = datablock + ( record + ( item @"000" 0x01 + *: item @"010" sacsic + *: nil ) + *: nil ) + checkBits "simple db" db (Hex "000007c0020301") + + do + let + r :: Record (RecordOf Cat0_1_0) + r = record (item @"000" 0x01 *: nil) + db :: Datablock (DatablockOf Cat0_1_0) + db = datablock (r *: r *: nil) + checkBits "2 records" db (Hex "00000740014001") + + do + let + r1 :: Record (RecordOfUap Cat1_1_0 "plot") + r1 = record (item @"010" 0x0102 *: nil) + + r2 :: Record (RecordOfUap Cat1_1_0 "track") + r2 = record (item @"010" 0x0102 *: nil) + + db :: Datablock (DatablockOf Cat1_1_0) + db = datablock (r1 *: r2 *: nil) + checkBits "multi uap" db (Hex "010009800102800102") + diff --git a/test/TestRawDatablock.hs b/test/TestRawDatablock.hs new file mode 100644 --- /dev/null +++ b/test/TestRawDatablock.hs @@ -0,0 +1,69 @@ +module TestRawDatablock (tests) where + +import Data.ByteString (ByteString) +import qualified Data.ByteString as BS +import Data.ByteString.Builder as BSB +import Data.Either +import Data.Maybe +import Data.Word +import Test.Tasty +import Test.Tasty.HUnit +import Test.Tasty.QuickCheck + +import Asterix.Base +import Asterix.BitString + +allowCategory :: Word8 -> RawDatablock -> Bool +allowCategory n db = rawDatablockCategory db == n + +rawDatablockFilter :: (RawDatablock -> Bool) -> ByteString -> Builder +rawDatablockFilter predicate s = case parseRawDatablocks s of + Left _err -> BSB.byteString s + Right lst -> mconcat (unparseRawDatablock <$> filter predicate lst) + +reverseDatablocks :: ByteString -> Builder +reverseDatablocks s = case parseRawDatablocks s of + Left _err -> BSB.byteString s + Right lst -> mconcat (unparseRawDatablock <$> reverse lst) + +-- e.g.: received from the network +samples :: [String] +samples = + [ "01000401" -- cat1 + , "01000401" -- cat1 + , "02000402" -- cat2 + ] + +allZeros :: String +allZeros = "00000000000000000000" + +datagramIn :: ByteString +datagramIn = fromJust $ unhexlify $ mconcat samples + +tests :: TestTree +tests = testGroup "RawDatablock" + [ testCase "correct parsing" $ assertEqual "sample" + True (isRight $ parseRawDatablocks datagramIn) + , testCase "incorrect parsing" $ assertEqual "sample" + True (isLeft $ parseRawDatablocks $ BS.tail datagramIn) + , testCase "filter 1" $ checkFilter 1 cat1 + , testCase "filter 2" $ checkFilter 2 cat2 + , testCase "reverse" $ assertEqual "sample" + (fromJust $ unhexlify $ mconcat $ reverse samples) + (builderToByteStringSlow $ reverseDatablocks datagramIn) + , testCase "all zeros" $ assertEqual "sample" + True (isLeft $ parseRawDatablocks $ fromJust $ unhexlify allZeros) + , testProperty "random input" $ withMaxSuccess 10_000 $ \(lst :: [Word8]) -> + let bs = BS.pack lst + result = parseRawDatablocks bs + -- this is always true, but we want the expression to terminate + in (isLeft result || isRight result) + ] + where + cat1 = take 2 samples + cat2 = take 1 $ drop 2 samples + checkFilter n expected = assertEqual (show n) + (mconcat expected) + (hexlify $ builderToByteStringSlow $ rawDatablockFilter (allowCategory n) + datagramIn) +