diff --git a/.ghci b/.ghci --- a/.ghci +++ b/.ghci @@ -1,1 +1,1 @@ -:set -fglasgow-exts -fallow-overlapping-instances -fallow-undecidable-instances -fno-monomorphism-restriction -XOverloadedStrings +:set -fglasgow-exts -XOverlappingInstances -XUndecidableInstances -XNoMonomorphismRestriction -XOverloadedStrings diff --git a/Analysis/STA.hs b/Analysis/STA.hs deleted file mode 100644 --- a/Analysis/STA.hs +++ /dev/null @@ -1,96 +0,0 @@ -{-# OPTIONS_GHC -fno-warn-missing-fields #-} - -module Analysis.STA - ( TransitionTime - , Timing (..) - , STALibrary - , Prop - , analyzeTiming - ) where - - - -import Control.Arrow ((***)) -import Control.Monad - -import Data.Hardware -import Lava.Internal -import Analysis.STA.Library - - - -data Prop = Prop - { riseTiming :: Timing - , fallTiming :: Timing - , capacitance :: Capacitance - } - - - -addTiming :: Timing -> Timing -> Timing -addTiming (Timing ar1 tr1) (Timing ar2 tr2) = Timing (ar1+ar2) (tr1+tr2) - -addProp :: Prop -> Prop -> Prop -addProp (Prop timR1 timF1 cap1) (Prop timR2 timF2 cap2) = - Prop (addTiming timR1 timR2) (addTiming timF1 timF2) (cap1+cap2) - -timing0 = Timing 0 0 - -prop0 = Prop timing0 timing0 0 - -propCap cap = prop0 {capacitance = cap} - -propRiseFall timR timF = prop0 {riseTiming = timR, fallTiming = timF} - -getDelay :: Prop -> Delay -getDelay (Prop timR timF _) = maxArrival timR timF - - - -interpTiming :: STALibrary lib => Interpretation lib Prop -interpTiming = Interp - { defaultVal = prop0 - , accumulator = addProp - , propagator = propagate - } - where - propagate cell ss = outs' ++ ins' - where - no = numOuts cell - (outs,ins) = splitAt no ss - - propagatePath oPin oCap (iPin, Prop iTimR iTimF _) = (oTimR,oTimF) - where - oTimR = maximumByArrival - [ delay cell iPin oPin Rising oCap iTimR - , delay cell iPin oPin Rising oCap iTimF - ] - - oTimF = maximumByArrival - [ delay cell iPin oPin Falling oCap iTimF - , delay cell iPin oPin Falling oCap iTimR - ] - - ins' = map (Just . propCap) (loadCaps cell) - - outs' = do - (oPin, Prop _ _ oCap) <- zip [0..] outs - let (timRs,timFs) = - unzip $ map (propagatePath oPin oCap) $ zip [icast no ..] ins - return $ Just $ propRiseFall - (maximumByArrival timRs) - (maximumByArrival timFs) - - - -analyzeTiming - :: ( STALibrary lib - , PortStruct ps Signal t - , PortStruct pd Delay t - ) - => Lava lib ps -> (pd, InterpDesignDB lib Prop) - -analyzeTiming = (unport . fmap getDelay *** id) . interpret_ interpTiming [] . liftM port - -- *** Check for loop. - -- *** Add wire loads. - diff --git a/Analysis/STA/Library.hs b/Analysis/STA/Library.hs deleted file mode 100644 --- a/Analysis/STA/Library.hs +++ /dev/null @@ -1,69 +0,0 @@ -module Analysis.STA.Library where - - - -import Data.Function -import Data.List - -import Data.Hardware.Internal -import Lava -import Wired.Model - - - -data Slope = Rising | Falling - deriving (Eq, Show) - -type TransitionTime = Time - -data Timing = Timing - { arrivalTime :: Time - , transitionTime :: TransitionTime - } - - - -class WiredLibrary lib => STALibrary lib - where - loadCaps :: lib -> [Capacitance] - - delay - :: lib - -> Pin -- Input - -> Pin -- Output - -> Slope -- For output - -> Capacitance -- For output - -> Timing -- For input - -> Timing -- For output - - - -mulTiming :: Timing -> Time -> Timing -mulTiming (Timing ar tr) x = Timing (ar*x) (tr*x) - -maxArrival :: Timing -> Timing -> Time -maxArrival = max `on` arrivalTime - -maximumByArrival :: [Timing] -> Timing -maximumByArrival = maximumBy (compare `on` arrivalTime) - - - -linearDelay - :: Delay -- Intrinsic delay - -> Double -- Rise time coefficient - -> Resistance -- Load capacitance coefficient - -> (Capacitance -> Timing -> Timing) - -linearDelay intrDel kTR res cap (Timing ar tr) = Timing - (ar + intrDel + kTR> (Capacitance -> Timing -> Timing) - -worstLinearDelay params cap t = maximumByArrival - [linearDelay intrDel kTR res cap t | (intrDel,kTR,res) <- params] - diff --git a/Analysis/Timing.hs b/Analysis/Timing.hs new file mode 100644 --- /dev/null +++ b/Analysis/Timing.hs @@ -0,0 +1,165 @@ +{-# OPTIONS_GHC -fno-warn-missing-fields #-} + +module Analysis.Timing + ( TransitionTime + , Timing (..) + , TimingLibrary + , analyzeTiming + , analyzeTimingW + ) where + + + +import Control.Arrow ((***)) +import Control.Monad +import Data.Function +import Data.List +import qualified Data.Map as Map + +import Data.Hardware.Internal +import Lava.Internal +import Layout.Internal +import Wired.Model +import Analysis.Timing.Library + + + +instance Port Time Time + where + port = One + unport = unOne + +instance PortStruct Time Time () + + + +addTiming :: Timing -> Timing -> Timing +addTiming (Timing ar1 tr1) (Timing ar2 tr2) = Timing (ar1+ar2) (tr1+tr2) + +addSig :: (Timing,Capacitance) -> (Timing,Capacitance) -> (Timing,Capacitance) +addSig (tim1,cap1) (tim2,cap2) = (addTiming tim1 tim2, cap1+cap2) + +timing0 = Timing 0 0 + +prop0 = (timing0, 0) + +propCap cap = (timing0, cap) + +propTim tim = (tim, 0) + +getDelay :: (Timing,Capacitance) -> Delay +getDelay = arrivalTime . fst + + + +interpTiming :: TimingLibrary lib => Interpretation lib (Timing,Capacitance) +interpTiming = Interp + { defaultVal = prop0 + , accumulator = addSig + , propagator = propagate + } + where + propagate cell ss = outs' ++ ins' + where + no = numOuts cell + (outs,ins) = genericSplitAt no ss + + propagatePath oPin oCap (iPin, (iTim,_)) = maximumByArrival + [ delay cell iPin oPin Rising oCap iTim + , delay cell iPin oPin Falling oCap iTim + ] + + ins' = map (Just . propCap) (loadCaps cell) + + outs' + | null ins = map (const (Just prop0)) outs + -- Cells with no inputs have prop0 on the outputs. + + | otherwise = do + (oPin, ~(_,oCap)) <- zip [0..] outs + return + $ Just + $ propTim + $ maximumByArrival + $ map (propagatePath oPin oCap) + $ zip [0..] + $ ins + + -- XXX This (and depthInterp) assumes that there's a path between each + -- input/output pair in a cell. In general, this might not be true. + + + +analyzeTiming + :: ( MonadLava lib m + , TimingLibrary lib + , PortStruct ps Signal t + , PortStruct pd Delay t + ) + => m ps -> (pd, InterpDesignDB lib (Timing,Capacitance)) + +analyzeTiming mps + | hasLoopDB True db = error "analyzeTiming: Combinational feedback loop" + | otherwise = pd_idb + where + pd_idb@(_,(db,_)) + = (unport . fmap getDelay *** id) + $ interpret_ interpTiming [] + $ liftM port + $ toLava + $ mps + + + +netCap + :: WireTimingLibrary lib + => [(Layer_, Position, Position)] + -> Res lib Capacitance + +netCap gs + = wireCap lay + $ Length + $ round + $ sum + $ map rectiDistance + $ rectiSpanning + $ map (\(_,pos,_) -> pos) -- XXX Ignoring length of guide + $ gs + where + layss + = sortBy (compare `on` length) + $ group + $ sort + $ map (\(lay,_,_) -> lay) gs + -- Sort layers by frequency. + + lay = case layss of + (lay:_):_ -> lay + _ -> 1 -- Empty guide list, so layer doesn't matter. + -- Most common layer (XXX better to use top-most layer?) + + + +analyzeTimingW + :: forall lib ps t pd + . ( WireTimingLibrary lib + , PortStruct ps Signal t + , PortStruct pd Delay t + ) + => Wired lib ps -> (pd, InterpDesignDB lib (Timing,Capacitance)) + +analyzeTimingW wps + | hasLoopDB True db = error "analyzeTimingW: Combinational feedback loop" + | otherwise = pd_idb + where + (ps,(db,fp)) = runWired wps + + res = result :: Res lib Capacitance -> Capacitance + + wireLoads = Map.toList $ + fmap (propCap . res . netCap) $ mkGuideDB fp + + pd_idb + = (unport . fmap getDelay *** id) + $ interpret__ interpTiming wireLoads (port ps,db) + diff --git a/Analysis/Timing/Library.hs b/Analysis/Timing/Library.hs new file mode 100644 --- /dev/null +++ b/Analysis/Timing/Library.hs @@ -0,0 +1,120 @@ +module Analysis.Timing.Library where + + + +import Data.Function +import Data.List +import Foreign.C + +import Data.Hardware.Internal +import Lava +import Wired.Model + + + +data Slope = Rising | Falling + deriving (Eq, Show) + +data Timing = Timing + { arrivalTime :: Time + , transitionTime :: TransitionTime + } + deriving (Eq, Show) + +data LayerProps = LayerProps + { layerWidth :: Width -- Default width + , capPerArea :: Double -- Area capacitance [F/m²] + , edgeCap :: Double -- Edge capacitance [F/m] + } + deriving (Eq, Show) + -- XXX All wires are currently assumed to have default width. + + + +class CellLibrary lib => TimingLibrary lib + where + loadCaps :: lib -> [Capacitance] + + delay + :: lib + -> InPin + -> OutPin + -> Slope -- For output + -> Capacitance -- For output + -> Timing -- For input + -> Timing -- For output + +class TimingLibrary lib => WireTimingLibrary lib + where + layerProps :: Layer_ -> Res lib LayerProps + + + +maximumByArrival :: [Timing] -> Timing +maximumByArrival = maximumBy (compare `on` arrivalTime) + + + +linearDelay + :: Delay -- Intrinsic delay + -> Double -- Transition time coefficient for output arrival + -> Double -- Transition time coefficient for output transition + -> Resistance -- Load capacitance coefficient for output arrival + -> Resistance -- Load capacitance coefficient for output transition + -> Capacitance + -> Timing + -> Timing + +linearDelay intrDel kAr kTr resAr resTr cap (Timing ar tr) = Timing + (ar + intrDel + timeCast (kAr> Table2D CInt TransitionTime Capacitance TransitionTime + -> (Capacitance -> Timing -> Timing) +tableDelay arLut trLut cap (Timing ar tr) = Timing ar' tr' + where + ar' = bilinInterpolate arLut tr cap + ar + tr' = bilinInterpolate trLut tr cap + + + +mkTimingTable + :: ( Fractional x + , Fractional y + , Fractional q + ) + => CInt + -> CInt + -> (CInt -> CDouble) + -> (CInt -> CDouble) + -> (CInt -> CInt -> CDouble) + -> Table2D CInt x y q + +mkTimingTable xLen yLen xAxis yAxis vals = Table2D + xLen + yLen + (realToFrac . xAxis) + (realToFrac . yAxis) + (\i1 i2 -> realToFrac (vals i1 i2)) + + + +wireCap + :: forall lib . WireTimingLibrary lib + => Layer_ -> Length -> Res lib Capacitance +wireCap lay len = R $ dcast + $ cArea * l*w + + (cEdge * 2 * (l+w)) + where + LayerProps wit cArea cEdge = result (layerProps lay :: Res lib LayerProps) + + l = fromRational $ value len + w = fromRational $ value wit + -- Formula taken from the LEF/DEF 5.5 Language Reference. + -- The 2*(l+w) part probably assumes a rectangular segment, but it seems to be + -- an OK approximation for other shapes too (and w is usually very small). + diff --git a/Data/Hardware.hs b/Data/Hardware.hs --- a/Data/Hardware.hs +++ b/Data/Hardware.hs @@ -1,16 +1,16 @@ +-- | This module exports the types that users of "Lava", "Layout" and "Wired" +-- (not the internal modules) will need. module Data.Hardware - ( Name + ( Res (..) + , Name , Tag - , IntCast (..) - , DoubleCast (..) - , icast - , dcast - , Length + , Length (..) + , XPos + , YPos , Width , Height + , addLen, subLen, mulLen, mulLen2, divLen , Layer - , Capacitance - , Resistance , Time , Delay ) where diff --git a/Data/Hardware/Internal.hs b/Data/Hardware/Internal.hs --- a/Data/Hardware/Internal.hs +++ b/Data/Hardware/Internal.hs @@ -1,34 +1,43 @@ +-- | This module defines types of a general nature that are used by the "Lava", +-- "Layout" and "Wired" libraries. It also defines operations on those types. module Data.Hardware.Internal where +import Control.Arrow ((***)) import Data.Function import Data.List import Data.Map (Map) import qualified Data.Map as Map import Data.Maybe import Data.String -import Test.QuickCheck +import Test.QuickCheck (Arbitrary, (==>), quickCheck) -------------------------------------------------------------------------------- --------------------------------------------------------------------------------- +-- * Type-parameterized results -------------------------------------------------------------------------------- -data TypeOf a = T - -- Used to pass a type constraint to an overloaded function. This is safer - -- than using undefined. +-- | The phantom parameter @t@ can be used to pass a type constraint to an +-- overloaded function. +data Res t a = R {result :: !a} + deriving (Eq, Show) -typeOf :: a -> TypeOf a -typeOf = const T + -- Res could be instantiated for Applicative, but that's not always very + -- useful, since it only allows computations where all expressions have the + -- same type of t. +instance Functor (Res t) + where + fmap f (R t) = R (f t) --------------------------------------------------------------------------------- + -------------------------------------------------------------------------------- +-- * Difference strings -------------------------------------------------------------------------------- @@ -50,29 +59,24 @@ unlineS :: [ShowS] -> ShowS unlineS [] = id -unlineS [s] = s +unlineS [s] = s . "\n" unlineS (s:ss) = s . "\n" . unlineS ss -newtype Name = Name {unName :: String} - deriving (Eq, Ord, IsString) +-------------------------------------------------------------------------------- +-- * Identifiers +-------------------------------------------------------------------------------- -newtype Tag = Tag {unTag :: String} - deriving (Eq, Ord, IsString) -instance Show Name - where - show = unName -instance Show Tag - where - show = unTag +type Name = String +type Tag = String -------------------------------------------------------------------------------- --------------------------------------------------------------------------------- +-- * Numerical types -------------------------------------------------------------------------------- @@ -87,6 +91,11 @@ toInt = id fromInt = id +instance IntCast Integer + where + toInt = fromInteger + fromInt = toInteger + instance IntCast Double where toInt = round @@ -109,11 +118,13 @@ toDouble = fromIntegral fromDouble = round -instance DoubleCast Rational +instance DoubleCast Integer where - toDouble = fromRational - fromDouble = toRational + toDouble = fromIntegral + fromDouble = round + + icast :: (IntCast m, IntCast n) => m -> n icast = fromInt . toInt -- Conversion between different integer types @@ -138,13 +149,13 @@ -newtype Pin = Pin Int +newtype InPin = InPin Int deriving (Eq, Show, Ord, Num, Real, Integral, Enum, IntCast) - -- Identifies a pin of a cell. + -- Identifies a input pin of a cell. -newtype ConstId = ConstId Int +newtype OutPin = OutPin Int deriving (Eq, Show, Ord, Num, Real, Integral, Enum, IntCast) - -- Identifies a constant signal. + -- Identifies a output pin of a cell. newtype PrimInpId = PrimInpId Int deriving (Eq, Show, Ord, Num, Real, Integral, Enum, IntCast) @@ -156,25 +167,93 @@ -newtype Length = Length Int - deriving (Eq, Show, Ord, Num, Real, Integral, Enum, IntCast) - -- [nm] +newtype Length = Length {unLength :: Integer} + deriving + ( Eq + , Show + , Ord + , Arbitrary + ) + -- The interpretation of a length unit depends on the application. We're + -- using Integer because otherwise we can easily get overflows when two + -- lengths are multiplied. The limit for 32-bit Int is below 50000², which is + -- easily reached, e.g. for a circuit layout with a unit of 0.1nm. -newtype Width = Width Int - deriving (Eq, Show, Ord, Num, Real, Integral, Enum, IntCast) - -- [nm] +type XPos = Length +type YPos = Length +type Width = Length +type Height = Length + -- Note that distinguishing between different distance types would be quite + -- inconvenient, since they are often used in the same numeric expressions. -newtype Height = Height Int - deriving (Eq, Show, Ord, Num, Real, Integral, Enum, IntCast) - -- [nm] +class Value v + where + value :: v -> Rational + -- Gives the actual value of the argument. + -- This allows the Num and Fractional instances for Length to abstract away + -- from the length unit used in an application. For example, by defining + -- + -- value (Length l) = fromIntegral l * 1e-9 + -- + -- we get + -- + -- fromInteger 1 :: Length ---> Length 1000000000 + -- + -- The alternative would be to let application libraries export abstract + -- constructor functions for Length, but then we'd still want fromInteger to + -- behave correctly since it gets inserted implicitly if one happens to forget + -- using a constructor function. -newtype Layer = Layer Int + + +instance Value Length => Num Length + where + Length l1 + Length l2 = Length (l1+l2) + Length l1 - Length l2 = Length (l1-l2) + Length l1 * Length l2 = Length (l1*l2) + + abs (Length l) = Length (abs l) + signum (Length l) = Length (signum l) + + fromInteger i = Length $ round (fromIntegral i / value (Length 1)) + +instance Value Length => Fractional Length + where + fromRational r = Length $ round (r / value (Length 1)) + + + +addLen :: Length -> Length -> Length +addLen (Length l1) (Length l2) = Length (l1+l2) + +subLen :: Length -> Length -> Length +subLen (Length l1) (Length l2) = Length (l1-l2) + +mulLen :: Integral n => Length -> n -> Length +mulLen (Length l) n = Length (l * toInteger n) + +mulLen2 :: Length -> Length -> Integer +mulLen2 (Length l1) (Length l2) = l1*l2 + +divLen :: Integral n => Length -> n -> Length +divLen (Length l) n = Length (l `div` toInteger n) + + -- These operations can be used when there's no Value Length instance in + -- scope. + + + +newtype Layer_ = Layer Int deriving (Eq, Show, Ord, Num, Real, Integral, Enum, IntCast) + -- Safe layer type (for internal use). +type Layer = Int + -- Unsafe layer type (for user convenience). + newtype Capacitance = Cap Double deriving (Eq, Show, Num, Ord, Fractional, IntCast, DoubleCast) -- [F] @@ -189,6 +268,10 @@ type Delay = Time +newtype TransitionTime = TransitionTime Double + deriving (Eq, Show, Num, Ord, Fractional, IntCast, DoubleCast) + -- [s] + instance Multiply Resistance Capacitance Time where r >< c = dcast (r * dcast c) @@ -197,16 +280,24 @@ where c >< r = r >< c +class DoubleCast t => IsTime t +instance IsTime Time +instance IsTime TransitionTime --------------------------------------------------------------------------------- +timeCast :: (IsTime t1, IsTime t2) => t1 -> t2 +timeCast = dcast + + + -------------------------------------------------------------------------------- +-- * Misc. types -------------------------------------------------------------------------------- -type Position = (Width,Height) -type Size = (Width,Height) +type Position = (XPos, YPos) +type Size = (Width, Height) @@ -217,7 +308,9 @@ deriving (Eq, Show) type Orientation = (Bool, Direction) - -- The bool tells whether or not the object is flipped around the y-axis. + -- The bool tells whether or not the object is flipped around the y-axis. The + -- standard direction is north (see below). This representation is inspired by + -- the DEF file format. @@ -233,23 +326,24 @@ -------------------------------------------------------------------------------- --------------------------------------------------------------------------------- +-- * Total lookup in partial maps -------------------------------------------------------------------------------- +-- | A lookup function that is defined for all keys. totalLookup :: Ord k => k -> Map k [a] -> [a] totalLookup k = concat . maybeToList . Map.lookup k - -- A lookup function that is defined for all keys. -------------------------------------------------------------------------------- --------------------------------------------------------------------------------- +-- * Spanning trees -------------------------------------------------------------------------------- +-- | Computes the minimal spanning tree based on the given distance function. spanning :: ((Position,Position) -> Double) -> [Position] -> [(Position,Position)] @@ -261,17 +355,17 @@ where (p,q) = minimumBy (compare `on` dist) [ (p,q) | p <- ps, q <- qs ] - -- Computes the minimal spanning tree based on the given distance function. - -- *** Comlexity: O(n²) + -- XXX Comlexity: O(n²) euclidDistance :: (Position,Position) -> Double -euclidDistance ((x1,y1),(x2,y2)) = - sqrt $ fromIntegral $ (x1-x2)^2 + icast ((y1-y2)^2) +euclidDistance ((Length x1, Length y1),(Length x2, Length y2)) = + sqrt $ toDouble $ (x1-x2)^2 + (y1-y2)^2 rectiDistance :: (Position,Position) -> Double -rectiDistance ((x1,y1),(x2,y2)) = icast (abs (x1-x2)) + icast (abs (y1-y2)) +rectiDistance ((Length x1, Length y1),(Length x2, Length y2)) = + toDouble $ abs (x1-x2) + abs (y1-y2) euclidSpanning :: [Position] -> [(Position,Position)] euclidSpanning = spanning euclidDistance @@ -281,10 +375,7 @@ -deriving instance Arbitrary Width -deriving instance Arbitrary Height - - +-- ** Properties prop_span1 dist ps = length ps > 0 ==> length (spanning dist ps) == (length ps - 1) @@ -304,8 +395,18 @@ ls = spanning dist ps ls' = [ (p1,p2) | p1 <- ps, p2 <- ps ] -- The complete graph -prop_span5 dist ps = sum (map dist ls) ~= sum (map dist ls') +prop_span5 dist ps n = spanning dist ps == ls where + n' = abs n + 1 :: Int -- Positive + + scaleUp (x,y) = (x `mulLen` n', y `mulLen` n') + scaleDown (x,y) = (x `divLen` n', y `divLen` n') + + ls = map (scaleDown *** scaleDown) $ spanning dist $ map scaleUp ps + -- Only relative distances matter. + +prop_span6 dist ps = sum (map dist ls) ~= sum (map dist ls') + where a ~= b = abs (a-b) < 0.01 ls = spanning dist ps @@ -320,10 +421,131 @@ quickCheck $ prop_span3 euclidDistance quickCheck $ prop_span4 euclidDistance quickCheck $ prop_span5 euclidDistance + quickCheck $ prop_span6 euclidDistance quickCheck $ prop_span1 rectiDistance quickCheck $ prop_span2 rectiDistance quickCheck $ prop_span3 rectiDistance quickCheck $ prop_span4 rectiDistance quickCheck $ prop_span5 rectiDistance + quickCheck $ prop_span6 rectiDistance + + + +-------------------------------------------------------------------------------- +-- * Bilinear interpolation +-------------------------------------------------------------------------------- + + + +data Table2D i x y q = Table2D + { tableLengthX :: i + , tableLengthY :: i + , tableAxisX :: i -> x + , tableAxisY :: i -> y + , tableValues :: i -> i -> q + } + -- It is assumed that + -- * tableAxisX is defined for all [0 .. tableLengthX-1] + -- * tableAxisY is defined for all [0 .. tableLengthY-1] + -- * tableValues is defined for all [0 .. tableLengthX-1] and + -- [0 .. tableLengthY-1] + -- * tableAxisX and tableAxisY are both >= 2. + + + +nearestPoints :: (Num i, Ord a) => i -> (i -> a) -> a -> ((i,a),(i,a)) +nearestPoints n axis a + | a >= a2 = ((i2,a2), (i1,a1)) + | otherwise = nearest i2 a2 + where + i1 = n-1 + i2 = n-2 + a1 = axis i1 + a2 = axis i2 + + nearest 1 ah = ((0, axis 0), (1,ah)) + nearest ih ah + | a >= al = ((il,al), (ih,ah)) + | otherwise = nearest il al + where + il = ih-1 + al = axis il + + -- axis is assumed to be monotonous, that is, map axis [0 .. n-1] should + -- return a sorted list. + -- If (ip1,ip2) = nearestPoints n axis a then ip1 and ip2 are the two + -- closest surrounding points (and their indices) of a in the axis. If a is + -- outside the range of the axis, the two closest points are returned. + + + +bilinInterpolate1 + :: ( Fractional x + , Fractional y + , Fractional q + , DoubleCast x + , DoubleCast y + , DoubleCast q + ) + => (x,y) -> (x,y) -> (q,q,q,q) -> x -> y -> q + +bilinInterpolate1 (x1,y1) (x2,y2) (f_Q11,f_Q21,f_Q12,f_Q22) x y = dcast $ + ( (toDouble f_Q11 * (x2'-x') * (y2'-y')) + + (toDouble f_Q21 * (x'-x1') * (y2'-y')) + + (toDouble f_Q12 * (x2'-x') * (y'-y1')) + + (toDouble f_Q22 * (x'-x1') * (y'-y1')) + ) + / + ((x2'-x1') * (y2'-y1')) + where + x' = toDouble x + y' = toDouble y + x1' = toDouble x1 + y1' = toDouble y1 + x2' = toDouble x2 + y2' = toDouble y2 + + -- Taken from Wikipedia. + + + +findPoints + :: (Num i, Ord x, Ord y) + => Table2D i x y q -> x -> y -> ((x,y), (x,y), (q,q,q,q)) + +findPoints (Table2D xLen yLen xAxis yAxis vals) x y = + ((x1,y1), (x2,y2), (f_Q11,f_Q21,f_Q12,f_Q22)) + where + ((ix1,x1),(ix2,x2)) = nearestPoints xLen xAxis x + ((iy1,y1),(iy2,y2)) = nearestPoints yLen yAxis y + + f_Q11 = vals ix1 iy1 + f_Q21 = vals ix2 iy1 + f_Q12 = vals ix1 iy2 + f_Q22 = vals ix2 iy2 + + -- Finds the four nearest sorrounding (if possible) points in the table. + -- Returns the coordinates and the values of the points. + + + +bilinInterpolate + :: ( Num i + , Ord x + , Ord y + , Fractional x + , Fractional y + , Fractional q + , DoubleCast x + , DoubleCast y + , DoubleCast q + ) + => Table2D i x y q -> x -> y -> q + +bilinInterpolate table x y = bilinInterpolate1 xy1 xy2 fQs x y + where + (xy1,xy2,fQs) = findPoints table x y + + -- Works even when coordinates are outside the table. diff --git a/Examples/Mult.hs b/Examples/Mult.hs --- a/Examples/Mult.hs +++ b/Examples/Mult.hs @@ -36,7 +36,7 @@ import System.Random import Wired -import Libs.Simple130nm.Wired +import Libs.Nangate45.Wired @@ -198,11 +198,11 @@ type CircBlock = - (Maybe Signal, [Signal]) -> Wired Simple130nm ([Signal], Maybe Signal) + (Maybe Signal, [Signal]) -> Wired Nangate45 ([Signal], Maybe Signal) insert a bs = bs ++ [a] -bus ps = rotate 1 $ space 500 () >> guideE 1 600 ps +bus ps = rotate 1 $ space 200e-9 () >> guide 1 200e-9 ps @@ -210,13 +210,13 @@ c22 (Nothing, ps@(_:_:_)) = do p1:p2:ps' <- bus ps - (s,c) <- flipX $ halfAdd (p1,p2) + (s,c) <- ha_x1 (p1,p2) return (insert s ps', Just c) c22 (Just c, ps@(_:_)) = do ps' <- bus ps let p1:p2:ps'' = insert c ps' - (s,c') <- flipX $ halfAdd (p1,p2) + (s,c') <- ha_x1 (p1,p2) return (insert s ps'', Just c') @@ -225,13 +225,13 @@ c32 (Nothing, ps@(_:_:_:_)) = do p1:p2:p3:ps' <- bus ps - (s,c) <- flipX $ fullAdd (p1,(p2,p3)) + (s,c) <- flipX $ fa_x1 (p1,(p2,p3)) return (insert s ps', Just c) c32 (Just c, ps@(_:_:_)) = do ps' <- bus ps let p1:p2:p3:ps'' = insert c ps' - (s,c') <- flipX $ fullAdd (p1,(p2,p3)) + (s,c') <- flipX $ fa_x1 (p1,(p2,p3)) return (insert s ps'', Just c') @@ -251,19 +251,19 @@ buildColumn :: [Block] -> ([Maybe Signal], [Signal]) - -> Wired Simple130nm ([Signal], [Maybe Signal]) + -> Wired Nangate45 ([Signal], [Maybe Signal]) buildColumn [] (_,ps) = return (ps,[]) buildColumn (b:bs) (c:cs, ps) = do (ps',cs') <- buildColumn bs (cs,ps) - -- unless (b==W) $ space 500 () + -- unless (b==W) $ space 500e-9 () (ss,c') <- circBlock b (c,ps') return (ss, c':cs') -buildArray :: Int -> [[Block]] -> [[Signal]] -> Wired Simple130nm [[Signal]] +buildArray :: Int -> [[Block]] -> [[Signal]] -> Wired Nangate45 [[Signal]] buildArray h bss pss = build bss [] pss where build [] _ _ = return [] @@ -271,28 +271,29 @@ build (bs:bss) cs (ps:pss) = do (ss,cs') <- downwards $ do ps' <- space h' =<< bus ps - (ss,cs') <- space 1000 =<< buildColumn + (ss,cs') <- space 1000e-9 =<< buildColumn (reverse bs) (cs ++ repeat Nothing, ps') ss' <- bus ss return (ss',cs') sss <- build bss cs' pss return (ss:sss) where - h' = icast (h - length (filter (/=W) bs)) * icast rowHeight + r = result (rowHeight :: Res Nangate45 Length) + h' = r `mulLen` (h - length (filter (/=W) bs)) -redArray :: [[Signal]] -> Wired Simple130nm [[Signal]] +redArray :: [[Signal]] -> Wired Nangate45 [[Signal]] redArray pss = rightwards $ buildArray h bss (pss ++ repeat []) where bss = redArrayBlock $ map length pss - h = maximum $ map length bss + h = maximum $ map genericLength bss inp n = sequence - $ [inputList m "" | m <- [1..n]] - ++ [inputList m "" | m <- reverse [1..n-1]] + $ [inputList m | m <- [1..n]] + ++ [inputList m | m <- reverse [1..n-1]] redArrayIO = inp 12 >>= redArray diff --git a/Examples/Sklansky.hs b/Examples/Sklansky.hs --- a/Examples/Sklansky.hs +++ b/Examples/Sklansky.hs @@ -1,29 +1,60 @@ +import Lava.Patterns import Wired -import Libs.Simple130nm.Wired +import Libs.Nangate45.Wired +import Analysis.Timing +import Export.DEF bus = rightwards . mapM bus1 where - bus1 = space 1200 >=> guideE 3 0 >=> space 850 + bus1 = space 402e-9 >=> guide 2 0 >=> space 358e-9 -sklansky op [a] = space 2050 [a] +sklansky op [a] = space 760e-9 [a] sklansky op as = downwards' $ do bus as - (ls',rs') <- rightwards $ ((sklansky op -|- sklansky op) . halveList) as - rs'' <- rightwards $ sequence [op (last ls', r) | r <- rs'] + (ls',rs') <- rightwards $ ((skl -|- skl) . halveList) as + rs'' <- rightwards $ sequence [op (last ls', r) | r <- rs'] bus (ls' ++ rs'') - -- Using downwards' to get alignment towards the right. In the future, this - -- will be done using elastic space instead. + where + skl = sklansky (flipY . op) + -- Using downwards' to get alignment towards the right. +sklanskyCrit op [a] = space 760e-9 [a] +sklanskyCrit op as = downwards' $ do + bus as + (ls',rs') <- rightwards $ ((sklC -|- skl) . halveList) as + rs'' <- rightwards $ sequence [op (last ls', r) | r <- rs'] + label "critical" (last ls') + bus (ls' ++ rs'') + where + sklC = sklanskyCrit (flipY . op) + skl = sklansky (flipY . op) + -- Using downwards' to get alignment towards the right. + +r = result (rowHeight :: Res Nangate45 Length) + sklanskyIO op = downwards . - (bus >=> space 1000 >=> sklansky op >=> space 1000 >=> bus) + ( bus + ->- space r + ->- sklanskyCrit op + ->- space r + ->- bus + ) -test1 = renderWiredWithNets "circ" $ sklanskyIO and2 =<< inputList 28 "in" +test1 = renderWiredWithNets "circ" $ sklanskyIO and2_x2 =<< inputList 16 -test2 = simulate (stripLayout . sklansky and2) [1,1,1,1,0,1,1,0,1,1] +test2 = simulate (sklansky and2_x2) [1,1,1,1,0,1,1,0,1,1] + +test3 = maximum $ fst $ analyzeTimingW $ sklanskyIO and2_x2 =<< inputList 16 + +test4 = exportDEF "sklansky" $ sklanskyIO and2_x2 =<< inputList 16 + +test5 = lookupTag "critical" $ fanout $ sklanskyIO and2_x2 =<< inputList 16 + +test6 = lookupTag "critical" $ snd $ analyzeTimingW $ sklanskyIO and2_x2 =<< inputList 16 diff --git a/Examples/UsingLava.hs b/Examples/UsingLava.hs --- a/Examples/UsingLava.hs +++ b/Examples/UsingLava.hs @@ -1,5 +1,7 @@ import Lava -import Libs.Simple130nm.Lava +import Lava.Patterns +import Libs.Nangate45.Lava +import Analysis.Timing import qualified Lava2000 as L @@ -9,38 +11,41 @@ -circ1 :: (Signal,Signal) -> Lava Simple130nm Signal -circ1 = and2 ->- inv +circ1 :: (Signal,Signal) -> Lava Nangate45 Signal +circ1 = and2_x1 ->- inv_x1 circ1' (a,b) = do - c <- and2 (a,b) - inv c + c <- and2_x1 (a,b) + inv_x1 c -- Same as circ1. -circ2 = halfAdd ->- and2 ->- inv +circ2 :: (Signal,Signal) -> Lava Nangate45 Signal +circ2 = ha_x1 ->- and2_x1 ->- inv_x1 +circLoop :: Lava Nangate45 Signal circLoop = mdo - a <- label "a" =<< and2 (b,b) - b <- label "b" =<< inv c - c <- label "c" =<< and2 (b,a) + a <- label "a" =<< and2_x1 (b,b) + b <- label "b" =<< inv_x1 c + c <- label "c" =<< and2_x1 (b,a) return b -- Labels are not needed for definition. +circLoop2 :: Lava Nangate45 Signal circLoop2 = runLetT $ do b <- free c <- free - a <- lift $ label "a" =<< and2 (val b, val b) - b' <- lift $ label "b" =<< inv (val c) - c' <- lift $ label "c" =<< and2 (val b, a) + a <- lift $ label "a" =<< and2_x1 (val b, val b) + b' <- lift $ label "b" =<< inv_x1 (val c) + c' <- lift $ label "c" =<< and2_x1 (val b, a) b === b' c === c' return b' -- Alternative definition using logical variables -circInput :: Signal -> Lava Simple130nm Signal +circInput :: Signal -> Lava Nangate45 Signal circInput a = do - b <- input "b" - and2 (a,b) + b <- input + and2_x1 (a,b) @@ -53,7 +58,7 @@ test3 = verify circ2 -- Check that output is always high. -test4 = fst $ depth $ circ1 (low,low) +test4 = fst $ depth $ circ1 =<< input -- Find logcial depth of circ1. test5 = fst $ depth circLoop @@ -71,4 +76,7 @@ test9 = simulate circInput 0 -- Inputs can be defined, but they cause error in simulation. + +test10 = fst $ analyzeTiming $ circ1 =<< input + -- Timing analysis without wires. diff --git a/Examples/UsingWired.hs b/Examples/UsingWired.hs --- a/Examples/UsingWired.hs +++ b/Examples/UsingWired.hs @@ -1,58 +1,53 @@ +import Lava.Patterns import Wired -import Libs.Simple130nm.Wired -import qualified Libs.Simple130nm.Lava as L +import Libs.Nangate45.Wired +import qualified Libs.Nangate45.Lava as L -circ1 = and2 ->- copy .>. and2 ->- copy .>. and2 ->- space 10000 {-nanometers-} - -circ2 = rightwards $ circ1 (low,low) +circ1 = and2_x1 ->- copy .>. and2_x1 ->- copy .>. and2_x1 ->- space 10000e-9 -circ3 = rightwards $ input "in" >>= circ1 +circ2 = rightwards $ circ1 =<< input -circ3' = rightwards $ do - (a,b) <- input "in" +circ3 = rightwards $ do + (a,b) <- input circ1 (a,b) - -- Same as circ3. Note that input can create several inputs in one go. + -- Same as circ2. Note that input can create several inputs in one go. -circ4 = upwards $ input "in" >>= circ1 +circ4 = upwards $ circ1 =<< input circ5 = rightwards - $ input "in" - >>= (rotate 3 . guideE 1 2000 {-nanometers-}) - >>= space 1000 {-nanometers-} + $ input + >>= rotate 1 . guide 1 800e-9 + >>= space 1000e-9 >>= circ1 -- In order to show the primary input nets, this definition has a guide -- followed by some space to the left of circ1. Since the input is a pair of -- signals, there are actually two guides beside each other. Each guide is - -- 2000 units wide, and is located on metal layer 1. By rotating the guides, - -- they get placed downwards instead of rigthwards. + -- 800 nm wide, and is located on metal layer 1. By rotating the guides, they + -- get placed upwards instead of rigthwards. -circ6 = rightwards . (and2 >=> copy .>. L.and2 >=> space 4000) +circ6 = rightwards . (and2_x1 ->- copy .>. L.and2_x1 ->- space 4000e-9) -test1 = simulate (stripLayout . circ1) (1,1) - -- A Wired circuit is easily converted to a Lava circuit. +test1 = simulate circ1 (1,1) + -- A Wired circuit is simulated just like a Lava circuit. test2 = renderWiredWithNets "circ" circ2 -- Draws a picture of the layout to the file circ.ps. The space in circ1 is -- only to make the picture look smaller (it is always scaled to fit on an A4 -- page). Note that the low inputs are connected in a single net. -test3 = renderWiredWithNets "circ" circ3 - -- Here each input is a separate net. Single-point nets are not drawn, so only - -- the intermediate signal is shown. - -test4 = renderWiredWithNets "circ" circ4 +test3 = renderWiredWithNets "circ" circ4 -- Same circuit with upwards placement. -test5 = renderWiredWithNets "circ" $ rotate 1 circ3 +test4 = renderWiredWithNets "circ" $ rotate 1 circ2 -- circ3 rotated 1 step counter-clockwise. Try also flipX and flipY. -test6 = renderWiredWithNets "circ" circ5 +test5 = renderWiredWithNets "circ" circ5 -test7 = renderWiredWithNets "circ" $ circ6 (low,low) +test6 = renderWiredWithNets "circ" $ circ6 =<< input -- Lava gates can be used happily together with Wired gates. They just don't -- show up in the pictures. diff --git a/Export/DEF.hs b/Export/DEF.hs new file mode 100644 --- /dev/null +++ b/Export/DEF.hs @@ -0,0 +1,203 @@ +module Export.DEF + ( exportDEF + ) where + + + +import qualified Data.Map as Map +import qualified Data.Foldable as Fold +import Data.List +import Data.String + +import Data.Hardware.Internal +import Lava.Internal +import Layout.Internal +import Wired.Model + + + +type ComponentDEF = + ( CellId + , Name + , Position + , Orientation + ) + +type NetDEF = + ( Name + -- Net identifier. The actual number is only important for connecting + -- exports. + , [(CellId, Name)] + -- Like Signal type, but referring to cell pin by name and may also + -- refer to inputs. + , [(Layer_, Position, Position)] + -- Guides + , [Tag] + -- Labels + ) + +type ExportDEF = + ( Name -- Identifier. Can be anything as long as it's unique. + , Name -- Net name + ) + + + +showPos :: Position -> ShowS +showPos (Length x, Length y) = unwordS + [ "(" + , shows x + , shows y + , ")" + ] + -- XXX Numbers should be scaled. + +showOri :: IsString str => Orientation -> str +showOri (flipped,dir) = fromString $ + (if flipped then "F" else "") ++ showDir dir + where + showDir Rightwards = "E" + showDir Leftwards = "W" + showDir Upwards = "N" + showDir Downwards = "S" + + + +top title (x,y) = + "VERSION 5.5 ; \n\ + \NAMESCASESENSITIVE ON ; \n\ + \DIVIDERCHAR \"/\" ; \n\ + \BUSBITCHARS \"[]\" ; \n\ + \DESIGN " .+ title .+ " ; \n\ + \DIEAREA ( 0 0 ) " .+ showPos topRight .+ " ; \n\ + \UNITS DISTANCE MICRONS 1000 ; \n\ + \ \n" + where + topRight = (addLen x (x`divLen`5), addLen y (y`divLen`5)) + -- Add 20%. + -- XXX Round to grid? + + + +renderDEF + :: [ComponentDEF] + -> [NetDEF] + -> [ExportDEF] -- Input exports + -> [ExportDEF] -- Output exports + -> [ExportDEF] -- In/out exports + -> Position -> Name -> IO () + +renderDEF comps nets iExps oExps ioExps topRight title + = writeFile (title ++ ".def") + $ top (showString title) topRight + .+ wrapper "COMPONENTS" (length comps) (map renderComp comps) + .+ wrapper "NETS" (length nets) (map renderNet nets) + .+ wrapper "PINS" lExps renderExports + $ "END DESIGN\n" + where + wrapper kind n lines = unlineS + $ [kind .+ " " .+ shows n .+ " ;"] + ++ lines + ++ ["END " .+ kind .+ "\n\n"] + + renderComp (nid, nm, pos, ori) = unwordS + [ "- CELL" .+ shows (toInt nid) + , showString nm + , "+ PLACED" + , showPos pos + , showOri ori .+ " ;" + ] + + renderNet (nm,ps,gs,ts) = unwordS + $ ["- " .+ showString nm] + ++ map renderPin ps + ++ map renderGuide gs + ++ [";"] + ++ tags + where + tags = if null ts then [] else "#" : map showString ts + + renderPin (nid,cnm) = unwordS + [ "( CELL" .+ shows (toInt nid), showString cnm, ")" ] + + renderGuide (lay,pos1,pos2) + = "+ ROUTED M" + .+ shows (toInt lay) + .+ " " .+ showPos pos1 + .+ if pos1==pos2 + then "" + else " " .+ showPos pos2 + + lExps = length (iExps++oExps++ioExps) + + iExps' = zip iExps (repeat "INPUT") + oExps' = zip oExps (repeat "OUTPUT") + ioExps' = zip ioExps (repeat "INOUT") + + renderExports = map renderExport $ zip [0..] (iExps'++oExps'++ioExps') + + renderExport (p,((pinName,netName),dir)) = unwordS + [ "- " .+ showString pinName + , "+ NET " .+ showString netName + , "+ DIRECTION" + , dir + , ";" + ] + + + +exportDEF + :: (CellLibrary lib, Port p Signal) + => Name -> Wired lib p -> IO () +exportDEF title wp = + renderDEF compsDEF netsDEF iExpsDEF oExpsDEF ioExpsDEF topRight title + where + (p,(db,fp)) = runWired wp + (afp,topRight) = absolutize fp + cellType = fst . (cellDB db Map.!) + + netName (PrimInpSig iid) = "inp" ++ show (toInt iid) + netName (CellSig cid pin) = + "sig" ++ show (toInt cid) ++ "-" ++ show (toInt pin) + + compsDEF = [ (cid,nm,pos,ori) | (pos, Box _ ori nm cid) <- afp ] + + netsDEF = do + (driver,loads) <- Map.toList $ fanoutDB db + let net = mkNet driver loads + gs = totalLookup driver (mkGuideDB fp) + ts = totalLookup driver (sigTagDB db) + return (netName driver, net ,gs, ts) + where + mkNet driver loads + = driverPin + ++ [ (cid, inPinName (cellType cid) pin) | (cid,pin) <- loads ] + where + driverPin = case driver of + PrimInpSig _ -> [] + CellSig cid pin -> [(cid, outPinName (cellType cid) pin)] + + filterInps is = [i | i <- is, not $ null $ totalLookup i $ fanoutDB db] + -- Filter out inputs that are not connected to anything, + + isInput (PrimInpSig _) = True + isInput _ = False + + (ios_,os) = partition isInput $ Fold.toList (port p) + ios = filterInps ios_ + is = filterInps (primIns db) \\ ios + + expName pre n sig + = concat + $ intersperse "_" + $ ((pre++show n):) + $ totalLookup sig + $ sigTagDB db + + listExports typ ss = + [(expName typ n s, netName s) | (n,s) <- [0..] `zip` ss] + + iExpsDEF = listExports "in" is + oExpsDEF = listExports "out" os + ioExpsDEF = listExports "inout" ios + diff --git a/Lava.hs b/Lava.hs --- a/Lava.hs +++ b/Lava.hs @@ -3,10 +3,9 @@ , Signal , CellLibrary , Lava - , MonadLava + , MonadLava (toLava) , InterpDesignDB , lookupTag - , module Lava.Patterns , hasLoop , hasCombLoop , Port @@ -18,6 +17,8 @@ , toLava2000 , simulateSeq , simulate + , encodeBin + , decodeBin , verify , depth , fanout @@ -28,7 +29,5 @@ import Control.Monad -import Data.Hardware -import Lava.Patterns import Lava.Internal diff --git a/Lava/Internal.hs b/Lava/Internal.hs --- a/Lava/Internal.hs +++ b/Lava/Internal.hs @@ -1,152 +1,17 @@ module Lava.Internal ( module Lava.Model - , module Lava.Patterns , module Lava.Loop , module Lava.Port , module Lava.Interpret - , input - , inputList - , cell - , label - , toLava2000 - , simulateSeq - , simulate - , verify - , depth - , fanout - , size + , module Lava.Misc ) where -import Control.Monad -import qualified Data.Foldable as Fold -import qualified Data.Map as Map - import Data.Hardware.Internal import Lava.Model -import Lava.Patterns import Lava.Loop import Lava.Port import Lava.Interpret - -import qualified Lava2000 as L -import qualified Lava2000.Ref as L - - - -input :: forall lib m p . (MonadLava lib m, PortFixed p Signal) => Name -> m p -input nm = liftM fromListFP $ replicateM (lengthFP (T::TypeOf p)) (inputSig nm) - -- Declare a primary input - -inputList :: (MonadLava lib m, PortFixed p Signal) => Int -> Name -> m [p] -inputList n nm = replicateM n $ input nm - - - -cell - :: forall m lib pi po - . ( MonadLava lib m - , PortFixed pi Signal - , PortFixed po Signal - , CellLibrary lib - ) - => lib -> pi -> m po - -cell cid pi = liftM fromListFP $ cellList cid ins - where - ins = Fold.toList $ port pi - -- Declare a cell - - - -label :: (MonadLava lib m, PortStruct p Signal t) => Tag -> p -> m p -label tag = mapPortM (labelSig tag) - -- Declare a label; only side-effect important. - - - -toLava2000 - :: ( CellLibrary lib - , PortStruct pli (L.Signal Bool) ti - , PortStruct psi Signal ti - , PortStruct pso Signal to - , PortStruct plo (L.Signal Bool) to - ) - => (psi -> Lava lib pso) - -> (pli -> plo) - -toLava2000 circ = fst . interpretFunc lava2000Interp circ - - - -simulateSeq - :: ( CellLibrary lib - , PortStruct pni Int ti - , PortStruct psi Signal ti - , PortStruct pso Signal to - , PortStruct pno Int to - ) - => (psi -> Lava lib pso) - -> ([pni] -> [pno]) - -simulateSeq circ - = map (unport . fmap sigToInt) - . L.simulateSeq circP - . map (fmap intToSig . port) - where - circP = fst . interpretFuncP lava2000Interp (liftM port . circ . unport) - - intToSig 0 = L.low - intToSig 1 = L.high - intToSig _ = error "Only values 0 and 1 allowed" - - sigToInt (L.Signal (L.Symbol r)) = case L.deref r of - L.Bool False -> 0 - L.Bool True -> 1 - - - -simulate - :: ( CellLibrary lib - , PortStruct pni Int ti - , PortStruct psi Signal ti - , PortStruct pso Signal to - , PortStruct pno Int to - ) - => (psi -> Lava lib pso) - -> (pni -> pno) - -simulate circ = head . simulateSeq circ . return - - - -verify - :: forall lib ps - . (CellLibrary lib, PortFixed ps Signal) - => (ps -> Lava lib Signal) -> IO () - -verify circ = L.smv (L.forAll (L.list n) circP) >> return () - where - n = lengthFP (T::TypeOf ps) - - circP = toLava2000 (circ . fromListFP) - - - -depth :: (CellLibrary lib, PortStruct ps Signal t, PortStruct pd Int t) => - Lava lib ps -> (pd, InterpDesignDB lib Int) -depth circ - | hasLoopDB True db = error "depth: Combinational feedback loop" - | otherwise = pd_idb - where - pd_idb@(_,(db,_)) = interpret depthInterp circ - -fanout :: CellLibrary lib => Lava lib a -> InterpDesignDB lib Int -fanout circ = (db, fmap length $ fanoutDB db) - where - (_,db) = runLava circ - -size :: CellLibrary lib => Lava lib p -> Int -size = length . Map.toList . cellDB . snd . runLava +import Lava.Misc diff --git a/Lava/Interpret.hs b/Lava/Interpret.hs --- a/Lava/Interpret.hs +++ b/Lava/Interpret.hs @@ -33,7 +33,7 @@ interpretCells interp es cells = snd $ accKnot (accumulator interp) $ do - sequence_ [s*=x | (s,x) <- es'] + sequence_ [s*=x | (s,x) <- es] -- Constrain explicitly interpreted signals. forM_ cells $ \(cid,(ct,ins)) -> do @@ -42,15 +42,24 @@ tellSigs interp sigs $ propagator interp ct vals -- Propagate values across each cell. - where - es' = zip (libraryConstants (T::TypeOf lib)) (constants interp) ++ es - -- Add constants to list of explicitly interpreted signals - -- es is a list of explicit signal interpretations. The signals mentioned in -- this list must be valid according to prop_validSignals. +interpret__ + :: CellLibrary lib + => Interpretation lib x + -> [(Signal, x)] + -> (PortTree Signal, DesignDB lib) + -> (PortTree x, InterpDesignDB lib x) + +interpret__ interp es (ps,db) = (fmap (sigMap Map.!) ps, (db,sigMap)) + where + sigMap = interpretCells interp es (Map.toList $ cellDB db) + + + interpret_ :: CellLibrary lib => Interpretation lib x @@ -58,10 +67,7 @@ -> Lava lib (PortTree Signal) -> (PortTree x, InterpDesignDB lib x) -interpret_ interp es lava = (fmap (sigMap Map.!) ps, (db,sigMap)) - where - (ps,db) = runLava lava - sigMap = interpretCells interp es (Map.toList $ cellDB db) +interpret_ interp es lava = interpret__ interp es (runLava lava) @@ -82,7 +88,7 @@ toSig x = do iid <- get put (pred iid) - return $ PrimInpSig iid + return (PrimInpSig iid) -- Using negative indices to aviod clash with user-defined primary inputs. diff --git a/Lava/Loop.hs b/Lava/Loop.hs --- a/Lava/Loop.hs +++ b/Lava/Loop.hs @@ -80,9 +80,9 @@ -hasLoop :: CellLibrary lib => Lava lib a -> Bool -hasLoop = hasLoopDB False . snd . runLava +hasLoop :: MonadLava lib m => m a -> Bool +hasLoop = hasLoopDB False . snd . runLava . toLava -hasCombLoop :: CellLibrary lib => Lava lib a -> Bool -hasCombLoop = hasLoopDB True . snd . runLava +hasCombLoop :: MonadLava lib m => m a -> Bool +hasCombLoop = hasLoopDB True . snd . runLava . toLava diff --git a/Lava/Misc.hs b/Lava/Misc.hs new file mode 100644 --- /dev/null +++ b/Lava/Misc.hs @@ -0,0 +1,187 @@ +module Lava.Misc where + + + +import Control.Monad +import qualified Data.Foldable as Fold +import qualified Data.Map as Map +import Test.QuickCheck (forAll, choose, quickCheck) + +import Data.Hardware.Internal +import Lava.Model +import Lava.Loop +import Lava.Port +import Lava.Interpret + +import qualified Lava2000 as L +import qualified Lava2000.Ref as L + + + +input :: forall lib m p . (MonadLava lib m, PortFixed p Signal) => m p +input = liftM fromListFP $ replicateM (result (lengthFP::Res p Int)) inputSig + -- Declare a primary input + +inputList :: (MonadLava lib m, PortFixed p Signal) => Int -> m [p] +inputList n = replicateM n input + + + +cell + :: forall m lib pi po + . (MonadLava lib m, PortFixed pi Signal, PortFixed po Signal) + => lib -> pi -> m po + +cell cid pi = liftM fromListFP $ cellList cid ins + where + ins = Fold.toList (port pi) + -- Declare a cell + + + +sourceCell :: (MonadLava lib m, PortFixed p Signal) => lib -> m p +sourceCell cid = liftM fromListFP $ cellList cid [] + -- A cell which has no inputs. + +sinkCell :: (MonadLava lib m, PortFixed p Signal) => lib -> p -> m () +sinkCell cid p = do + cellList cid $ Fold.toList $ port p + return () + -- A cell which has no outputs. + +physCell :: MonadLava lib m => lib -> (a -> m a) +physCell cid a = cellList cid [] >> return a + -- A cell which has neither inputs nor outputs (purely physical). + + + +label :: (MonadLava lib m, PortStruct p Signal t) => Tag -> p -> m p +label = mapPortM . labelSig + -- Declare a label; only side-effect important. + + + +toLava2000 + :: ( MonadLava lib m + , PortStruct pli (L.Signal Bool) ti + , PortStruct psi Signal ti + , PortStruct pso Signal to + , PortStruct plo (L.Signal Bool) to + ) + => (psi -> m pso) -> (pli -> plo) + +toLava2000 circ = fst . interpretFunc lava2000Interp (toLava . circ) + + + +simulateSeq + :: ( MonadLava lib m + , PortStruct pni Int ti + , PortStruct psi Signal ti + , PortStruct pso Signal to + , PortStruct pno Int to + ) + => (psi -> m pso) -> ([pni] -> [pno]) + +simulateSeq circ + = map (unport . fmap sigToInt) + . L.simulateSeq circP + . map (fmap intToSig . port) + where + circP = fst . interpretFuncP lava2000Interp + (liftM port . toLava . circ . unport) + + intToSig 0 = L.low + intToSig 1 = L.high + intToSig _ = error "Only values 0 and 1 allowed" + + sigToInt (L.Signal (L.Symbol r)) = case L.deref r of + L.Bool False -> 0 + L.Bool True -> 1 + + + +simulate + :: ( MonadLava lib m + , PortStruct pni Int ti + , PortStruct psi Signal ti + , PortStruct pso Signal to + , PortStruct pno Int to + ) + => (psi -> m pso) -> (pni -> pno) + +simulate circ = head . simulateSeq circ . return + + + +-- |@encodeBin n x@ +-- +-- Encodes the number @x@ as a binary number of length @n@. The resulting list +-- contains only zeroes and ones. +encodeBin :: Int -> Int -> [Int] +encodeBin n i + | l < n = ie ++ replicate (n-l) 0 + | otherwise = take n ie + where + ie = encode i + l = length ie + + encode i + | i <= 1 = [i] + | otherwise = m : encode d + where + (d,m) = i `divMod` 2 + + + +decodeBin :: [Int] -> Int +decodeBin as = sum [2^x * check a | (a,x) <- as `zip` [0..]] + where + check a + | a `elem` [0,1] = a + | otherwise = error "decodeBin: Not a binary number" + +prop_encodeBin = + forAll (choose (0,10)) $ \n -> + forAll (choose (0,2^11)) $ \i -> + length (encodeBin n i) == n + +prop_encodeDecodeBin = + forAll (choose (0,10)) $ \n -> + forAll (choose (0,2^11)) $ \i -> + decodeBin (encodeBin n i) == (i `mod` 2^n) + +checkAll = do + quickCheck prop_encodeBin + quickCheck prop_encodeDecodeBin + + + +verify + :: forall lib m ps + . (MonadLava lib m, PortFixed ps Signal) + => (ps -> m Signal) -> IO () + +verify circ = L.smv (L.forAll (L.list n) circP) >> return () + where + n = result (lengthFP :: Res ps Int) + circP = toLava2000 (circ . fromListFP) + + + +depth :: (MonadLava lib m, PortStruct ps Signal t, PortStruct pd Int t) => + m ps -> (pd, InterpDesignDB lib Int) +depth circ + | hasLoopDB True db = error "depth: Combinational feedback loop" + | otherwise = pd_idb + where + pd_idb@(_,(db,_)) = interpret depthInterp (toLava circ) + +fanout :: MonadLava lib m => m a -> InterpDesignDB lib Int +fanout circ = (db, fmap length $ fanoutDB db) + where + (_,db) = runLava (toLava circ) + +size :: MonadLava lib m => m p -> Int +size = length . Map.toList . cellDB . snd . runLava . toLava + diff --git a/Lava/Model.hs b/Lava/Model.hs --- a/Lava/Model.hs +++ b/Lava/Model.hs @@ -4,8 +4,10 @@ +import Control.Arrow ((***)) import Control.Monad.Writer import Control.Monad.State +import Data.Char import Data.List as List import Data.Map (Map) import qualified Data.Map as Map @@ -16,46 +18,48 @@ +-- | Identifies a driver in the circuit. A driver is either a primary input or +-- an output pin of a cell. data Signal - = Constant ConstId - | PrimInpSig PrimInpId - | CellSig CellId Pin - -- The pins of a cell are numbered consequtively from 0, starting - -- with the outputs. + = PrimInpSig PrimInpId + | CellSig CellId OutPin deriving (Eq, Show, Ord) data Declaration lib - = PrimInput PrimInpId Name + = PrimInput PrimInpId | Cell CellId lib [Signal] | Label Tag Signal deriving (Eq, Show) data DesignDB lib = DesignDB - { inputDB :: Map PrimInpId Name - , cellDB :: Map CellId (lib,[Signal]) - , fanoutDB :: Map Signal [Signal] - , tagDB :: Map Tag [Signal] + { cellDB :: Map CellId (lib,[Signal]) + , fanoutDB :: Map Signal [(CellId,InPin)] + , sigTagDB :: Map Signal [Tag] + , tagSigDB :: Map Tag [Signal] + , primIns :: [Signal] } deriving (Eq, Show) - -- fanoutDB and tagDB need only be defined if the value is non-empty. Use - -- together with totalLookup. A database is valid if the corresponding list - -- of declarations is (*** it should be possible to reconstruct a list of - -- declarations from a database to make this well-defined). + -- sigTagDB and tagSigDB need only be defined for non-empty values. Use + -- together with totalLookup. fanoutDB should be defined for all signals (even + -- ones with no fanout), so that it can be used to list all signals. A + -- database is valid if the corresponding list of declarations is (*** it + -- should be possible to reconstruct a list of declarations from a database to + -- make this well-defined). class CellLibrary lib where - numConsts :: TypeOf lib -> ConstId - -- Only used for specifying valid circuits (see prop_validDecls). - - numIns :: lib -> Int - numOuts :: lib -> Int + numIns :: lib -> InPin + numOuts :: lib -> OutPin -- Number of inputs/outputs of the given cell - pinName :: lib -> Pin -> Name - pinId :: lib -> Name -> Pin + inPinName :: lib -> InPin -> Name + inPinId :: lib -> Name -> InPin + outPinName :: lib -> OutPin -> Name + outPinId :: lib -> Name -> OutPin + isFlop :: lib -> Bool -- Tells whether or not the given cell is a flipflop. @@ -63,11 +67,11 @@ -- Requirements: -- - -- * The range of numConsts, numIns and numOuts is a subset of [0..] - -- - -- * The domain of (pinName c) is [0 .. numOuts c + numIns c - 1] + -- * The domain of (inPinName c) is [0 .. numIns c - 1] + -- * The domain of (outPinName c) is [0 .. numOuts c - 1] -- - -- * (pinName c) is one-to-one, and its inverse is (pinId c). + -- * (inPinName c) is one-to-one, and its inverse is (inPinId c). + -- * (outPinName c) is one-to-one, and its inverse is (outPinId c). -- -- * lava2000Interp is a valid interpretation (see definition of -- Interpretation). Moreover, the propagator method should constrain all @@ -75,23 +79,17 @@ -libraryConstants :: CellLibrary lib => TypeOf lib -> [Signal] -libraryConstants t = map Constant [0 .. numConsts t-1] - -cellInputs :: CellLibrary lib => CellId -> lib -> [Signal] -cellInputs cid ct = map (CellSig cid) [no .. no+ni] - where - no = icast (numOuts ct) - ni = icast (numIns ct) +cellInputs :: CellLibrary lib => CellId -> lib -> [(CellId,InPin)] +cellInputs cid ct = zip (repeat cid) [0 .. numIns ct-1] cellOutputs :: CellLibrary lib => CellId -> lib -> [Signal] -cellOutputs cid ct = map (CellSig cid) [0 .. icast (numOuts ct) - 1] +cellOutputs cid ct = map (CellSig cid) [0 .. numOuts ct-1] prop_uniquePrimInputs decls = iids == nub iids where - iids = [iid | PrimInput iid _ <- decls] + iids = [iid | PrimInput iid <- decls] -- Each PrimInput has a uniqe PrimInpId. prop_uniqueCells decls = cids == nub cids @@ -100,17 +98,17 @@ -- Each Cell has a uniqe CellId. prop_correctCellInputs decls = - and [numIns ct == length ss | Cell _ ct ss <- decls] + and [numIns ct == genericLength ss | Cell _ ct ss <- decls] -- Each Cell has the correct number of inputs. -prop_validSignals :: forall lib . CellLibrary lib => [Declaration lib] -> Bool +prop_validSignals :: CellLibrary lib => [Declaration lib] -> Bool prop_validSignals decls = all (`elem` validSigs) referred where - primInps = [PrimInpSig iid | PrimInput iid _ <- decls] + primInps = [PrimInpSig iid | PrimInput iid <- decls] cellOuts = [s | Cell cid ct _ <- decls, s <- cellOutputs cid ct] - validSigs = libraryConstants (T::TypeOf lib) ++ primInps ++ cellOuts + validSigs = primInps ++ cellOuts referred = concat [ss | Cell _ _ ss <- decls] @@ -118,9 +116,7 @@ -- All signals referred to in the declarations -- Checks that all signals referred to by a Cell or Label are valid. The valid - -- signals are the constants defined by the library, the declared primary - -- inputs and the *outputs* of declared cells. It is not allowed to refer to - -- cell inputs. + -- signals are the declared primary inputs and the outputs of declared cells. @@ -137,7 +133,7 @@ -- -- The properties should be fulfilled as long as the requirements of the -- CellLibrary class are met and all signals are created using the methods: - -- libraryConstants, input, cell, and label. + -- input, cell and label. -- -- The only thing that can go wrong is if the number of inputs/outputs -- demanded by the type of a cell is different from what is specified by @@ -155,21 +151,26 @@ runLava :: CellLibrary lib => Lava lib a -> (a, DesignDB lib) -runLava (Lava lava) = (a, makeDesignDB decls) +runLava (Lava lava) = (a, DesignDB cDB fDB stDB tsDB ins) where ((a,decls),_) = runState (runWriterT lava) (0,0) - fanouts decls = Map.fromListWith (++) $ concat - [ zip ins (map return $ cellInputs cid ct) | Cell cid ct ins <- decls ] + cDB = Map.fromList [ (cid,(ct,ins)) | Cell cid ct ins <- decls ] + stDB = fmap nub $ Map.fromListWith (++) [ (s,[t]) | Label t s <- decls ] + tsDB = fmap nub $ Map.fromListWith (++) [ (t,[s]) | Label t s <- decls ] - makeDesignDB decls = DesignDB iDB cDB (fanouts decls) tDB - where - iDB = Map.fromList [(iid,nm) | PrimInput iid nm <- decls] - cDB = Map.fromList [(cid,(ct,ins)) | Cell cid ct ins <- decls] - tDB = Map.fromListWith (++) [(tag,[sig]) | Label tag sig <- decls] + fDB = Map.fromListWith (++) $ concat + [ zip ins (map return $ cellInputs cid ct) + ++ + zip (cellOutputs cid ct) (repeat []) + -- Just to make all outputs appear in the map. + | Cell cid ct ins <- decls + ] + ins = [PrimInpSig iid | PrimInput iid <- decls] + class (Monad m, CellLibrary lib) => MonadLava lib m | m -> lib where newPrimInpId :: m PrimInpId @@ -179,6 +180,8 @@ listenDecls :: m a -> m (a, [Declaration lib]) + toLava :: m a -> Lava lib a + instance CellLibrary lib => MonadLava lib (Lava lib) where newPrimInpId = Lava $ do @@ -195,12 +198,14 @@ listenDecls = Lava . listen . unLava + toLava = id -inputSig :: MonadLava lib m => Name -> m Signal -inputSig nm = do + +inputSig :: MonadLava lib m => m Signal +inputSig = do iid <- newPrimInpId - declare $ PrimInput iid nm + declare (PrimInput iid) return (PrimInpSig iid) -- Declare a primary input @@ -212,26 +217,28 @@ -- Declare a cell labelSig :: MonadLava lib m => Tag -> Signal -> m Signal -labelSig tag sig = declare (Label tag sig) >> return sig +labelSig tag sig + | not $ all isAlphaNum tag = error msg + | otherwise = declare (Label tag sig) >> return sig + where + msg = + "label: Only alphanumeric characters allowed\n\ + \Offending label: " ++ tag + -- Declare a label; only side-effect important data Interpretation lib x = Interp - { constants :: [x] - , defaultVal :: x + { defaultVal :: x , accumulator :: x -> x -> x , propagator :: lib -> ([x] -> [Maybe x]) - -- The value of pin p appears at position p in the lists (i.e. - -- outputs first). + -- The lists contain all outputs in pin order and then all inputs in + -- pin order (pin 0 first). } - -- Requirements: - -- - -- * The length of the constant list is (numConsts (T::TypeOf lib)). - -- - -- * The number of elements accepted/returned by the propagator is - -- (numOuts cell + numIns cell). + -- The number of elements accepted/returned by the propagator should be + -- (numOuts cell + numIns cell). @@ -240,20 +247,21 @@ lookupTag :: Tag -> InterpDesignDB lib x -> [x] -lookupTag tag (db,sigMap) = map (sigMap Map.!) (tag `totalLookup` tagDB db) +lookupTag tag (db,sigMap) = map (sigMap Map.!) (tag `totalLookup` tagSigDB db) -depthInterp :: forall lib . CellLibrary lib => Interpretation lib Int +depthInterp :: CellLibrary lib => Interpretation lib Int depthInterp = Interp - { constants = replicate (icast $ numConsts (T::TypeOf lib)) 0 + { defaultVal = 0 -- Inputs , propagator = prop } where prop ct vals - | isFlop ct = replicate no (Just 0) ++ ins - | otherwise = replicate no (Just (d+1)) ++ ins + | isFlop ct = genericReplicate no (Just 0) ++ ins + | otherwise = genericReplicate no (Just (d+1)) ++ ins where ni = numIns ct no = numOuts ct - ins = replicate ni Nothing - d = maximum (drop no vals) + ins = genericReplicate ni Nothing + d = maximum (0 : genericDrop no vals) + -- Cells with no inputs will have depth 0+1. diff --git a/Lava/Port.hs b/Lava/Port.hs --- a/Lava/Port.hs +++ b/Lava/Port.hs @@ -30,7 +30,7 @@ instance Foldable PortTree where foldr f x (One s) = f s x - foldr f x (List ps) = List.foldr (flip $ Fold.foldr f) x ps + foldr f x (List ps) = Fold.foldr (flip $ Fold.foldr f) x ps instance Traversable PortTree where @@ -69,6 +69,22 @@ port = One unport = unOne +instance Port p s => Port (Maybe p) s + where + port (Just p) = List [port p] + port _ = List [] + + unport (List [p]) = Just (unport p) + unport _ = Nothing + +instance (Port p1 s, Port p2 s) => Port (Either p1 p2) s + where + port (Left p) = List [List [port p], List []] + port (Right p) = List [List [], List [port p]] + + unport (List [List [p], List []]) = Left (unport p) + unport (List [List [], List [p]]) = Right (unport p) + instance Port p s => Port [p] s where port = List . map port @@ -98,6 +114,12 @@ instance PortStruct Bool Bool () instance PortStruct Int Int () instance PortStruct (L.Signal Bool) (L.Signal Bool) () + +instance PortStruct p s t => PortStruct (Maybe p) s (Maybe t) + +instance (PortStruct p1 s t1, PortStruct p2 s t2) + => PortStruct (Either p1 p2) s (Either t1 t2) + instance PortStruct p s t => PortStruct [p] s [t] instance (PortStruct p1 s t1, PortStruct p2 s t2) @@ -127,21 +149,21 @@ class Port p s => PortFixed p s | p -> s where - lengthFP :: TypeOf p -> Int + lengthFP :: Res p Int fromListFP :: [s] -> p instance PortFixed Signal Signal where - lengthFP = const 1 + lengthFP = R 1 fromListFP [s] = s instance (PortFixed p1 s, PortFixed p2 s) => PortFixed (p1,p2) s where - lengthFP = const $ lengthFP (T::TypeOf p1) + lengthFP (T::TypeOf p2) + lengthFP = R $ result (lengthFP::Res p1 Int) + result (lengthFP::Res p2 Int) fromListFP ss = (fromListFP ss1, fromListFP ss2) where - (ss1,ss2) = splitAt (lengthFP (T::TypeOf p1)) ss + (ss1,ss2) = splitAt (result (lengthFP::Res p1 Int)) ss instance ( PortFixed p1 s , PortFixed p2 s @@ -149,15 +171,15 @@ ) => PortFixed (p1,p2,p3) s where - lengthFP = const - $ lengthFP (T::TypeOf p1) - + lengthFP (T::TypeOf p2) - + lengthFP (T::TypeOf p3) + lengthFP = R + $ result (lengthFP::Res p1 Int) + + result (lengthFP::Res p2 Int) + + result (lengthFP::Res p3 Int) fromListFP ss = (fromListFP ss1, fromListFP ss2, fromListFP ss3) where - (ss1,ss23) = splitAt (lengthFP (T::TypeOf p1)) ss - (ss2,ss3) = splitAt (lengthFP (T::TypeOf p2)) ss23 + (ss1,ss23) = splitAt (result (lengthFP::Res p1 Int)) ss + (ss2,ss3) = splitAt (result (lengthFP::Res p2 Int)) ss23 instance ( PortFixed p1 s , PortFixed p2 s @@ -166,18 +188,18 @@ ) => PortFixed (p1,p2,p3,p4) s where - lengthFP = const - $ lengthFP (T::TypeOf p1) - + lengthFP (T::TypeOf p2) - + lengthFP (T::TypeOf p3) - + lengthFP (T::TypeOf p4) + lengthFP = R + $ result (lengthFP::Res p1 Int) + + result (lengthFP::Res p2 Int) + + result (lengthFP::Res p3 Int) + + result (lengthFP::Res p4 Int) fromListFP ss = (fromListFP ss1, fromListFP ss2, fromListFP ss3, fromListFP ss4) where - (ss1,ss234) = splitAt (lengthFP (T::TypeOf p1)) ss - (ss2,ss34) = splitAt (lengthFP (T::TypeOf p2)) ss234 - (ss3,ss4) = splitAt (lengthFP (T::TypeOf p3)) ss34 + (ss1,ss234) = splitAt (result (lengthFP::Res p1 Int)) ss + (ss2,ss34) = splitAt (result (lengthFP::Res p2 Int)) ss234 + (ss3,ss4) = splitAt (result (lengthFP::Res p3 Int)) ss34 diff --git a/Layout.hs b/Layout.hs --- a/Layout.hs +++ b/Layout.hs @@ -3,9 +3,10 @@ , rotate , Layout , LayoutT + , black, white, grey, red, green, blue , renderLayout , renderLayoutT - , MonadLayout (..) + , MonadLayout , space , rightwards , leftwards diff --git a/Layout/Floorplan.hs b/Layout/Floorplan.hs --- a/Layout/Floorplan.hs +++ b/Layout/Floorplan.hs @@ -19,7 +19,7 @@ data Distance = Dist Length -- Absolute distance - -- *** | Fill Elasticity -- Relative distance + -- XXX | Fill Elasticity -- Relative distance deriving (Eq, Show) data Block spaceSize s b @@ -94,7 +94,7 @@ rotate_ n (Box wh@(w,h) ori nm b) = Box wh' (rotate_ n ori) nm b where - wh' = if even n then wh else (icast h, icast w) + wh' = if even n then wh else (h,w) rotate_ n bl = bl @@ -145,26 +145,27 @@ absolutizeBlock :: Placement -> RelBlock s b -> (AbsBlock s b, Size) absolutizeBlock _ (Box sz ori nm b) = (Box sz ori nm b, sz) - -- *** Could use unsafeCoerce to avoid reconstruction. + -- XXX Could use unsafeCoerce to avoid reconstruction. absolutizeBlock (Row dir _) (Space (Dist d) ms) = case ang of - Horizontal -> (Space (ang,d) ms, (icast d, 0)) - Vertical -> (Space (ang,d) ms, (0, icast d)) + Horizontal -> (Space (ang,d) ms, (d,Length 0)) + Vertical -> (Space (ang,d) ms, (Length 0,d)) where ang = directionAngle dir -absolutizeBlock _ (Space _ ms) = (Space (Horizontal,0) ms, (0,0)) +absolutizeBlock _ (Space _ ms) = + (Space (Horizontal, Length 0) ms, (Length 0, Length 0)) -align :: Integral i => Alignment -> i -> i -> i -align BottomLeft _ _ = 0 -align _ smaller larger = larger - smaller +align :: Alignment -> Length -> Length -> Length +align BottomLeft _ _ = Length 0 +align _ smaller larger = larger `subLen` smaller translateBlocks :: Position -> AbsFloorplan s b -> AbsFloorplan s b translateBlocks (x,y) = map (transP *** id) where - transP (x',y') = (x'+x,y'+y) + transP (x',y') = (x'`addLen`x, y'`addLen`y) @@ -188,38 +189,38 @@ absolutize_ pl pos (Comb (Row Downwards al) fps) = absolutize_ pl pos $ Comb (Row Upwards al) $ reverse fps -absolutize_ _ _ (Comb _ []) = return (0,0) +absolutize_ _ _ (Comb _ []) = return (Length 0, Length 0) absolutize_ pl (x,y) (Comb pl'@(Row Rightwards al) (fp:fps)) | h1 < h2 = do - tell $ translateBlocks (0, align al h1 h2) afp1 + tell $ translateBlocks (Length 0, align al h1 h2) afp1 tell afp2 - return (w1+w2, h2) + return (w1`addLen`w2, h2) | otherwise = do tell afp1 - tell $ translateBlocks (0, align al h2 h1) afp2 - return (w1+w2, h1) + tell $ translateBlocks (Length 0, align al h2 h1) afp2 + return (w1`addLen`w2, h1) where ((w1,h1),afp1) = runWriter $ absolutize_ pl' (x,y) fp - ((w2,h2),afp2) = runWriter $ absolutize_ pl (x+w1, y) (Comb pl' fps) + ((w2,h2),afp2) = runWriter $ absolutize_ pl (x`addLen`w1, y) (Comb pl' fps) absolutize_ pl (x,y) (Comb pl'@(Row Upwards al) (fp:fps)) | w1 < w2 = do - tell $ translateBlocks (align al w1 w2, 0) afp1 + tell $ translateBlocks (align al w1 w2, Length 0) afp1 tell afp2 - return (w2, h1+h2) + return (w2, h1`addLen`h2) | otherwise = do tell afp1 - tell $ translateBlocks (align al w2 w1, 0) afp2 - return (w1, h1+h2) + tell $ translateBlocks (align al w2 w1, Length 0) afp2 + return (w1, h1`addLen`h2) where ((w1,h1),afp1) = runWriter $ absolutize_ pl' (x,y) fp - ((w2,h2),afp2) = runWriter $ absolutize_ pl (x, y+h1) (Comb pl' fps) + ((w2,h2),afp2) = runWriter $ absolutize_ pl (x, y`addLen`h1) (Comb pl' fps) absolutize_ pl (x,y) (Comb pl'@(Stack alx aly) (fp:fps)) = case (compare w1 w2, compare h1 h2) of @@ -235,13 +236,13 @@ return (w1,h1) (LT,_) -> do - tell $ translateBlocks (align alx w1 w2, 0) afp1 - tell $ translateBlocks (0, align aly h2 h1) afp2 + tell $ translateBlocks (align alx w1 w2, Length 0) afp1 + tell $ translateBlocks (Length 0, align aly h2 h1) afp2 return (w2,h1) _ -> do - tell $ translateBlocks (0, align aly h1 h2) afp1 - tell $ translateBlocks (align alx w2 w1, 0) afp2 + tell $ translateBlocks (Length 0, align aly h1 h2) afp1 + tell $ translateBlocks (align alx w2 w1, Length 0) afp2 return (w1,h2) where @@ -249,27 +250,18 @@ ((w2,h2),afp2) = runWriter $ absolutize_ pl (x,y) (Comb pl' fps) absolutize_ pl pos fp@(Comb Unspecified fps) = return rt - -- *** Should do something more... + -- XXX Should do something more... where - areaFP fp = icast x * icast y :: Int - where - (x,y) = fst $ runWriter $ absolutize_ pl pos fp + areaFP fp = uncurry mulLen2 $ fst $ runWriter $ absolutize_ pl pos fp totArea = sum $ map areaFP fps - - side :: Int - side = fromInteger - $ round - $ sqrt - $ fromIntegral - $ totArea - - rt = (icast side, icast side) + side = Length $ round $ sqrt $ toDouble totArea + rt = (side,side) -- The Placement argument is the placement of the node immediately above the -- current one. It is only used for blocks. - -- *** The same block may be translated over and over again. If the size of + -- XXX The same block may be translated over and over again. If the size of -- each sub-floorplan was known in advance, this could be avioded (by -- adjusting the position argument to absolutize_ for alignment). @@ -278,10 +270,11 @@ absolutize :: Floorplan s b -> (AbsFloorplan s b, Size) absolutize fp = (afp,topRight) where - (topRight,afp) = runWriter $ absolutize_ Unspecified (0,0) fp + (topRight,afp) = runWriter $ absolutize_ Unspecified (Length 0, Length 0) fp blockCenter :: (Position, AbsBlock s b) -> Position -blockCenter ((x,y), Space (Horizontal,len) _) = (x + icast len`div`2, y) -blockCenter ((x,y), Space (Vertical, len) _) = (x, y + icast len`div`2) -blockCenter ((x,y), Box (w,h) _ _ _) = (x + w`div`2, y + h`div`2) +blockCenter ((x,y), Space (Horizontal,len) _) = (addLen x (len`divLen`2), y) +blockCenter ((x,y), Space (Vertical, len) _) = (x, addLen y (len`divLen`2)) +blockCenter ((x,y), Box (w,h) _ _ _) = + (addLen x (w`divLen`2), addLen y (h`divLen`2)) diff --git a/Layout/Internal.hs b/Layout/Internal.hs --- a/Layout/Internal.hs +++ b/Layout/Internal.hs @@ -54,13 +54,13 @@ (a,fps) <- runWriterT $ flip runReaderT Unspecified m return (a, Comb Unspecified fps) -renderLayout :: String -> Layout s b a -> IO () +renderLayout :: Name -> Layout s b a -> IO () renderLayout title = renderFloorplan title . snd . runLayout renderLayoutT :: Monad m => (forall a . m a -> a) - -> String -> LayoutT s b m a -> IO () + -> Name -> LayoutT s b m a -> IO () renderLayoutT runner title = renderFloorplan title . snd . runner . runLayoutT @@ -74,7 +74,8 @@ space__ :: MonadWriter [Floorplan s b] m => Length -> Maybe s -> m () space__ len ms = tell [Block $ Space (Dist len) ms] -block__ :: MonadWriter [Floorplan s b] m => Width -> Height -> Name -> b -> m () +block__ + :: MonadWriter [Floorplan s b] m => Width -> Height -> Name -> b -> m () block__ x y nm b = tell [Block $ Box (x,y) north nm b] subLayout_ @@ -146,7 +147,6 @@ leftwards' = subLayout (Row Leftwards TopRight) upwards' = subLayout (Row Upwards TopRight) downwards' = subLayout (Row Downwards TopRight) - -- *** These will not be needed when elastic space has been implemented. unplaced :: MonadLayout s b m => m a -> m a unplaced = subLayout Unspecified @@ -154,13 +154,13 @@ stacked :: MonadLayout s b m => m a -> m a stacked = subLayout (Stack BottomLeft BottomLeft) -translate :: MonadLayout s bl m => Width -> Height -> m a -> m a +translate :: MonadLayout s bl m => XPos -> YPos -> m a -> m a translate x y ma = do pl <- currentPlacement rightwards $ do - space_ (icast x) Nothing + space_ x Nothing upwards $ do - space_ (icast y) Nothing + space_ y Nothing subLayout pl ma diff --git a/Layout/Postscript.hs b/Layout/Postscript.hs --- a/Layout/Postscript.hs +++ b/Layout/Postscript.hs @@ -2,31 +2,38 @@ -import Data.String - import Data.Hardware.Internal import Layout.Floorplan -type Postscript = ShowS +type Color = (Float, Float, Float) + -- (R,G,B), each number between 0 and 1. +black, white, grey, red, green, blue :: Color +black = (0,0,0) +white = (1,1,1) +grey = (0.5,0.5,0.5) +red = (1,0,0) +green = (0,1,0) +blue = (0,0,1) + + +type Postscript = ShowS + class Show a => PSShow a where psShow :: a -> Postscript -instance PSShow Int +instance PSShow Length where - psShow n = shows n + psShow = shows . unLength -instance (IsString a, Show a) => PSShow a +instance PSShow String where - psShow a = "(" .+ shows a .+ ")" - -deriving instance PSShow Width -deriving instance PSShow Height + psShow a = "(" .+ showString a .+ ")" instance PSShow Orientation where @@ -50,7 +57,7 @@ absPS _ = id blockLine (x,y) (w,h) ori nm - | w * icast h > 0 = unwordS + | min w h > Length 0 = unwordS [ psShow x , psShow y , psShow w @@ -60,8 +67,10 @@ , "block\n" ] + | otherwise = "" + floorplanToPS :: Floorplan s b -> (Postscript, Size) floorplanToPS fp = (absToPS afp, sz) where @@ -69,22 +78,29 @@ -linesToPS :: [(Position,Position)] -> Postscript -linesToPS [] = id -linesToPS (line:lines) - = unwordS - [ psShow x1, psShow y1 - , psShow x2, psShow y2 - , "wire\n" - ] - .+ linesToPS lines +linesToPS :: [([(Position,Position)], Color)] -> Postscript +linesToPS lcs = unlineS [toPS col lines | (lines,col) <- lcs] where - ((x1,y1),(x2,y2)) = line + toPS _ [] = "" + toPS col@(r,g,b) (line:lines) + = unwordS + [ psShow x1, psShow y1 + , psShow x2, psShow y2 + , "{" .+ unwordS (map shows [r,g,b]) .+ "}" + , "wire\n" + ] + .+ toPS col lines + where + ((x1,y1),(x2,y2)) = line renderFloorplan_ - :: Int -> String -> Floorplan s b -> [(Position,Position)] -> IO () + :: Length + -> Name + -> Floorplan s b + -> [([(Position,Position)], Color)] + -> IO () renderFloorplan_ lnScale title fp lines = writeFile (title ++ ".ps") $ "%!PS-Adobe-1.0\n" @@ -96,22 +112,24 @@ .+ ps3 .+ ps -- .+ "\nshowpage\n" - -- *** This should make a first page without wires, but it doesn't seem to + -- XXX This should make a first page without wires, but it doesn't seem to -- work. .+ "\nwireWidth setlinewidth\n\n" .+ linesToPS lines - $ "\nshowpage\n" + $ "showpage\n" where (ps,sz) = floorplanToPS fp lnScLine - = shows lnScale - .+ showString (replicate (6 - length (show lnScale)) ' ') + = lnsc + .+ showString (replicate (6 - length (lnsc "")) ' ') .+ "% Scale for lines and names\n" + where + lnsc = psShow lnScale setPicSize (x,y) = unlineS - [ "/picW " .+ shows (toInt x) .+ " def" - , "/picH " .+ shows (toInt y) .+ " def" + [ "/picW " .+ psShow x .+ " def" + , "/picH " .+ psShow y .+ " def" , " % Width/heigth of picture (in floorplan units)" , "" ] @@ -120,8 +138,8 @@ -renderFloorplan :: String -> Floorplan s b -> IO () -renderFloorplan title fp = renderFloorplan_ 1 title fp [] +renderFloorplan :: Name -> Floorplan s b -> IO () +renderFloorplan title fp = renderFloorplan_ (Length 1) title fp [] @@ -371,14 +389,16 @@ \} def \n\ \ \n\ \/wire { \n\ - \ 4 dict begin \n\ - \ /y2 exch def \n\ - \ /x2 exch def \n\ - \ /y1 exch def \n\ - \ /x1 exch def \n\ + \ 5 dict begin \n\ + \ /col exch def \n\ + \ /y2 exch def \n\ + \ /x2 exch def \n\ + \ /y1 exch def \n\ + \ /x1 exch def \n\ \ \n\ \ gsave \n\ \ newpath \n\ + \ col setrgbcolor \n\ \ x1 y1 moveto \n\ \ x2 y2 lineto \n\ \ closepath \n\ diff --git a/Libs/Nangate45/LICENSE.hs b/Libs/Nangate45/LICENSE.hs new file mode 100644 --- /dev/null +++ b/Libs/Nangate45/LICENSE.hs @@ -0,0 +1,44 @@ +-- | +-- > The Open Cell Library is intended for use by universities, other research +-- > activities, educational programs and Si2.org members. +-- > However allowed, the Open Cell Library is not intended for commercial use. +-- > If you use the Open Cell Library for demonstration of commercial EDA tools +-- > it is required to mention, indicate that the library was developped by +-- > Nangate. +-- > +-- > If you have questions or concerns then please contact us at +-- > openlibrary@nangate.com +-- > +-- > The Open Cell Library is provided by Nangate under the following License: +-- > +-- > Nangate Open Cell Library License, Version 1.0. February 20, 2008 +-- > +-- > Permission is hereby granted, free of charge, to any person or organization +-- > obtaining a copy of the Open Cell Library and accompanying documentation +-- > (the "Library") covered by this license to use, reproduce, display, +-- > distribute, execute, and transmit the Library, and to prepare derivative +-- > works of the Library, and to permit third-parties to whom the Library is +-- > furnished to do so, all subject to the following: +-- > +-- > The copyright notices in the Library and this entire statement, including +-- > the above license grant, this restriction and the following disclaimer, +-- > must be included in all copies of the Library, in whole or in part, and all +-- > derivative works of the Library, unless such copies or derivative works are +-- > solely in the form of machine-executable object code generated by a source +-- > language processor. The library has been generated using a non-optimized +-- > open PDK and is not suited for any commercial purpose. Measuring or +-- > benchmarking the Library against any other library or standard cell set is +-- > prohibited. Any meaningful library benchmarking must be done in +-- > collaboration with Nangate or other providers of optimized and +-- > production-ready PDKs. +-- > +-- > THE LIBRARY IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +-- > IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +-- > FITNESS FOR A PARTICULAR PURPOSE, TITLE AND NON-INFRINGEMENT. IN NO EVENT +-- > SHALL THE COPYRIGHT HOLDERS OR ANYONE DISTRIBUTING THE LIBRARY BE LIABLE +-- > FOR ANY DAMAGES OR OTHER LIABILITY, WHETHER IN CONTRACT, TORT OR OTHERWISE, +-- > ARISING FROM, OUT OF OR IN CONNECTION WITH THE LIBRARY OR THE USE OR OTHER +-- > DEALINGS IN THE LIBRARY. + +module Libs.Nangate45.LICENSE where + diff --git a/Libs/Nangate45/Lava.hs b/Libs/Nangate45/Lava.hs new file mode 100644 --- /dev/null +++ b/Libs/Nangate45/Lava.hs @@ -0,0 +1,894 @@ +{-# OPTIONS_GHC -fno-warn-missing-fields #-} + +-- | +-- Copyright : Copyright (c) 2008, Emil Axelsson +-- License : BSD3 +-- Maintainer : Emil Axelsson +-- Stability : experimental +-- +-- Lava interface to the Nangate45 library. +-- +-- The data in this file is derived from Nangate's Open Cell Library, +-- and is subject to the license restrictions stated in +-- "Libs.Nangate45.LICENSE". +module Libs.Nangate45.Lava + ( + -- * Library type + Nangate45 + + -- * Cells + , and2_x1 + , and2_x2 + , and2_x4 + , buf_x1 + , buf_x16 + , buf_x2 + , buf_x32 + , buf_x4 + , buf_x8 + , fa_x1 + , fillcell_x1 + , fillcell_x16 + , fillcell_x2 + , fillcell_x32 + , fillcell_x4 + , fillcell_x8 + , ha_x1 + , inv_x1 + , inv_x16 + , inv_x2 + , inv_x32 + , inv_x4 + , inv_x8 + , logic0_x1 + , logic1_x1 + , nand2_x1 + , nand2_x2 + , nand2_x4 + , nor2_x1 + , nor2_x2 + , nor2_x4 + , or2_x1 + , or2_x2 + , or2_x4 + , xnor2_x1 + , xnor2_x2 + , xor2_x1 + , xor2_x2 + ) where + +import Data.Hardware.Internal +import Lava.Internal +import Lava +import Analysis.Timing.Library +import Libs.Nangate45.Timing + +import qualified Lava2000 as L +import qualified Lava2000.Arithmetic as L + +data Nangate45 = AND2_X1 | AND2_X2 | AND2_X4 | BUF_X1 | BUF_X16 | BUF_X2 | BUF_X32 | BUF_X4 | BUF_X8 | FA_X1 | FILLCELL_X1 | FILLCELL_X16 | FILLCELL_X2 | FILLCELL_X32 | FILLCELL_X4 | FILLCELL_X8 | HA_X1 | INV_X1 | INV_X16 | INV_X2 | INV_X32 | INV_X4 | INV_X8 | LOGIC0_X1 | LOGIC1_X1 | NAND2_X1 | NAND2_X2 | NAND2_X4 | NOR2_X1 | NOR2_X2 | NOR2_X4 | OR2_X1 | OR2_X2 | OR2_X4 | XNOR2_X1 | XNOR2_X2 | XOR2_X1 | XOR2_X2 + deriving (Eq, Show) + +instance CellLibrary Nangate45 + where + numIns AND2_X1 = 2 + numIns AND2_X2 = 2 + numIns AND2_X4 = 2 + numIns BUF_X1 = 1 + numIns BUF_X16 = 1 + numIns BUF_X2 = 1 + numIns BUF_X32 = 1 + numIns BUF_X4 = 1 + numIns BUF_X8 = 1 + numIns FA_X1 = 3 + numIns FILLCELL_X1 = 0 + numIns FILLCELL_X16 = 0 + numIns FILLCELL_X2 = 0 + numIns FILLCELL_X32 = 0 + numIns FILLCELL_X4 = 0 + numIns FILLCELL_X8 = 0 + numIns HA_X1 = 2 + numIns INV_X1 = 1 + numIns INV_X16 = 1 + numIns INV_X2 = 1 + numIns INV_X32 = 1 + numIns INV_X4 = 1 + numIns INV_X8 = 1 + numIns LOGIC0_X1 = 0 + numIns LOGIC1_X1 = 0 + numIns NAND2_X1 = 2 + numIns NAND2_X2 = 2 + numIns NAND2_X4 = 2 + numIns NOR2_X1 = 2 + numIns NOR2_X2 = 2 + numIns NOR2_X4 = 2 + numIns OR2_X1 = 2 + numIns OR2_X2 = 2 + numIns OR2_X4 = 2 + numIns XNOR2_X1 = 2 + numIns XNOR2_X2 = 2 + numIns XOR2_X1 = 2 + numIns XOR2_X2 = 2 + + numOuts AND2_X1 = 1 + numOuts AND2_X2 = 1 + numOuts AND2_X4 = 1 + numOuts BUF_X1 = 1 + numOuts BUF_X16 = 1 + numOuts BUF_X2 = 1 + numOuts BUF_X32 = 1 + numOuts BUF_X4 = 1 + numOuts BUF_X8 = 1 + numOuts FA_X1 = 2 + numOuts FILLCELL_X1 = 0 + numOuts FILLCELL_X16 = 0 + numOuts FILLCELL_X2 = 0 + numOuts FILLCELL_X32 = 0 + numOuts FILLCELL_X4 = 0 + numOuts FILLCELL_X8 = 0 + numOuts HA_X1 = 2 + numOuts INV_X1 = 1 + numOuts INV_X16 = 1 + numOuts INV_X2 = 1 + numOuts INV_X32 = 1 + numOuts INV_X4 = 1 + numOuts INV_X8 = 1 + numOuts LOGIC0_X1 = 1 + numOuts LOGIC1_X1 = 1 + numOuts NAND2_X1 = 1 + numOuts NAND2_X2 = 1 + numOuts NAND2_X4 = 1 + numOuts NOR2_X1 = 1 + numOuts NOR2_X2 = 1 + numOuts NOR2_X4 = 1 + numOuts OR2_X1 = 1 + numOuts OR2_X2 = 1 + numOuts OR2_X4 = 1 + numOuts XNOR2_X1 = 1 + numOuts XNOR2_X2 = 1 + numOuts XOR2_X1 = 1 + numOuts XOR2_X2 = 1 + + inPinName AND2_X1 0 = "A1" + inPinName AND2_X1 1 = "A2" + inPinName AND2_X2 0 = "A1" + inPinName AND2_X2 1 = "A2" + inPinName AND2_X4 0 = "A1" + inPinName AND2_X4 1 = "A2" + inPinName BUF_X1 0 = "A" + inPinName BUF_X16 0 = "A" + inPinName BUF_X2 0 = "A" + inPinName BUF_X32 0 = "A" + inPinName BUF_X4 0 = "A" + inPinName BUF_X8 0 = "A" + inPinName FA_X1 0 = "CI" + inPinName FA_X1 1 = "A" + inPinName FA_X1 2 = "B" + inPinName HA_X1 0 = "A" + inPinName HA_X1 1 = "B" + inPinName INV_X1 0 = "A" + inPinName INV_X16 0 = "A" + inPinName INV_X2 0 = "A" + inPinName INV_X32 0 = "A" + inPinName INV_X4 0 = "A" + inPinName INV_X8 0 = "A" + inPinName NAND2_X1 0 = "A1" + inPinName NAND2_X1 1 = "A2" + inPinName NAND2_X2 0 = "A1" + inPinName NAND2_X2 1 = "A2" + inPinName NAND2_X4 0 = "A1" + inPinName NAND2_X4 1 = "A2" + inPinName NOR2_X1 0 = "A1" + inPinName NOR2_X1 1 = "A2" + inPinName NOR2_X2 0 = "A1" + inPinName NOR2_X2 1 = "A2" + inPinName NOR2_X4 0 = "A1" + inPinName NOR2_X4 1 = "A2" + inPinName OR2_X1 0 = "A1" + inPinName OR2_X1 1 = "A2" + inPinName OR2_X2 0 = "A1" + inPinName OR2_X2 1 = "A2" + inPinName OR2_X4 0 = "A1" + inPinName OR2_X4 1 = "A2" + inPinName XNOR2_X1 0 = "A" + inPinName XNOR2_X1 1 = "B" + inPinName XNOR2_X2 0 = "A" + inPinName XNOR2_X2 1 = "B" + inPinName XOR2_X1 0 = "A" + inPinName XOR2_X1 1 = "B" + inPinName XOR2_X2 0 = "A" + inPinName XOR2_X2 1 = "B" + + outPinName AND2_X1 0 = "ZN" + outPinName AND2_X2 0 = "ZN" + outPinName AND2_X4 0 = "ZN" + outPinName BUF_X1 0 = "Z" + outPinName BUF_X16 0 = "Z" + outPinName BUF_X2 0 = "Z" + outPinName BUF_X32 0 = "Z" + outPinName BUF_X4 0 = "Z" + outPinName BUF_X8 0 = "Z" + outPinName FA_X1 0 = "S" + outPinName FA_X1 1 = "CO" + outPinName HA_X1 0 = "S" + outPinName HA_X1 1 = "CO" + outPinName INV_X1 0 = "ZN" + outPinName INV_X16 0 = "ZN" + outPinName INV_X2 0 = "ZN" + outPinName INV_X32 0 = "ZN" + outPinName INV_X4 0 = "ZN" + outPinName INV_X8 0 = "ZN" + outPinName LOGIC0_X1 0 = "Z" + outPinName LOGIC1_X1 0 = "Z" + outPinName NAND2_X1 0 = "ZN" + outPinName NAND2_X2 0 = "ZN" + outPinName NAND2_X4 0 = "ZN" + outPinName NOR2_X1 0 = "ZN" + outPinName NOR2_X2 0 = "ZN" + outPinName NOR2_X4 0 = "ZN" + outPinName OR2_X1 0 = "ZN" + outPinName OR2_X2 0 = "ZN" + outPinName OR2_X4 0 = "ZN" + outPinName XNOR2_X1 0 = "ZN" + outPinName XNOR2_X2 0 = "ZN" + outPinName XOR2_X1 0 = "Z" + outPinName XOR2_X2 0 = "Z" + + inPinId AND2_X1 "A1" = 0 + inPinId AND2_X1 "A2" = 1 + inPinId AND2_X2 "A1" = 0 + inPinId AND2_X2 "A2" = 1 + inPinId AND2_X4 "A1" = 0 + inPinId AND2_X4 "A2" = 1 + inPinId BUF_X1 "A" = 0 + inPinId BUF_X16 "A" = 0 + inPinId BUF_X2 "A" = 0 + inPinId BUF_X32 "A" = 0 + inPinId BUF_X4 "A" = 0 + inPinId BUF_X8 "A" = 0 + inPinId FA_X1 "CI" = 0 + inPinId FA_X1 "A" = 1 + inPinId FA_X1 "B" = 2 + inPinId HA_X1 "A" = 0 + inPinId HA_X1 "B" = 1 + inPinId INV_X1 "A" = 0 + inPinId INV_X16 "A" = 0 + inPinId INV_X2 "A" = 0 + inPinId INV_X32 "A" = 0 + inPinId INV_X4 "A" = 0 + inPinId INV_X8 "A" = 0 + inPinId NAND2_X1 "A1" = 0 + inPinId NAND2_X1 "A2" = 1 + inPinId NAND2_X2 "A1" = 0 + inPinId NAND2_X2 "A2" = 1 + inPinId NAND2_X4 "A1" = 0 + inPinId NAND2_X4 "A2" = 1 + inPinId NOR2_X1 "A1" = 0 + inPinId NOR2_X1 "A2" = 1 + inPinId NOR2_X2 "A1" = 0 + inPinId NOR2_X2 "A2" = 1 + inPinId NOR2_X4 "A1" = 0 + inPinId NOR2_X4 "A2" = 1 + inPinId OR2_X1 "A1" = 0 + inPinId OR2_X1 "A2" = 1 + inPinId OR2_X2 "A1" = 0 + inPinId OR2_X2 "A2" = 1 + inPinId OR2_X4 "A1" = 0 + inPinId OR2_X4 "A2" = 1 + inPinId XNOR2_X1 "A" = 0 + inPinId XNOR2_X1 "B" = 1 + inPinId XNOR2_X2 "A" = 0 + inPinId XNOR2_X2 "B" = 1 + inPinId XOR2_X1 "A" = 0 + inPinId XOR2_X1 "B" = 1 + inPinId XOR2_X2 "A" = 0 + inPinId XOR2_X2 "B" = 1 + + outPinId AND2_X1 "ZN" = 0 + outPinId AND2_X2 "ZN" = 0 + outPinId AND2_X4 "ZN" = 0 + outPinId BUF_X1 "Z" = 0 + outPinId BUF_X16 "Z" = 0 + outPinId BUF_X2 "Z" = 0 + outPinId BUF_X32 "Z" = 0 + outPinId BUF_X4 "Z" = 0 + outPinId BUF_X8 "Z" = 0 + outPinId FA_X1 "S" = 0 + outPinId FA_X1 "CO" = 1 + outPinId HA_X1 "S" = 0 + outPinId HA_X1 "CO" = 1 + outPinId INV_X1 "ZN" = 0 + outPinId INV_X16 "ZN" = 0 + outPinId INV_X2 "ZN" = 0 + outPinId INV_X32 "ZN" = 0 + outPinId INV_X4 "ZN" = 0 + outPinId INV_X8 "ZN" = 0 + outPinId LOGIC0_X1 "Z" = 0 + outPinId LOGIC1_X1 "Z" = 0 + outPinId NAND2_X1 "ZN" = 0 + outPinId NAND2_X2 "ZN" = 0 + outPinId NAND2_X4 "ZN" = 0 + outPinId NOR2_X1 "ZN" = 0 + outPinId NOR2_X2 "ZN" = 0 + outPinId NOR2_X4 "ZN" = 0 + outPinId OR2_X1 "ZN" = 0 + outPinId OR2_X2 "ZN" = 0 + outPinId OR2_X4 "ZN" = 0 + outPinId XNOR2_X1 "ZN" = 0 + outPinId XNOR2_X2 "ZN" = 0 + outPinId XOR2_X1 "Z" = 0 + outPinId XOR2_X2 "Z" = 0 + + isFlop AND2_X1 = False + isFlop AND2_X2 = False + isFlop AND2_X4 = False + isFlop BUF_X1 = False + isFlop BUF_X16 = False + isFlop BUF_X2 = False + isFlop BUF_X32 = False + isFlop BUF_X4 = False + isFlop BUF_X8 = False + isFlop FA_X1 = False + isFlop FILLCELL_X1 = False + isFlop FILLCELL_X16 = False + isFlop FILLCELL_X2 = False + isFlop FILLCELL_X32 = False + isFlop FILLCELL_X4 = False + isFlop FILLCELL_X8 = False + isFlop HA_X1 = False + isFlop INV_X1 = False + isFlop INV_X16 = False + isFlop INV_X2 = False + isFlop INV_X32 = False + isFlop INV_X4 = False + isFlop INV_X8 = False + isFlop LOGIC0_X1 = False + isFlop LOGIC1_X1 = False + isFlop NAND2_X1 = False + isFlop NAND2_X2 = False + isFlop NAND2_X4 = False + isFlop NOR2_X1 = False + isFlop NOR2_X2 = False + isFlop NOR2_X4 = False + isFlop OR2_X1 = False + isFlop OR2_X2 = False + isFlop OR2_X4 = False + isFlop XNOR2_X1 = False + isFlop XNOR2_X2 = False + isFlop XOR2_X1 = False + isFlop XOR2_X2 = False + + lava2000Interp = Interp + { defaultVal = error "Undefined signal" + , propagator = prop + } + where + prop AND2_X1 = \[_, iA1, iA2] -> [Just (L.andl [iA1, iA2]), Nothing, Nothing] + prop AND2_X2 = \[_, iA1, iA2] -> [Just (L.andl [iA1, iA2]), Nothing, Nothing] + prop AND2_X4 = \[_, iA1, iA2] -> [Just (L.andl [iA1, iA2]), Nothing, Nothing] + prop BUF_X1 = \[_, iA] -> [Just (iA), Nothing] + prop BUF_X16 = \[_, iA] -> [Just (iA), Nothing] + prop BUF_X2 = \[_, iA] -> [Just (iA), Nothing] + prop BUF_X32 = \[_, iA] -> [Just (iA), Nothing] + prop BUF_X4 = \[_, iA] -> [Just (iA), Nothing] + prop BUF_X8 = \[_, iA] -> [Just (iA), Nothing] + prop FA_X1 = \[_, _, iCI, iA, iB] -> [Just (L.orl [L.andl [L.orl [L.andl [iA, L.inv (iB)], L.andl [L.inv (iA), iB]], L.inv (iCI)], L.andl [L.inv (L.orl [L.andl [iA, L.inv (iB)], L.andl [L.inv (iA), iB]]), iCI]]), Just (L.orl [L.andl [iA, iB], L.andl [iA, iCI], L.andl [iB, iCI]]), Nothing, Nothing, Nothing] + prop FILLCELL_X1 = \[] -> [] + prop FILLCELL_X16 = \[] -> [] + prop FILLCELL_X2 = \[] -> [] + prop FILLCELL_X32 = \[] -> [] + prop FILLCELL_X4 = \[] -> [] + prop FILLCELL_X8 = \[] -> [] + prop HA_X1 = \[_, _, iA, iB] -> [Just (L.orl [L.andl [iA, L.inv (iB)], L.andl [L.inv (iA), iB]]), Just (L.andl [iA, iB]), Nothing, Nothing] + prop INV_X1 = \[_, iA] -> [Just (L.inv (iA)), Nothing] + prop INV_X16 = \[_, iA] -> [Just (L.inv (iA)), Nothing] + prop INV_X2 = \[_, iA] -> [Just (L.inv (iA)), Nothing] + prop INV_X32 = \[_, iA] -> [Just (L.inv (iA)), Nothing] + prop INV_X4 = \[_, iA] -> [Just (L.inv (iA)), Nothing] + prop INV_X8 = \[_, iA] -> [Just (L.inv (iA)), Nothing] + prop LOGIC0_X1 = \[_] -> [Just (L.low)] + prop LOGIC1_X1 = \[_] -> [Just (L.high)] + prop NAND2_X1 = \[_, iA1, iA2] -> [Just (L.inv (L.andl [iA1, iA2])), Nothing, Nothing] + prop NAND2_X2 = \[_, iA1, iA2] -> [Just (L.inv (L.andl [iA1, iA2])), Nothing, Nothing] + prop NAND2_X4 = \[_, iA1, iA2] -> [Just (L.inv (L.andl [iA1, iA2])), Nothing, Nothing] + prop NOR2_X1 = \[_, iA1, iA2] -> [Just (L.inv (L.orl [iA1, iA2])), Nothing, Nothing] + prop NOR2_X2 = \[_, iA1, iA2] -> [Just (L.inv (L.orl [iA1, iA2])), Nothing, Nothing] + prop NOR2_X4 = \[_, iA1, iA2] -> [Just (L.inv (L.orl [iA1, iA2])), Nothing, Nothing] + prop OR2_X1 = \[_, iA1, iA2] -> [Just (L.orl [iA1, iA2]), Nothing, Nothing] + prop OR2_X2 = \[_, iA1, iA2] -> [Just (L.orl [iA1, iA2]), Nothing, Nothing] + prop OR2_X4 = \[_, iA1, iA2] -> [Just (L.orl [iA1, iA2]), Nothing, Nothing] + prop XNOR2_X1 = \[_, iA, iB] -> [Just (L.inv (L.orl [L.andl [iA, L.inv (iB)], L.andl [L.inv (iA), iB]])), Nothing, Nothing] + prop XNOR2_X2 = \[_, iA, iB] -> [Just (L.inv (L.orl [L.andl [iA, L.inv (iB)], L.andl [L.inv (iA), iB]])), Nothing, Nothing] + prop XOR2_X1 = \[_, iA, iB] -> [Just (L.orl [L.andl [iA, L.inv (iB)], L.andl [L.inv (iA), iB]]), Nothing, Nothing] + prop XOR2_X2 = \[_, iA, iB] -> [Just (L.orl [L.andl [iA, L.inv (iB)], L.andl [L.inv (iA), iB]]), Nothing, Nothing] + +instance TimingLibrary Nangate45 + where + loadCaps AND2_X1 = [5.05e-16, 5.25e-16] + loadCaps AND2_X2 = [5.1e-16, 5.41e-16] + loadCaps AND2_X4 = [4.85e-16, 5.37e-16] + loadCaps BUF_X1 = [5.04e-16] + loadCaps BUF_X16 = [4.3399999999999995e-16] + loadCaps BUF_X2 = [5.109999999999999e-16] + loadCaps BUF_X32 = [4.519999999999999e-16] + loadCaps BUF_X4 = [4.66e-16] + loadCaps BUF_X8 = [4.650000000000001e-16] + loadCaps FA_X1 = [2.1610000000000002e-15, 2.8769999999999996e-15, 3.0339999999999996e-15] + loadCaps FILLCELL_X1 = [] + loadCaps FILLCELL_X16 = [] + loadCaps FILLCELL_X2 = [] + loadCaps FILLCELL_X32 = [] + loadCaps FILLCELL_X4 = [] + loadCaps FILLCELL_X8 = [] + loadCaps HA_X1 = [2.9650000000000003e-15, 1.697e-15] + loadCaps INV_X1 = [4.37e-16] + loadCaps INV_X16 = [5.511e-15] + loadCaps INV_X2 = [7.839999999999999e-16] + loadCaps INV_X32 = [1.0717000000000001e-14] + loadCaps INV_X4 = [1.4630000000000001e-15] + loadCaps INV_X8 = [2.8129999999999998e-15] + loadCaps LOGIC0_X1 = [] + loadCaps LOGIC1_X1 = [] + loadCaps NAND2_X1 = [4.939999999999999e-16, 4.6e-16] + loadCaps NAND2_X2 = [8.95e-16, 8.63e-16] + loadCaps NAND2_X4 = [1.7149999999999999e-15, 2.472e-15] + loadCaps NOR2_X1 = [4.809999999999999e-16, 4.979999999999999e-16] + loadCaps NOR2_X2 = [8.97e-16, 9.24e-16] + loadCaps NOR2_X4 = [1.777e-15, 2.05e-15] + loadCaps OR2_X1 = [5.57e-16, 5.34e-16] + loadCaps OR2_X2 = [6.089999999999999e-16, 5.299999999999999e-16] + loadCaps OR2_X4 = [5.779999999999999e-16, 5.31e-16] + loadCaps XNOR2_X1 = [1.029e-15, 1.151e-15] + loadCaps XNOR2_X2 = [1.395e-15, 1.586e-15] + loadCaps XOR2_X1 = [1.059e-15, 1.118e-15] + loadCaps XOR2_X2 = [1.4369999999999999e-15, 1.576e-15] + + delay AND2_X1 0 0 Falling = tableDelay table_AND2_X1_A1_ZN_fallingDelay table_AND2_X1_A1_ZN_fallingTransition + delay AND2_X1 0 0 Rising = tableDelay table_AND2_X1_A1_ZN_risingDelay table_AND2_X1_A1_ZN_risingTransition + delay AND2_X1 1 0 Falling = tableDelay table_AND2_X1_A2_ZN_fallingDelay table_AND2_X1_A2_ZN_fallingTransition + delay AND2_X1 1 0 Rising = tableDelay table_AND2_X1_A2_ZN_risingDelay table_AND2_X1_A2_ZN_risingTransition + delay AND2_X2 0 0 Falling = tableDelay table_AND2_X2_A1_ZN_fallingDelay table_AND2_X2_A1_ZN_fallingTransition + delay AND2_X2 0 0 Rising = tableDelay table_AND2_X2_A1_ZN_risingDelay table_AND2_X2_A1_ZN_risingTransition + delay AND2_X2 1 0 Falling = tableDelay table_AND2_X2_A2_ZN_fallingDelay table_AND2_X2_A2_ZN_fallingTransition + delay AND2_X2 1 0 Rising = tableDelay table_AND2_X2_A2_ZN_risingDelay table_AND2_X2_A2_ZN_risingTransition + delay AND2_X4 0 0 Falling = tableDelay table_AND2_X4_A1_ZN_fallingDelay table_AND2_X4_A1_ZN_fallingTransition + delay AND2_X4 0 0 Rising = tableDelay table_AND2_X4_A1_ZN_risingDelay table_AND2_X4_A1_ZN_risingTransition + delay AND2_X4 1 0 Falling = tableDelay table_AND2_X4_A2_ZN_fallingDelay table_AND2_X4_A2_ZN_fallingTransition + delay AND2_X4 1 0 Rising = tableDelay table_AND2_X4_A2_ZN_risingDelay table_AND2_X4_A2_ZN_risingTransition + delay BUF_X1 0 0 Falling = tableDelay table_BUF_X1_A_Z_fallingDelay table_BUF_X1_A_Z_fallingTransition + delay BUF_X1 0 0 Rising = tableDelay table_BUF_X1_A_Z_risingDelay table_BUF_X1_A_Z_risingTransition + delay BUF_X16 0 0 Falling = tableDelay table_BUF_X16_A_Z_fallingDelay table_BUF_X16_A_Z_fallingTransition + delay BUF_X16 0 0 Rising = tableDelay table_BUF_X16_A_Z_risingDelay table_BUF_X16_A_Z_risingTransition + delay BUF_X2 0 0 Falling = tableDelay table_BUF_X2_A_Z_fallingDelay table_BUF_X2_A_Z_fallingTransition + delay BUF_X2 0 0 Rising = tableDelay table_BUF_X2_A_Z_risingDelay table_BUF_X2_A_Z_risingTransition + delay BUF_X32 0 0 Falling = tableDelay table_BUF_X32_A_Z_fallingDelay table_BUF_X32_A_Z_fallingTransition + delay BUF_X32 0 0 Rising = tableDelay table_BUF_X32_A_Z_risingDelay table_BUF_X32_A_Z_risingTransition + delay BUF_X4 0 0 Falling = tableDelay table_BUF_X4_A_Z_fallingDelay table_BUF_X4_A_Z_fallingTransition + delay BUF_X4 0 0 Rising = tableDelay table_BUF_X4_A_Z_risingDelay table_BUF_X4_A_Z_risingTransition + delay BUF_X8 0 0 Falling = tableDelay table_BUF_X8_A_Z_fallingDelay table_BUF_X8_A_Z_fallingTransition + delay BUF_X8 0 0 Rising = tableDelay table_BUF_X8_A_Z_risingDelay table_BUF_X8_A_Z_risingTransition + delay FA_X1 0 0 Falling = tableDelay table_FA_X1_CI_S_fallingDelay table_FA_X1_CI_S_fallingTransition + delay FA_X1 0 0 Rising = tableDelay table_FA_X1_CI_S_risingDelay table_FA_X1_CI_S_risingTransition + delay FA_X1 0 1 Falling = tableDelay table_FA_X1_CI_CO_fallingDelay table_FA_X1_CI_CO_fallingTransition + delay FA_X1 0 1 Rising = tableDelay table_FA_X1_CI_CO_risingDelay table_FA_X1_CI_CO_risingTransition + delay FA_X1 1 0 Falling = tableDelay table_FA_X1_A_S_fallingDelay table_FA_X1_A_S_fallingTransition + delay FA_X1 1 0 Rising = tableDelay table_FA_X1_A_S_risingDelay table_FA_X1_A_S_risingTransition + delay FA_X1 1 1 Falling = tableDelay table_FA_X1_A_CO_fallingDelay table_FA_X1_A_CO_fallingTransition + delay FA_X1 1 1 Rising = tableDelay table_FA_X1_A_CO_risingDelay table_FA_X1_A_CO_risingTransition + delay FA_X1 2 0 Falling = tableDelay table_FA_X1_B_S_fallingDelay table_FA_X1_B_S_fallingTransition + delay FA_X1 2 0 Rising = tableDelay table_FA_X1_B_S_risingDelay table_FA_X1_B_S_risingTransition + delay FA_X1 2 1 Falling = tableDelay table_FA_X1_B_CO_fallingDelay table_FA_X1_B_CO_fallingTransition + delay FA_X1 2 1 Rising = tableDelay table_FA_X1_B_CO_risingDelay table_FA_X1_B_CO_risingTransition + delay HA_X1 0 0 Falling = tableDelay table_HA_X1_A_S_fallingDelay table_HA_X1_A_S_fallingTransition + delay HA_X1 0 0 Rising = tableDelay table_HA_X1_A_S_risingDelay table_HA_X1_A_S_risingTransition + delay HA_X1 0 1 Falling = tableDelay table_HA_X1_A_CO_fallingDelay table_HA_X1_A_CO_fallingTransition + delay HA_X1 0 1 Rising = tableDelay table_HA_X1_A_CO_risingDelay table_HA_X1_A_CO_risingTransition + delay HA_X1 1 0 Falling = tableDelay table_HA_X1_B_S_fallingDelay table_HA_X1_B_S_fallingTransition + delay HA_X1 1 0 Rising = tableDelay table_HA_X1_B_S_risingDelay table_HA_X1_B_S_risingTransition + delay HA_X1 1 1 Falling = tableDelay table_HA_X1_B_CO_fallingDelay table_HA_X1_B_CO_fallingTransition + delay HA_X1 1 1 Rising = tableDelay table_HA_X1_B_CO_risingDelay table_HA_X1_B_CO_risingTransition + delay INV_X1 0 0 Falling = tableDelay table_INV_X1_A_ZN_fallingDelay table_INV_X1_A_ZN_fallingTransition + delay INV_X1 0 0 Rising = tableDelay table_INV_X1_A_ZN_risingDelay table_INV_X1_A_ZN_risingTransition + delay INV_X16 0 0 Falling = tableDelay table_INV_X16_A_ZN_fallingDelay table_INV_X16_A_ZN_fallingTransition + delay INV_X16 0 0 Rising = tableDelay table_INV_X16_A_ZN_risingDelay table_INV_X16_A_ZN_risingTransition + delay INV_X2 0 0 Falling = tableDelay table_INV_X2_A_ZN_fallingDelay table_INV_X2_A_ZN_fallingTransition + delay INV_X2 0 0 Rising = tableDelay table_INV_X2_A_ZN_risingDelay table_INV_X2_A_ZN_risingTransition + delay INV_X32 0 0 Falling = tableDelay table_INV_X32_A_ZN_fallingDelay table_INV_X32_A_ZN_fallingTransition + delay INV_X32 0 0 Rising = tableDelay table_INV_X32_A_ZN_risingDelay table_INV_X32_A_ZN_risingTransition + delay INV_X4 0 0 Falling = tableDelay table_INV_X4_A_ZN_fallingDelay table_INV_X4_A_ZN_fallingTransition + delay INV_X4 0 0 Rising = tableDelay table_INV_X4_A_ZN_risingDelay table_INV_X4_A_ZN_risingTransition + delay INV_X8 0 0 Falling = tableDelay table_INV_X8_A_ZN_fallingDelay table_INV_X8_A_ZN_fallingTransition + delay INV_X8 0 0 Rising = tableDelay table_INV_X8_A_ZN_risingDelay table_INV_X8_A_ZN_risingTransition + delay NAND2_X1 0 0 Falling = tableDelay table_NAND2_X1_A1_ZN_fallingDelay table_NAND2_X1_A1_ZN_fallingTransition + delay NAND2_X1 0 0 Rising = tableDelay table_NAND2_X1_A1_ZN_risingDelay table_NAND2_X1_A1_ZN_risingTransition + delay NAND2_X1 1 0 Falling = tableDelay table_NAND2_X1_A2_ZN_fallingDelay table_NAND2_X1_A2_ZN_fallingTransition + delay NAND2_X1 1 0 Rising = tableDelay table_NAND2_X1_A2_ZN_risingDelay table_NAND2_X1_A2_ZN_risingTransition + delay NAND2_X2 0 0 Falling = tableDelay table_NAND2_X2_A1_ZN_fallingDelay table_NAND2_X2_A1_ZN_fallingTransition + delay NAND2_X2 0 0 Rising = tableDelay table_NAND2_X2_A1_ZN_risingDelay table_NAND2_X2_A1_ZN_risingTransition + delay NAND2_X2 1 0 Falling = tableDelay table_NAND2_X2_A2_ZN_fallingDelay table_NAND2_X2_A2_ZN_fallingTransition + delay NAND2_X2 1 0 Rising = tableDelay table_NAND2_X2_A2_ZN_risingDelay table_NAND2_X2_A2_ZN_risingTransition + delay NAND2_X4 0 0 Falling = tableDelay table_NAND2_X4_A1_ZN_fallingDelay table_NAND2_X4_A1_ZN_fallingTransition + delay NAND2_X4 0 0 Rising = tableDelay table_NAND2_X4_A1_ZN_risingDelay table_NAND2_X4_A1_ZN_risingTransition + delay NAND2_X4 1 0 Falling = tableDelay table_NAND2_X4_A2_ZN_fallingDelay table_NAND2_X4_A2_ZN_fallingTransition + delay NAND2_X4 1 0 Rising = tableDelay table_NAND2_X4_A2_ZN_risingDelay table_NAND2_X4_A2_ZN_risingTransition + delay NOR2_X1 0 0 Falling = tableDelay table_NOR2_X1_A1_ZN_fallingDelay table_NOR2_X1_A1_ZN_fallingTransition + delay NOR2_X1 0 0 Rising = tableDelay table_NOR2_X1_A1_ZN_risingDelay table_NOR2_X1_A1_ZN_risingTransition + delay NOR2_X1 1 0 Falling = tableDelay table_NOR2_X1_A2_ZN_fallingDelay table_NOR2_X1_A2_ZN_fallingTransition + delay NOR2_X1 1 0 Rising = tableDelay table_NOR2_X1_A2_ZN_risingDelay table_NOR2_X1_A2_ZN_risingTransition + delay NOR2_X2 0 0 Falling = tableDelay table_NOR2_X2_A1_ZN_fallingDelay table_NOR2_X2_A1_ZN_fallingTransition + delay NOR2_X2 0 0 Rising = tableDelay table_NOR2_X2_A1_ZN_risingDelay table_NOR2_X2_A1_ZN_risingTransition + delay NOR2_X2 1 0 Falling = tableDelay table_NOR2_X2_A2_ZN_fallingDelay table_NOR2_X2_A2_ZN_fallingTransition + delay NOR2_X2 1 0 Rising = tableDelay table_NOR2_X2_A2_ZN_risingDelay table_NOR2_X2_A2_ZN_risingTransition + delay NOR2_X4 0 0 Falling = tableDelay table_NOR2_X4_A1_ZN_fallingDelay table_NOR2_X4_A1_ZN_fallingTransition + delay NOR2_X4 0 0 Rising = tableDelay table_NOR2_X4_A1_ZN_risingDelay table_NOR2_X4_A1_ZN_risingTransition + delay NOR2_X4 1 0 Falling = tableDelay table_NOR2_X4_A2_ZN_fallingDelay table_NOR2_X4_A2_ZN_fallingTransition + delay NOR2_X4 1 0 Rising = tableDelay table_NOR2_X4_A2_ZN_risingDelay table_NOR2_X4_A2_ZN_risingTransition + delay OR2_X1 0 0 Falling = tableDelay table_OR2_X1_A1_ZN_fallingDelay table_OR2_X1_A1_ZN_fallingTransition + delay OR2_X1 0 0 Rising = tableDelay table_OR2_X1_A1_ZN_risingDelay table_OR2_X1_A1_ZN_risingTransition + delay OR2_X1 1 0 Falling = tableDelay table_OR2_X1_A2_ZN_fallingDelay table_OR2_X1_A2_ZN_fallingTransition + delay OR2_X1 1 0 Rising = tableDelay table_OR2_X1_A2_ZN_risingDelay table_OR2_X1_A2_ZN_risingTransition + delay OR2_X2 0 0 Falling = tableDelay table_OR2_X2_A1_ZN_fallingDelay table_OR2_X2_A1_ZN_fallingTransition + delay OR2_X2 0 0 Rising = tableDelay table_OR2_X2_A1_ZN_risingDelay table_OR2_X2_A1_ZN_risingTransition + delay OR2_X2 1 0 Falling = tableDelay table_OR2_X2_A2_ZN_fallingDelay table_OR2_X2_A2_ZN_fallingTransition + delay OR2_X2 1 0 Rising = tableDelay table_OR2_X2_A2_ZN_risingDelay table_OR2_X2_A2_ZN_risingTransition + delay OR2_X4 0 0 Falling = tableDelay table_OR2_X4_A1_ZN_fallingDelay table_OR2_X4_A1_ZN_fallingTransition + delay OR2_X4 0 0 Rising = tableDelay table_OR2_X4_A1_ZN_risingDelay table_OR2_X4_A1_ZN_risingTransition + delay OR2_X4 1 0 Falling = tableDelay table_OR2_X4_A2_ZN_fallingDelay table_OR2_X4_A2_ZN_fallingTransition + delay OR2_X4 1 0 Rising = tableDelay table_OR2_X4_A2_ZN_risingDelay table_OR2_X4_A2_ZN_risingTransition + delay XNOR2_X1 0 0 Falling = tableDelay table_XNOR2_X1_A_ZN_fallingDelay table_XNOR2_X1_A_ZN_fallingTransition + delay XNOR2_X1 0 0 Rising = tableDelay table_XNOR2_X1_A_ZN_risingDelay table_XNOR2_X1_A_ZN_risingTransition + delay XNOR2_X1 1 0 Falling = tableDelay table_XNOR2_X1_B_ZN_fallingDelay table_XNOR2_X1_B_ZN_fallingTransition + delay XNOR2_X1 1 0 Rising = tableDelay table_XNOR2_X1_B_ZN_risingDelay table_XNOR2_X1_B_ZN_risingTransition + delay XNOR2_X2 0 0 Falling = tableDelay table_XNOR2_X2_A_ZN_fallingDelay table_XNOR2_X2_A_ZN_fallingTransition + delay XNOR2_X2 0 0 Rising = tableDelay table_XNOR2_X2_A_ZN_risingDelay table_XNOR2_X2_A_ZN_risingTransition + delay XNOR2_X2 1 0 Falling = tableDelay table_XNOR2_X2_B_ZN_fallingDelay table_XNOR2_X2_B_ZN_fallingTransition + delay XNOR2_X2 1 0 Rising = tableDelay table_XNOR2_X2_B_ZN_risingDelay table_XNOR2_X2_B_ZN_risingTransition + delay XOR2_X1 0 0 Falling = tableDelay table_XOR2_X1_A_Z_fallingDelay table_XOR2_X1_A_Z_fallingTransition + delay XOR2_X1 0 0 Rising = tableDelay table_XOR2_X1_A_Z_risingDelay table_XOR2_X1_A_Z_risingTransition + delay XOR2_X1 1 0 Falling = tableDelay table_XOR2_X1_B_Z_fallingDelay table_XOR2_X1_B_Z_fallingTransition + delay XOR2_X1 1 0 Rising = tableDelay table_XOR2_X1_B_Z_risingDelay table_XOR2_X1_B_Z_risingTransition + delay XOR2_X2 0 0 Falling = tableDelay table_XOR2_X2_A_Z_fallingDelay table_XOR2_X2_A_Z_fallingTransition + delay XOR2_X2 0 0 Rising = tableDelay table_XOR2_X2_A_Z_risingDelay table_XOR2_X2_A_Z_risingTransition + delay XOR2_X2 1 0 Falling = tableDelay table_XOR2_X2_B_Z_fallingDelay table_XOR2_X2_B_Z_fallingTransition + delay XOR2_X2 1 0 Rising = tableDelay table_XOR2_X2_B_Z_risingDelay table_XOR2_X2_B_Z_risingTransition + +-- | Interface: +-- +-- > (A1, A2) -> ZN +-- +-- Function: +-- +-- > ZN = and [A1, A2] +and2_x1 :: MonadLava Nangate45 m => (Signal, Signal) -> m Signal +and2_x1 = cell AND2_X1 + +-- | Interface: +-- +-- > (A1, A2) -> ZN +-- +-- Function: +-- +-- > ZN = and [A1, A2] +and2_x2 :: MonadLava Nangate45 m => (Signal, Signal) -> m Signal +and2_x2 = cell AND2_X2 + +-- | Interface: +-- +-- > (A1, A2) -> ZN +-- +-- Function: +-- +-- > ZN = and [A1, A2] +and2_x4 :: MonadLava Nangate45 m => (Signal, Signal) -> m Signal +and2_x4 = cell AND2_X4 + +-- | Interface: +-- +-- > A -> Z +-- +-- Function: +-- +-- > Z = A +buf_x1 :: MonadLava Nangate45 m => Signal -> m Signal +buf_x1 = cell BUF_X1 + +-- | Interface: +-- +-- > A -> Z +-- +-- Function: +-- +-- > Z = A +buf_x16 :: MonadLava Nangate45 m => Signal -> m Signal +buf_x16 = cell BUF_X16 + +-- | Interface: +-- +-- > A -> Z +-- +-- Function: +-- +-- > Z = A +buf_x2 :: MonadLava Nangate45 m => Signal -> m Signal +buf_x2 = cell BUF_X2 + +-- | Interface: +-- +-- > A -> Z +-- +-- Function: +-- +-- > Z = A +buf_x32 :: MonadLava Nangate45 m => Signal -> m Signal +buf_x32 = cell BUF_X32 + +-- | Interface: +-- +-- > A -> Z +-- +-- Function: +-- +-- > Z = A +buf_x4 :: MonadLava Nangate45 m => Signal -> m Signal +buf_x4 = cell BUF_X4 + +-- | Interface: +-- +-- > A -> Z +-- +-- Function: +-- +-- > Z = A +buf_x8 :: MonadLava Nangate45 m => Signal -> m Signal +buf_x8 = cell BUF_X8 + +-- | Interface: +-- +-- > (CI, (A, B)) -> (S, CO) +-- +-- Function: +-- +-- > S = or [and [or [and [A, B'], and [A', B]], CI'], and [(or [and [A, B'], and [A', B]])', CI]] +-- > CO = or [and [A, B], and [A, CI], and [B, CI]] +fa_x1 :: MonadLava Nangate45 m => (Signal, (Signal, Signal)) -> m (Signal, Signal) +fa_x1 = cell FA_X1 + +fillcell_x1 :: MonadLava Nangate45 m => a -> m a +fillcell_x1 = physCell FILLCELL_X1 + +fillcell_x16 :: MonadLava Nangate45 m => a -> m a +fillcell_x16 = physCell FILLCELL_X16 + +fillcell_x2 :: MonadLava Nangate45 m => a -> m a +fillcell_x2 = physCell FILLCELL_X2 + +fillcell_x32 :: MonadLava Nangate45 m => a -> m a +fillcell_x32 = physCell FILLCELL_X32 + +fillcell_x4 :: MonadLava Nangate45 m => a -> m a +fillcell_x4 = physCell FILLCELL_X4 + +fillcell_x8 :: MonadLava Nangate45 m => a -> m a +fillcell_x8 = physCell FILLCELL_X8 + +-- | Interface: +-- +-- > (A, B) -> (S, CO) +-- +-- Function: +-- +-- > S = or [and [A, B'], and [A', B]] +-- > CO = and [A, B] +ha_x1 :: MonadLava Nangate45 m => (Signal, Signal) -> m (Signal, Signal) +ha_x1 = cell HA_X1 + +-- | Interface: +-- +-- > A -> ZN +-- +-- Function: +-- +-- > ZN = A' +inv_x1 :: MonadLava Nangate45 m => Signal -> m Signal +inv_x1 = cell INV_X1 + +-- | Interface: +-- +-- > A -> ZN +-- +-- Function: +-- +-- > ZN = A' +inv_x16 :: MonadLava Nangate45 m => Signal -> m Signal +inv_x16 = cell INV_X16 + +-- | Interface: +-- +-- > A -> ZN +-- +-- Function: +-- +-- > ZN = A' +inv_x2 :: MonadLava Nangate45 m => Signal -> m Signal +inv_x2 = cell INV_X2 + +-- | Interface: +-- +-- > A -> ZN +-- +-- Function: +-- +-- > ZN = A' +inv_x32 :: MonadLava Nangate45 m => Signal -> m Signal +inv_x32 = cell INV_X32 + +-- | Interface: +-- +-- > A -> ZN +-- +-- Function: +-- +-- > ZN = A' +inv_x4 :: MonadLava Nangate45 m => Signal -> m Signal +inv_x4 = cell INV_X4 + +-- | Interface: +-- +-- > A -> ZN +-- +-- Function: +-- +-- > ZN = A' +inv_x8 :: MonadLava Nangate45 m => Signal -> m Signal +inv_x8 = cell INV_X8 + +-- | Interface: +-- +-- > Z +-- +-- Function: +-- +-- > Z = 0 +logic0_x1 :: MonadLava Nangate45 m => m Signal +logic0_x1 = sourceCell LOGIC0_X1 + +-- | Interface: +-- +-- > Z +-- +-- Function: +-- +-- > Z = 1 +logic1_x1 :: MonadLava Nangate45 m => m Signal +logic1_x1 = sourceCell LOGIC1_X1 + +-- | Interface: +-- +-- > (A1, A2) -> ZN +-- +-- Function: +-- +-- > ZN = (and [A1, A2])' +nand2_x1 :: MonadLava Nangate45 m => (Signal, Signal) -> m Signal +nand2_x1 = cell NAND2_X1 + +-- | Interface: +-- +-- > (A1, A2) -> ZN +-- +-- Function: +-- +-- > ZN = (and [A1, A2])' +nand2_x2 :: MonadLava Nangate45 m => (Signal, Signal) -> m Signal +nand2_x2 = cell NAND2_X2 + +-- | Interface: +-- +-- > (A1, A2) -> ZN +-- +-- Function: +-- +-- > ZN = (and [A1, A2])' +nand2_x4 :: MonadLava Nangate45 m => (Signal, Signal) -> m Signal +nand2_x4 = cell NAND2_X4 + +-- | Interface: +-- +-- > (A1, A2) -> ZN +-- +-- Function: +-- +-- > ZN = (or [A1, A2])' +nor2_x1 :: MonadLava Nangate45 m => (Signal, Signal) -> m Signal +nor2_x1 = cell NOR2_X1 + +-- | Interface: +-- +-- > (A1, A2) -> ZN +-- +-- Function: +-- +-- > ZN = (or [A1, A2])' +nor2_x2 :: MonadLava Nangate45 m => (Signal, Signal) -> m Signal +nor2_x2 = cell NOR2_X2 + +-- | Interface: +-- +-- > (A1, A2) -> ZN +-- +-- Function: +-- +-- > ZN = (or [A1, A2])' +nor2_x4 :: MonadLava Nangate45 m => (Signal, Signal) -> m Signal +nor2_x4 = cell NOR2_X4 + +-- | Interface: +-- +-- > (A1, A2) -> ZN +-- +-- Function: +-- +-- > ZN = or [A1, A2] +or2_x1 :: MonadLava Nangate45 m => (Signal, Signal) -> m Signal +or2_x1 = cell OR2_X1 + +-- | Interface: +-- +-- > (A1, A2) -> ZN +-- +-- Function: +-- +-- > ZN = or [A1, A2] +or2_x2 :: MonadLava Nangate45 m => (Signal, Signal) -> m Signal +or2_x2 = cell OR2_X2 + +-- | Interface: +-- +-- > (A1, A2) -> ZN +-- +-- Function: +-- +-- > ZN = or [A1, A2] +or2_x4 :: MonadLava Nangate45 m => (Signal, Signal) -> m Signal +or2_x4 = cell OR2_X4 + +-- | Interface: +-- +-- > (A, B) -> ZN +-- +-- Function: +-- +-- > ZN = (or [and [A, B'], and [A', B]])' +xnor2_x1 :: MonadLava Nangate45 m => (Signal, Signal) -> m Signal +xnor2_x1 = cell XNOR2_X1 + +-- | Interface: +-- +-- > (A, B) -> ZN +-- +-- Function: +-- +-- > ZN = (or [and [A, B'], and [A', B]])' +xnor2_x2 :: MonadLava Nangate45 m => (Signal, Signal) -> m Signal +xnor2_x2 = cell XNOR2_X2 + +-- | Interface: +-- +-- > (A, B) -> Z +-- +-- Function: +-- +-- > Z = or [and [A, B'], and [A', B]] +xor2_x1 :: MonadLava Nangate45 m => (Signal, Signal) -> m Signal +xor2_x1 = cell XOR2_X1 + +-- | Interface: +-- +-- > (A, B) -> Z +-- +-- Function: +-- +-- > Z = or [and [A, B'], and [A', B]] +xor2_x2 :: MonadLava Nangate45 m => (Signal, Signal) -> m Signal +xor2_x2 = cell XOR2_X2 + diff --git a/Libs/Nangate45/Timing.hs b/Libs/Nangate45/Timing.hs new file mode 100644 --- /dev/null +++ b/Libs/Nangate45/Timing.hs @@ -0,0 +1,1316 @@ +{-# OPTIONS_GHC -fno-warn-missing-fields #-} + +-- | +-- Copyright : Copyright (c) 2008, Emil Axelsson +-- License : BSD3 +-- Maintainer : Emil Axelsson +-- Stability : experimental +-- +-- Timing interface to the Nangate45 library. +-- +-- The data in this file is derived from Nangate's Open Cell Library, +-- and is subject to the license restrictions stated in +-- "Libs.Nangate45.LICENSE". +module Libs.Nangate45.Timing where + +import Foreign.C + +import Data.Hardware.Internal +import Analysis.Timing.Library + +foreign import ccall "timing.h lookTrAxis_AND2_X1_A1_ZN_risingDelay" lookTrAxis_AND2_X1_A1_ZN_risingDelay :: CInt -> CDouble +foreign import ccall "timing.h lookCapAxis_AND2_X1_A1_ZN_risingDelay" lookCapAxis_AND2_X1_A1_ZN_risingDelay :: CInt -> CDouble +foreign import ccall "timing.h lookTable_AND2_X1_A1_ZN_risingDelay" lookTable_AND2_X1_A1_ZN_risingDelay :: CInt -> CInt -> CDouble +table_AND2_X1_A1_ZN_risingDelay :: Table2D CInt TransitionTime Capacitance Time +table_AND2_X1_A1_ZN_risingDelay = mkTimingTable 8 6 lookTrAxis_AND2_X1_A1_ZN_risingDelay lookCapAxis_AND2_X1_A1_ZN_risingDelay lookTable_AND2_X1_A1_ZN_risingDelay + +foreign import ccall "timing.h lookTrAxis_AND2_X1_A1_ZN_fallingDelay" lookTrAxis_AND2_X1_A1_ZN_fallingDelay :: CInt -> CDouble +foreign import ccall "timing.h lookCapAxis_AND2_X1_A1_ZN_fallingDelay" lookCapAxis_AND2_X1_A1_ZN_fallingDelay :: CInt -> CDouble +foreign import ccall "timing.h lookTable_AND2_X1_A1_ZN_fallingDelay" lookTable_AND2_X1_A1_ZN_fallingDelay :: CInt -> CInt -> CDouble +table_AND2_X1_A1_ZN_fallingDelay :: Table2D CInt TransitionTime Capacitance Time +table_AND2_X1_A1_ZN_fallingDelay = mkTimingTable 8 6 lookTrAxis_AND2_X1_A1_ZN_fallingDelay lookCapAxis_AND2_X1_A1_ZN_fallingDelay lookTable_AND2_X1_A1_ZN_fallingDelay + +foreign import ccall "timing.h lookTrAxis_AND2_X1_A1_ZN_risingTransition" lookTrAxis_AND2_X1_A1_ZN_risingTransition :: CInt -> CDouble +foreign import ccall "timing.h lookCapAxis_AND2_X1_A1_ZN_risingTransition" lookCapAxis_AND2_X1_A1_ZN_risingTransition :: CInt -> CDouble +foreign import ccall "timing.h lookTable_AND2_X1_A1_ZN_risingTransition" lookTable_AND2_X1_A1_ZN_risingTransition :: CInt -> CInt -> CDouble +table_AND2_X1_A1_ZN_risingTransition :: Table2D CInt TransitionTime Capacitance TransitionTime +table_AND2_X1_A1_ZN_risingTransition = mkTimingTable 8 6 lookTrAxis_AND2_X1_A1_ZN_risingTransition lookCapAxis_AND2_X1_A1_ZN_risingTransition lookTable_AND2_X1_A1_ZN_risingTransition + +foreign import ccall "timing.h lookTrAxis_AND2_X1_A1_ZN_fallingTransition" lookTrAxis_AND2_X1_A1_ZN_fallingTransition :: CInt -> CDouble +foreign import ccall "timing.h lookCapAxis_AND2_X1_A1_ZN_fallingTransition" lookCapAxis_AND2_X1_A1_ZN_fallingTransition :: CInt -> CDouble +foreign import ccall "timing.h lookTable_AND2_X1_A1_ZN_fallingTransition" lookTable_AND2_X1_A1_ZN_fallingTransition :: CInt -> CInt -> CDouble +table_AND2_X1_A1_ZN_fallingTransition :: Table2D CInt TransitionTime Capacitance TransitionTime +table_AND2_X1_A1_ZN_fallingTransition = mkTimingTable 8 6 lookTrAxis_AND2_X1_A1_ZN_fallingTransition lookCapAxis_AND2_X1_A1_ZN_fallingTransition lookTable_AND2_X1_A1_ZN_fallingTransition + +foreign import ccall "timing.h lookTrAxis_AND2_X1_A2_ZN_risingDelay" lookTrAxis_AND2_X1_A2_ZN_risingDelay :: CInt -> CDouble +foreign import ccall "timing.h lookCapAxis_AND2_X1_A2_ZN_risingDelay" lookCapAxis_AND2_X1_A2_ZN_risingDelay :: CInt -> CDouble +foreign import ccall "timing.h lookTable_AND2_X1_A2_ZN_risingDelay" lookTable_AND2_X1_A2_ZN_risingDelay :: CInt -> CInt -> CDouble +table_AND2_X1_A2_ZN_risingDelay :: Table2D CInt TransitionTime Capacitance Time +table_AND2_X1_A2_ZN_risingDelay = mkTimingTable 8 6 lookTrAxis_AND2_X1_A2_ZN_risingDelay lookCapAxis_AND2_X1_A2_ZN_risingDelay lookTable_AND2_X1_A2_ZN_risingDelay + +foreign import ccall "timing.h lookTrAxis_AND2_X1_A2_ZN_fallingDelay" lookTrAxis_AND2_X1_A2_ZN_fallingDelay :: CInt -> CDouble +foreign import ccall "timing.h lookCapAxis_AND2_X1_A2_ZN_fallingDelay" lookCapAxis_AND2_X1_A2_ZN_fallingDelay :: CInt -> CDouble +foreign import ccall "timing.h lookTable_AND2_X1_A2_ZN_fallingDelay" lookTable_AND2_X1_A2_ZN_fallingDelay :: CInt -> CInt -> CDouble +table_AND2_X1_A2_ZN_fallingDelay :: Table2D CInt TransitionTime Capacitance Time +table_AND2_X1_A2_ZN_fallingDelay = mkTimingTable 8 6 lookTrAxis_AND2_X1_A2_ZN_fallingDelay lookCapAxis_AND2_X1_A2_ZN_fallingDelay lookTable_AND2_X1_A2_ZN_fallingDelay + +foreign import ccall "timing.h lookTrAxis_AND2_X1_A2_ZN_risingTransition" lookTrAxis_AND2_X1_A2_ZN_risingTransition :: CInt -> CDouble +foreign import ccall "timing.h lookCapAxis_AND2_X1_A2_ZN_risingTransition" lookCapAxis_AND2_X1_A2_ZN_risingTransition :: CInt -> CDouble +foreign import ccall "timing.h lookTable_AND2_X1_A2_ZN_risingTransition" lookTable_AND2_X1_A2_ZN_risingTransition :: CInt -> CInt -> CDouble +table_AND2_X1_A2_ZN_risingTransition :: Table2D CInt TransitionTime Capacitance TransitionTime +table_AND2_X1_A2_ZN_risingTransition = mkTimingTable 8 6 lookTrAxis_AND2_X1_A2_ZN_risingTransition lookCapAxis_AND2_X1_A2_ZN_risingTransition lookTable_AND2_X1_A2_ZN_risingTransition + +foreign import ccall "timing.h lookTrAxis_AND2_X1_A2_ZN_fallingTransition" lookTrAxis_AND2_X1_A2_ZN_fallingTransition :: CInt -> CDouble +foreign import ccall "timing.h lookCapAxis_AND2_X1_A2_ZN_fallingTransition" lookCapAxis_AND2_X1_A2_ZN_fallingTransition :: CInt -> CDouble +foreign import ccall "timing.h lookTable_AND2_X1_A2_ZN_fallingTransition" lookTable_AND2_X1_A2_ZN_fallingTransition :: CInt -> CInt -> CDouble +table_AND2_X1_A2_ZN_fallingTransition :: Table2D CInt TransitionTime Capacitance TransitionTime +table_AND2_X1_A2_ZN_fallingTransition = mkTimingTable 8 6 lookTrAxis_AND2_X1_A2_ZN_fallingTransition lookCapAxis_AND2_X1_A2_ZN_fallingTransition lookTable_AND2_X1_A2_ZN_fallingTransition + +foreign import ccall "timing.h lookTrAxis_AND2_X2_A1_ZN_risingDelay" lookTrAxis_AND2_X2_A1_ZN_risingDelay :: CInt -> CDouble +foreign import ccall "timing.h lookCapAxis_AND2_X2_A1_ZN_risingDelay" lookCapAxis_AND2_X2_A1_ZN_risingDelay :: CInt -> CDouble +foreign import ccall "timing.h lookTable_AND2_X2_A1_ZN_risingDelay" lookTable_AND2_X2_A1_ZN_risingDelay :: CInt -> CInt -> CDouble +table_AND2_X2_A1_ZN_risingDelay :: Table2D CInt TransitionTime Capacitance Time +table_AND2_X2_A1_ZN_risingDelay = mkTimingTable 8 6 lookTrAxis_AND2_X2_A1_ZN_risingDelay lookCapAxis_AND2_X2_A1_ZN_risingDelay lookTable_AND2_X2_A1_ZN_risingDelay + +foreign import ccall "timing.h lookTrAxis_AND2_X2_A1_ZN_fallingDelay" lookTrAxis_AND2_X2_A1_ZN_fallingDelay :: CInt -> CDouble +foreign import ccall "timing.h lookCapAxis_AND2_X2_A1_ZN_fallingDelay" lookCapAxis_AND2_X2_A1_ZN_fallingDelay :: CInt -> CDouble +foreign import ccall "timing.h lookTable_AND2_X2_A1_ZN_fallingDelay" lookTable_AND2_X2_A1_ZN_fallingDelay :: CInt -> CInt -> CDouble +table_AND2_X2_A1_ZN_fallingDelay :: Table2D CInt TransitionTime Capacitance Time +table_AND2_X2_A1_ZN_fallingDelay = mkTimingTable 8 6 lookTrAxis_AND2_X2_A1_ZN_fallingDelay lookCapAxis_AND2_X2_A1_ZN_fallingDelay lookTable_AND2_X2_A1_ZN_fallingDelay + +foreign import ccall "timing.h lookTrAxis_AND2_X2_A1_ZN_risingTransition" lookTrAxis_AND2_X2_A1_ZN_risingTransition :: CInt -> CDouble +foreign import ccall "timing.h lookCapAxis_AND2_X2_A1_ZN_risingTransition" lookCapAxis_AND2_X2_A1_ZN_risingTransition :: CInt -> CDouble +foreign import ccall "timing.h lookTable_AND2_X2_A1_ZN_risingTransition" lookTable_AND2_X2_A1_ZN_risingTransition :: CInt -> CInt -> CDouble +table_AND2_X2_A1_ZN_risingTransition :: Table2D CInt TransitionTime Capacitance TransitionTime +table_AND2_X2_A1_ZN_risingTransition = mkTimingTable 8 6 lookTrAxis_AND2_X2_A1_ZN_risingTransition lookCapAxis_AND2_X2_A1_ZN_risingTransition lookTable_AND2_X2_A1_ZN_risingTransition + +foreign import ccall "timing.h lookTrAxis_AND2_X2_A1_ZN_fallingTransition" lookTrAxis_AND2_X2_A1_ZN_fallingTransition :: CInt -> CDouble +foreign import ccall "timing.h lookCapAxis_AND2_X2_A1_ZN_fallingTransition" lookCapAxis_AND2_X2_A1_ZN_fallingTransition :: CInt -> CDouble +foreign import ccall "timing.h lookTable_AND2_X2_A1_ZN_fallingTransition" lookTable_AND2_X2_A1_ZN_fallingTransition :: CInt -> CInt -> CDouble +table_AND2_X2_A1_ZN_fallingTransition :: Table2D CInt TransitionTime Capacitance TransitionTime +table_AND2_X2_A1_ZN_fallingTransition = mkTimingTable 8 6 lookTrAxis_AND2_X2_A1_ZN_fallingTransition lookCapAxis_AND2_X2_A1_ZN_fallingTransition lookTable_AND2_X2_A1_ZN_fallingTransition + +foreign import ccall "timing.h lookTrAxis_AND2_X2_A2_ZN_risingDelay" lookTrAxis_AND2_X2_A2_ZN_risingDelay :: CInt -> CDouble +foreign import ccall "timing.h lookCapAxis_AND2_X2_A2_ZN_risingDelay" lookCapAxis_AND2_X2_A2_ZN_risingDelay :: CInt -> CDouble +foreign import ccall "timing.h lookTable_AND2_X2_A2_ZN_risingDelay" lookTable_AND2_X2_A2_ZN_risingDelay :: CInt -> CInt -> CDouble +table_AND2_X2_A2_ZN_risingDelay :: Table2D CInt TransitionTime Capacitance Time +table_AND2_X2_A2_ZN_risingDelay = mkTimingTable 8 6 lookTrAxis_AND2_X2_A2_ZN_risingDelay lookCapAxis_AND2_X2_A2_ZN_risingDelay lookTable_AND2_X2_A2_ZN_risingDelay + +foreign import ccall "timing.h lookTrAxis_AND2_X2_A2_ZN_fallingDelay" lookTrAxis_AND2_X2_A2_ZN_fallingDelay :: CInt -> CDouble +foreign import ccall "timing.h lookCapAxis_AND2_X2_A2_ZN_fallingDelay" lookCapAxis_AND2_X2_A2_ZN_fallingDelay :: CInt -> CDouble +foreign import ccall "timing.h lookTable_AND2_X2_A2_ZN_fallingDelay" lookTable_AND2_X2_A2_ZN_fallingDelay :: CInt -> CInt -> CDouble +table_AND2_X2_A2_ZN_fallingDelay :: Table2D CInt TransitionTime Capacitance Time +table_AND2_X2_A2_ZN_fallingDelay = mkTimingTable 8 6 lookTrAxis_AND2_X2_A2_ZN_fallingDelay lookCapAxis_AND2_X2_A2_ZN_fallingDelay lookTable_AND2_X2_A2_ZN_fallingDelay + +foreign import ccall "timing.h lookTrAxis_AND2_X2_A2_ZN_risingTransition" lookTrAxis_AND2_X2_A2_ZN_risingTransition :: CInt -> CDouble +foreign import ccall "timing.h lookCapAxis_AND2_X2_A2_ZN_risingTransition" lookCapAxis_AND2_X2_A2_ZN_risingTransition :: CInt -> CDouble +foreign import ccall "timing.h lookTable_AND2_X2_A2_ZN_risingTransition" lookTable_AND2_X2_A2_ZN_risingTransition :: CInt -> CInt -> CDouble +table_AND2_X2_A2_ZN_risingTransition :: Table2D CInt TransitionTime Capacitance TransitionTime +table_AND2_X2_A2_ZN_risingTransition = mkTimingTable 8 6 lookTrAxis_AND2_X2_A2_ZN_risingTransition lookCapAxis_AND2_X2_A2_ZN_risingTransition lookTable_AND2_X2_A2_ZN_risingTransition + +foreign import ccall "timing.h lookTrAxis_AND2_X2_A2_ZN_fallingTransition" lookTrAxis_AND2_X2_A2_ZN_fallingTransition :: CInt -> CDouble +foreign import ccall "timing.h lookCapAxis_AND2_X2_A2_ZN_fallingTransition" lookCapAxis_AND2_X2_A2_ZN_fallingTransition :: CInt -> CDouble +foreign import ccall "timing.h lookTable_AND2_X2_A2_ZN_fallingTransition" lookTable_AND2_X2_A2_ZN_fallingTransition :: CInt -> CInt -> CDouble +table_AND2_X2_A2_ZN_fallingTransition :: Table2D CInt TransitionTime Capacitance TransitionTime +table_AND2_X2_A2_ZN_fallingTransition = mkTimingTable 8 6 lookTrAxis_AND2_X2_A2_ZN_fallingTransition lookCapAxis_AND2_X2_A2_ZN_fallingTransition lookTable_AND2_X2_A2_ZN_fallingTransition + +foreign import ccall "timing.h lookTrAxis_AND2_X4_A1_ZN_risingDelay" lookTrAxis_AND2_X4_A1_ZN_risingDelay :: CInt -> CDouble +foreign import ccall "timing.h lookCapAxis_AND2_X4_A1_ZN_risingDelay" lookCapAxis_AND2_X4_A1_ZN_risingDelay :: CInt -> CDouble +foreign import ccall "timing.h lookTable_AND2_X4_A1_ZN_risingDelay" lookTable_AND2_X4_A1_ZN_risingDelay :: CInt -> CInt -> CDouble +table_AND2_X4_A1_ZN_risingDelay :: Table2D CInt TransitionTime Capacitance Time +table_AND2_X4_A1_ZN_risingDelay = mkTimingTable 8 6 lookTrAxis_AND2_X4_A1_ZN_risingDelay lookCapAxis_AND2_X4_A1_ZN_risingDelay lookTable_AND2_X4_A1_ZN_risingDelay + +foreign import ccall "timing.h lookTrAxis_AND2_X4_A1_ZN_fallingDelay" lookTrAxis_AND2_X4_A1_ZN_fallingDelay :: CInt -> CDouble +foreign import ccall "timing.h lookCapAxis_AND2_X4_A1_ZN_fallingDelay" lookCapAxis_AND2_X4_A1_ZN_fallingDelay :: CInt -> CDouble +foreign import ccall "timing.h lookTable_AND2_X4_A1_ZN_fallingDelay" lookTable_AND2_X4_A1_ZN_fallingDelay :: CInt -> CInt -> CDouble +table_AND2_X4_A1_ZN_fallingDelay :: Table2D CInt TransitionTime Capacitance Time +table_AND2_X4_A1_ZN_fallingDelay = mkTimingTable 8 6 lookTrAxis_AND2_X4_A1_ZN_fallingDelay lookCapAxis_AND2_X4_A1_ZN_fallingDelay lookTable_AND2_X4_A1_ZN_fallingDelay + +foreign import ccall "timing.h lookTrAxis_AND2_X4_A1_ZN_risingTransition" lookTrAxis_AND2_X4_A1_ZN_risingTransition :: CInt -> CDouble +foreign import ccall "timing.h lookCapAxis_AND2_X4_A1_ZN_risingTransition" lookCapAxis_AND2_X4_A1_ZN_risingTransition :: CInt -> CDouble +foreign import ccall "timing.h lookTable_AND2_X4_A1_ZN_risingTransition" lookTable_AND2_X4_A1_ZN_risingTransition :: CInt -> CInt -> CDouble +table_AND2_X4_A1_ZN_risingTransition :: Table2D CInt TransitionTime Capacitance TransitionTime +table_AND2_X4_A1_ZN_risingTransition = mkTimingTable 8 6 lookTrAxis_AND2_X4_A1_ZN_risingTransition lookCapAxis_AND2_X4_A1_ZN_risingTransition lookTable_AND2_X4_A1_ZN_risingTransition + +foreign import ccall "timing.h lookTrAxis_AND2_X4_A1_ZN_fallingTransition" lookTrAxis_AND2_X4_A1_ZN_fallingTransition :: CInt -> CDouble +foreign import ccall "timing.h lookCapAxis_AND2_X4_A1_ZN_fallingTransition" lookCapAxis_AND2_X4_A1_ZN_fallingTransition :: CInt -> CDouble +foreign import ccall "timing.h lookTable_AND2_X4_A1_ZN_fallingTransition" lookTable_AND2_X4_A1_ZN_fallingTransition :: CInt -> CInt -> CDouble +table_AND2_X4_A1_ZN_fallingTransition :: Table2D CInt TransitionTime Capacitance TransitionTime +table_AND2_X4_A1_ZN_fallingTransition = mkTimingTable 8 6 lookTrAxis_AND2_X4_A1_ZN_fallingTransition lookCapAxis_AND2_X4_A1_ZN_fallingTransition lookTable_AND2_X4_A1_ZN_fallingTransition + +foreign import ccall "timing.h lookTrAxis_AND2_X4_A2_ZN_risingDelay" lookTrAxis_AND2_X4_A2_ZN_risingDelay :: CInt -> CDouble +foreign import ccall "timing.h lookCapAxis_AND2_X4_A2_ZN_risingDelay" lookCapAxis_AND2_X4_A2_ZN_risingDelay :: CInt -> CDouble +foreign import ccall "timing.h lookTable_AND2_X4_A2_ZN_risingDelay" lookTable_AND2_X4_A2_ZN_risingDelay :: CInt -> CInt -> CDouble +table_AND2_X4_A2_ZN_risingDelay :: Table2D CInt TransitionTime Capacitance Time +table_AND2_X4_A2_ZN_risingDelay = mkTimingTable 8 6 lookTrAxis_AND2_X4_A2_ZN_risingDelay lookCapAxis_AND2_X4_A2_ZN_risingDelay lookTable_AND2_X4_A2_ZN_risingDelay + +foreign import ccall "timing.h lookTrAxis_AND2_X4_A2_ZN_fallingDelay" lookTrAxis_AND2_X4_A2_ZN_fallingDelay :: CInt -> CDouble +foreign import ccall "timing.h lookCapAxis_AND2_X4_A2_ZN_fallingDelay" lookCapAxis_AND2_X4_A2_ZN_fallingDelay :: CInt -> CDouble +foreign import ccall "timing.h lookTable_AND2_X4_A2_ZN_fallingDelay" lookTable_AND2_X4_A2_ZN_fallingDelay :: CInt -> CInt -> CDouble +table_AND2_X4_A2_ZN_fallingDelay :: Table2D CInt TransitionTime Capacitance Time +table_AND2_X4_A2_ZN_fallingDelay = mkTimingTable 8 6 lookTrAxis_AND2_X4_A2_ZN_fallingDelay lookCapAxis_AND2_X4_A2_ZN_fallingDelay lookTable_AND2_X4_A2_ZN_fallingDelay + +foreign import ccall "timing.h lookTrAxis_AND2_X4_A2_ZN_risingTransition" lookTrAxis_AND2_X4_A2_ZN_risingTransition :: CInt -> CDouble +foreign import ccall "timing.h lookCapAxis_AND2_X4_A2_ZN_risingTransition" lookCapAxis_AND2_X4_A2_ZN_risingTransition :: CInt -> CDouble +foreign import ccall "timing.h lookTable_AND2_X4_A2_ZN_risingTransition" lookTable_AND2_X4_A2_ZN_risingTransition :: CInt -> CInt -> CDouble +table_AND2_X4_A2_ZN_risingTransition :: Table2D CInt TransitionTime Capacitance TransitionTime +table_AND2_X4_A2_ZN_risingTransition = mkTimingTable 8 6 lookTrAxis_AND2_X4_A2_ZN_risingTransition lookCapAxis_AND2_X4_A2_ZN_risingTransition lookTable_AND2_X4_A2_ZN_risingTransition + +foreign import ccall "timing.h lookTrAxis_AND2_X4_A2_ZN_fallingTransition" lookTrAxis_AND2_X4_A2_ZN_fallingTransition :: CInt -> CDouble +foreign import ccall "timing.h lookCapAxis_AND2_X4_A2_ZN_fallingTransition" lookCapAxis_AND2_X4_A2_ZN_fallingTransition :: CInt -> CDouble +foreign import ccall "timing.h lookTable_AND2_X4_A2_ZN_fallingTransition" lookTable_AND2_X4_A2_ZN_fallingTransition :: CInt -> CInt -> CDouble +table_AND2_X4_A2_ZN_fallingTransition :: Table2D CInt TransitionTime Capacitance TransitionTime +table_AND2_X4_A2_ZN_fallingTransition = mkTimingTable 8 6 lookTrAxis_AND2_X4_A2_ZN_fallingTransition lookCapAxis_AND2_X4_A2_ZN_fallingTransition lookTable_AND2_X4_A2_ZN_fallingTransition + +foreign import ccall "timing.h lookTrAxis_BUF_X1_A_Z_risingDelay" lookTrAxis_BUF_X1_A_Z_risingDelay :: CInt -> CDouble +foreign import ccall "timing.h lookCapAxis_BUF_X1_A_Z_risingDelay" lookCapAxis_BUF_X1_A_Z_risingDelay :: CInt -> CDouble +foreign import ccall "timing.h lookTable_BUF_X1_A_Z_risingDelay" lookTable_BUF_X1_A_Z_risingDelay :: CInt -> CInt -> CDouble +table_BUF_X1_A_Z_risingDelay :: Table2D CInt TransitionTime Capacitance Time +table_BUF_X1_A_Z_risingDelay = mkTimingTable 8 6 lookTrAxis_BUF_X1_A_Z_risingDelay lookCapAxis_BUF_X1_A_Z_risingDelay lookTable_BUF_X1_A_Z_risingDelay + +foreign import ccall "timing.h lookTrAxis_BUF_X1_A_Z_fallingDelay" lookTrAxis_BUF_X1_A_Z_fallingDelay :: CInt -> CDouble +foreign import ccall "timing.h lookCapAxis_BUF_X1_A_Z_fallingDelay" lookCapAxis_BUF_X1_A_Z_fallingDelay :: CInt -> CDouble +foreign import ccall "timing.h lookTable_BUF_X1_A_Z_fallingDelay" lookTable_BUF_X1_A_Z_fallingDelay :: CInt -> CInt -> CDouble +table_BUF_X1_A_Z_fallingDelay :: Table2D CInt TransitionTime Capacitance Time +table_BUF_X1_A_Z_fallingDelay = mkTimingTable 8 6 lookTrAxis_BUF_X1_A_Z_fallingDelay lookCapAxis_BUF_X1_A_Z_fallingDelay lookTable_BUF_X1_A_Z_fallingDelay + +foreign import ccall "timing.h lookTrAxis_BUF_X1_A_Z_risingTransition" lookTrAxis_BUF_X1_A_Z_risingTransition :: CInt -> CDouble +foreign import ccall "timing.h lookCapAxis_BUF_X1_A_Z_risingTransition" lookCapAxis_BUF_X1_A_Z_risingTransition :: CInt -> CDouble +foreign import ccall "timing.h lookTable_BUF_X1_A_Z_risingTransition" lookTable_BUF_X1_A_Z_risingTransition :: CInt -> CInt -> CDouble +table_BUF_X1_A_Z_risingTransition :: Table2D CInt TransitionTime Capacitance TransitionTime +table_BUF_X1_A_Z_risingTransition = mkTimingTable 8 6 lookTrAxis_BUF_X1_A_Z_risingTransition lookCapAxis_BUF_X1_A_Z_risingTransition lookTable_BUF_X1_A_Z_risingTransition + +foreign import ccall "timing.h lookTrAxis_BUF_X1_A_Z_fallingTransition" lookTrAxis_BUF_X1_A_Z_fallingTransition :: CInt -> CDouble +foreign import ccall "timing.h lookCapAxis_BUF_X1_A_Z_fallingTransition" lookCapAxis_BUF_X1_A_Z_fallingTransition :: CInt -> CDouble +foreign import ccall "timing.h lookTable_BUF_X1_A_Z_fallingTransition" lookTable_BUF_X1_A_Z_fallingTransition :: CInt -> CInt -> CDouble +table_BUF_X1_A_Z_fallingTransition :: Table2D CInt TransitionTime Capacitance TransitionTime +table_BUF_X1_A_Z_fallingTransition = mkTimingTable 8 6 lookTrAxis_BUF_X1_A_Z_fallingTransition lookCapAxis_BUF_X1_A_Z_fallingTransition lookTable_BUF_X1_A_Z_fallingTransition + +foreign import ccall "timing.h lookTrAxis_BUF_X16_A_Z_risingDelay" lookTrAxis_BUF_X16_A_Z_risingDelay :: CInt -> CDouble +foreign import ccall "timing.h lookCapAxis_BUF_X16_A_Z_risingDelay" lookCapAxis_BUF_X16_A_Z_risingDelay :: CInt -> CDouble +foreign import ccall "timing.h lookTable_BUF_X16_A_Z_risingDelay" lookTable_BUF_X16_A_Z_risingDelay :: CInt -> CInt -> CDouble +table_BUF_X16_A_Z_risingDelay :: Table2D CInt TransitionTime Capacitance Time +table_BUF_X16_A_Z_risingDelay = mkTimingTable 8 6 lookTrAxis_BUF_X16_A_Z_risingDelay lookCapAxis_BUF_X16_A_Z_risingDelay lookTable_BUF_X16_A_Z_risingDelay + +foreign import ccall "timing.h lookTrAxis_BUF_X16_A_Z_fallingDelay" lookTrAxis_BUF_X16_A_Z_fallingDelay :: CInt -> CDouble +foreign import ccall "timing.h lookCapAxis_BUF_X16_A_Z_fallingDelay" lookCapAxis_BUF_X16_A_Z_fallingDelay :: CInt -> CDouble +foreign import ccall "timing.h lookTable_BUF_X16_A_Z_fallingDelay" lookTable_BUF_X16_A_Z_fallingDelay :: CInt -> CInt -> CDouble +table_BUF_X16_A_Z_fallingDelay :: Table2D CInt TransitionTime Capacitance Time +table_BUF_X16_A_Z_fallingDelay = mkTimingTable 8 6 lookTrAxis_BUF_X16_A_Z_fallingDelay lookCapAxis_BUF_X16_A_Z_fallingDelay lookTable_BUF_X16_A_Z_fallingDelay + +foreign import ccall "timing.h lookTrAxis_BUF_X16_A_Z_risingTransition" lookTrAxis_BUF_X16_A_Z_risingTransition :: CInt -> CDouble +foreign import ccall "timing.h lookCapAxis_BUF_X16_A_Z_risingTransition" lookCapAxis_BUF_X16_A_Z_risingTransition :: CInt -> CDouble +foreign import ccall "timing.h lookTable_BUF_X16_A_Z_risingTransition" lookTable_BUF_X16_A_Z_risingTransition :: CInt -> CInt -> CDouble +table_BUF_X16_A_Z_risingTransition :: Table2D CInt TransitionTime Capacitance TransitionTime +table_BUF_X16_A_Z_risingTransition = mkTimingTable 8 6 lookTrAxis_BUF_X16_A_Z_risingTransition lookCapAxis_BUF_X16_A_Z_risingTransition lookTable_BUF_X16_A_Z_risingTransition + +foreign import ccall "timing.h lookTrAxis_BUF_X16_A_Z_fallingTransition" lookTrAxis_BUF_X16_A_Z_fallingTransition :: CInt -> CDouble +foreign import ccall "timing.h lookCapAxis_BUF_X16_A_Z_fallingTransition" lookCapAxis_BUF_X16_A_Z_fallingTransition :: CInt -> CDouble +foreign import ccall "timing.h lookTable_BUF_X16_A_Z_fallingTransition" lookTable_BUF_X16_A_Z_fallingTransition :: CInt -> CInt -> CDouble +table_BUF_X16_A_Z_fallingTransition :: Table2D CInt TransitionTime Capacitance TransitionTime +table_BUF_X16_A_Z_fallingTransition = mkTimingTable 8 6 lookTrAxis_BUF_X16_A_Z_fallingTransition lookCapAxis_BUF_X16_A_Z_fallingTransition lookTable_BUF_X16_A_Z_fallingTransition + +foreign import ccall "timing.h lookTrAxis_BUF_X2_A_Z_risingDelay" lookTrAxis_BUF_X2_A_Z_risingDelay :: CInt -> CDouble +foreign import ccall "timing.h lookCapAxis_BUF_X2_A_Z_risingDelay" lookCapAxis_BUF_X2_A_Z_risingDelay :: CInt -> CDouble +foreign import ccall "timing.h lookTable_BUF_X2_A_Z_risingDelay" lookTable_BUF_X2_A_Z_risingDelay :: CInt -> CInt -> CDouble +table_BUF_X2_A_Z_risingDelay :: Table2D CInt TransitionTime Capacitance Time +table_BUF_X2_A_Z_risingDelay = mkTimingTable 8 6 lookTrAxis_BUF_X2_A_Z_risingDelay lookCapAxis_BUF_X2_A_Z_risingDelay lookTable_BUF_X2_A_Z_risingDelay + +foreign import ccall "timing.h lookTrAxis_BUF_X2_A_Z_fallingDelay" lookTrAxis_BUF_X2_A_Z_fallingDelay :: CInt -> CDouble +foreign import ccall "timing.h lookCapAxis_BUF_X2_A_Z_fallingDelay" lookCapAxis_BUF_X2_A_Z_fallingDelay :: CInt -> CDouble +foreign import ccall "timing.h lookTable_BUF_X2_A_Z_fallingDelay" lookTable_BUF_X2_A_Z_fallingDelay :: CInt -> CInt -> CDouble +table_BUF_X2_A_Z_fallingDelay :: Table2D CInt TransitionTime Capacitance Time +table_BUF_X2_A_Z_fallingDelay = mkTimingTable 8 6 lookTrAxis_BUF_X2_A_Z_fallingDelay lookCapAxis_BUF_X2_A_Z_fallingDelay lookTable_BUF_X2_A_Z_fallingDelay + +foreign import ccall "timing.h lookTrAxis_BUF_X2_A_Z_risingTransition" lookTrAxis_BUF_X2_A_Z_risingTransition :: CInt -> CDouble +foreign import ccall "timing.h lookCapAxis_BUF_X2_A_Z_risingTransition" lookCapAxis_BUF_X2_A_Z_risingTransition :: CInt -> CDouble +foreign import ccall "timing.h lookTable_BUF_X2_A_Z_risingTransition" lookTable_BUF_X2_A_Z_risingTransition :: CInt -> CInt -> CDouble +table_BUF_X2_A_Z_risingTransition :: Table2D CInt TransitionTime Capacitance TransitionTime +table_BUF_X2_A_Z_risingTransition = mkTimingTable 8 6 lookTrAxis_BUF_X2_A_Z_risingTransition lookCapAxis_BUF_X2_A_Z_risingTransition lookTable_BUF_X2_A_Z_risingTransition + +foreign import ccall "timing.h lookTrAxis_BUF_X2_A_Z_fallingTransition" lookTrAxis_BUF_X2_A_Z_fallingTransition :: CInt -> CDouble +foreign import ccall "timing.h lookCapAxis_BUF_X2_A_Z_fallingTransition" lookCapAxis_BUF_X2_A_Z_fallingTransition :: CInt -> CDouble +foreign import ccall "timing.h lookTable_BUF_X2_A_Z_fallingTransition" lookTable_BUF_X2_A_Z_fallingTransition :: CInt -> CInt -> CDouble +table_BUF_X2_A_Z_fallingTransition :: Table2D CInt TransitionTime Capacitance TransitionTime +table_BUF_X2_A_Z_fallingTransition = mkTimingTable 8 6 lookTrAxis_BUF_X2_A_Z_fallingTransition lookCapAxis_BUF_X2_A_Z_fallingTransition lookTable_BUF_X2_A_Z_fallingTransition + +foreign import ccall "timing.h lookTrAxis_BUF_X32_A_Z_risingDelay" lookTrAxis_BUF_X32_A_Z_risingDelay :: CInt -> CDouble +foreign import ccall "timing.h lookCapAxis_BUF_X32_A_Z_risingDelay" lookCapAxis_BUF_X32_A_Z_risingDelay :: CInt -> CDouble +foreign import ccall "timing.h lookTable_BUF_X32_A_Z_risingDelay" lookTable_BUF_X32_A_Z_risingDelay :: CInt -> CInt -> CDouble +table_BUF_X32_A_Z_risingDelay :: Table2D CInt TransitionTime Capacitance Time +table_BUF_X32_A_Z_risingDelay = mkTimingTable 8 6 lookTrAxis_BUF_X32_A_Z_risingDelay lookCapAxis_BUF_X32_A_Z_risingDelay lookTable_BUF_X32_A_Z_risingDelay + +foreign import ccall "timing.h lookTrAxis_BUF_X32_A_Z_fallingDelay" lookTrAxis_BUF_X32_A_Z_fallingDelay :: CInt -> CDouble +foreign import ccall "timing.h lookCapAxis_BUF_X32_A_Z_fallingDelay" lookCapAxis_BUF_X32_A_Z_fallingDelay :: CInt -> CDouble +foreign import ccall "timing.h lookTable_BUF_X32_A_Z_fallingDelay" lookTable_BUF_X32_A_Z_fallingDelay :: CInt -> CInt -> CDouble +table_BUF_X32_A_Z_fallingDelay :: Table2D CInt TransitionTime Capacitance Time +table_BUF_X32_A_Z_fallingDelay = mkTimingTable 8 6 lookTrAxis_BUF_X32_A_Z_fallingDelay lookCapAxis_BUF_X32_A_Z_fallingDelay lookTable_BUF_X32_A_Z_fallingDelay + +foreign import ccall "timing.h lookTrAxis_BUF_X32_A_Z_risingTransition" lookTrAxis_BUF_X32_A_Z_risingTransition :: CInt -> CDouble +foreign import ccall "timing.h lookCapAxis_BUF_X32_A_Z_risingTransition" lookCapAxis_BUF_X32_A_Z_risingTransition :: CInt -> CDouble +foreign import ccall "timing.h lookTable_BUF_X32_A_Z_risingTransition" lookTable_BUF_X32_A_Z_risingTransition :: CInt -> CInt -> CDouble +table_BUF_X32_A_Z_risingTransition :: Table2D CInt TransitionTime Capacitance TransitionTime +table_BUF_X32_A_Z_risingTransition = mkTimingTable 8 6 lookTrAxis_BUF_X32_A_Z_risingTransition lookCapAxis_BUF_X32_A_Z_risingTransition lookTable_BUF_X32_A_Z_risingTransition + +foreign import ccall "timing.h lookTrAxis_BUF_X32_A_Z_fallingTransition" lookTrAxis_BUF_X32_A_Z_fallingTransition :: CInt -> CDouble +foreign import ccall "timing.h lookCapAxis_BUF_X32_A_Z_fallingTransition" lookCapAxis_BUF_X32_A_Z_fallingTransition :: CInt -> CDouble +foreign import ccall "timing.h lookTable_BUF_X32_A_Z_fallingTransition" lookTable_BUF_X32_A_Z_fallingTransition :: CInt -> CInt -> CDouble +table_BUF_X32_A_Z_fallingTransition :: Table2D CInt TransitionTime Capacitance TransitionTime +table_BUF_X32_A_Z_fallingTransition = mkTimingTable 8 6 lookTrAxis_BUF_X32_A_Z_fallingTransition lookCapAxis_BUF_X32_A_Z_fallingTransition lookTable_BUF_X32_A_Z_fallingTransition + +foreign import ccall "timing.h lookTrAxis_BUF_X4_A_Z_risingDelay" lookTrAxis_BUF_X4_A_Z_risingDelay :: CInt -> CDouble +foreign import ccall "timing.h lookCapAxis_BUF_X4_A_Z_risingDelay" lookCapAxis_BUF_X4_A_Z_risingDelay :: CInt -> CDouble +foreign import ccall "timing.h lookTable_BUF_X4_A_Z_risingDelay" lookTable_BUF_X4_A_Z_risingDelay :: CInt -> CInt -> CDouble +table_BUF_X4_A_Z_risingDelay :: Table2D CInt TransitionTime Capacitance Time +table_BUF_X4_A_Z_risingDelay = mkTimingTable 8 6 lookTrAxis_BUF_X4_A_Z_risingDelay lookCapAxis_BUF_X4_A_Z_risingDelay lookTable_BUF_X4_A_Z_risingDelay + +foreign import ccall "timing.h lookTrAxis_BUF_X4_A_Z_fallingDelay" lookTrAxis_BUF_X4_A_Z_fallingDelay :: CInt -> CDouble +foreign import ccall "timing.h lookCapAxis_BUF_X4_A_Z_fallingDelay" lookCapAxis_BUF_X4_A_Z_fallingDelay :: CInt -> CDouble +foreign import ccall "timing.h lookTable_BUF_X4_A_Z_fallingDelay" lookTable_BUF_X4_A_Z_fallingDelay :: CInt -> CInt -> CDouble +table_BUF_X4_A_Z_fallingDelay :: Table2D CInt TransitionTime Capacitance Time +table_BUF_X4_A_Z_fallingDelay = mkTimingTable 8 6 lookTrAxis_BUF_X4_A_Z_fallingDelay lookCapAxis_BUF_X4_A_Z_fallingDelay lookTable_BUF_X4_A_Z_fallingDelay + +foreign import ccall "timing.h lookTrAxis_BUF_X4_A_Z_risingTransition" lookTrAxis_BUF_X4_A_Z_risingTransition :: CInt -> CDouble +foreign import ccall "timing.h lookCapAxis_BUF_X4_A_Z_risingTransition" lookCapAxis_BUF_X4_A_Z_risingTransition :: CInt -> CDouble +foreign import ccall "timing.h lookTable_BUF_X4_A_Z_risingTransition" lookTable_BUF_X4_A_Z_risingTransition :: CInt -> CInt -> CDouble +table_BUF_X4_A_Z_risingTransition :: Table2D CInt TransitionTime Capacitance TransitionTime +table_BUF_X4_A_Z_risingTransition = mkTimingTable 8 6 lookTrAxis_BUF_X4_A_Z_risingTransition lookCapAxis_BUF_X4_A_Z_risingTransition lookTable_BUF_X4_A_Z_risingTransition + +foreign import ccall "timing.h lookTrAxis_BUF_X4_A_Z_fallingTransition" lookTrAxis_BUF_X4_A_Z_fallingTransition :: CInt -> CDouble +foreign import ccall "timing.h lookCapAxis_BUF_X4_A_Z_fallingTransition" lookCapAxis_BUF_X4_A_Z_fallingTransition :: CInt -> CDouble +foreign import ccall "timing.h lookTable_BUF_X4_A_Z_fallingTransition" lookTable_BUF_X4_A_Z_fallingTransition :: CInt -> CInt -> CDouble +table_BUF_X4_A_Z_fallingTransition :: Table2D CInt TransitionTime Capacitance TransitionTime +table_BUF_X4_A_Z_fallingTransition = mkTimingTable 8 6 lookTrAxis_BUF_X4_A_Z_fallingTransition lookCapAxis_BUF_X4_A_Z_fallingTransition lookTable_BUF_X4_A_Z_fallingTransition + +foreign import ccall "timing.h lookTrAxis_BUF_X8_A_Z_risingDelay" lookTrAxis_BUF_X8_A_Z_risingDelay :: CInt -> CDouble +foreign import ccall "timing.h lookCapAxis_BUF_X8_A_Z_risingDelay" lookCapAxis_BUF_X8_A_Z_risingDelay :: CInt -> CDouble +foreign import ccall "timing.h lookTable_BUF_X8_A_Z_risingDelay" lookTable_BUF_X8_A_Z_risingDelay :: CInt -> CInt -> CDouble +table_BUF_X8_A_Z_risingDelay :: Table2D CInt TransitionTime Capacitance Time +table_BUF_X8_A_Z_risingDelay = mkTimingTable 8 6 lookTrAxis_BUF_X8_A_Z_risingDelay lookCapAxis_BUF_X8_A_Z_risingDelay lookTable_BUF_X8_A_Z_risingDelay + +foreign import ccall "timing.h lookTrAxis_BUF_X8_A_Z_fallingDelay" lookTrAxis_BUF_X8_A_Z_fallingDelay :: CInt -> CDouble +foreign import ccall "timing.h lookCapAxis_BUF_X8_A_Z_fallingDelay" lookCapAxis_BUF_X8_A_Z_fallingDelay :: CInt -> CDouble +foreign import ccall "timing.h lookTable_BUF_X8_A_Z_fallingDelay" lookTable_BUF_X8_A_Z_fallingDelay :: CInt -> CInt -> CDouble +table_BUF_X8_A_Z_fallingDelay :: Table2D CInt TransitionTime Capacitance Time +table_BUF_X8_A_Z_fallingDelay = mkTimingTable 8 6 lookTrAxis_BUF_X8_A_Z_fallingDelay lookCapAxis_BUF_X8_A_Z_fallingDelay lookTable_BUF_X8_A_Z_fallingDelay + +foreign import ccall "timing.h lookTrAxis_BUF_X8_A_Z_risingTransition" lookTrAxis_BUF_X8_A_Z_risingTransition :: CInt -> CDouble +foreign import ccall "timing.h lookCapAxis_BUF_X8_A_Z_risingTransition" lookCapAxis_BUF_X8_A_Z_risingTransition :: CInt -> CDouble +foreign import ccall "timing.h lookTable_BUF_X8_A_Z_risingTransition" lookTable_BUF_X8_A_Z_risingTransition :: CInt -> CInt -> CDouble +table_BUF_X8_A_Z_risingTransition :: Table2D CInt TransitionTime Capacitance TransitionTime +table_BUF_X8_A_Z_risingTransition = mkTimingTable 8 6 lookTrAxis_BUF_X8_A_Z_risingTransition lookCapAxis_BUF_X8_A_Z_risingTransition lookTable_BUF_X8_A_Z_risingTransition + +foreign import ccall "timing.h lookTrAxis_BUF_X8_A_Z_fallingTransition" lookTrAxis_BUF_X8_A_Z_fallingTransition :: CInt -> CDouble +foreign import ccall "timing.h lookCapAxis_BUF_X8_A_Z_fallingTransition" lookCapAxis_BUF_X8_A_Z_fallingTransition :: CInt -> CDouble +foreign import ccall "timing.h lookTable_BUF_X8_A_Z_fallingTransition" lookTable_BUF_X8_A_Z_fallingTransition :: CInt -> CInt -> CDouble +table_BUF_X8_A_Z_fallingTransition :: Table2D CInt TransitionTime Capacitance TransitionTime +table_BUF_X8_A_Z_fallingTransition = mkTimingTable 8 6 lookTrAxis_BUF_X8_A_Z_fallingTransition lookCapAxis_BUF_X8_A_Z_fallingTransition lookTable_BUF_X8_A_Z_fallingTransition + +foreign import ccall "timing.h lookTrAxis_FA_X1_A_CO_risingDelay" lookTrAxis_FA_X1_A_CO_risingDelay :: CInt -> CDouble +foreign import ccall "timing.h lookCapAxis_FA_X1_A_CO_risingDelay" lookCapAxis_FA_X1_A_CO_risingDelay :: CInt -> CDouble +foreign import ccall "timing.h lookTable_FA_X1_A_CO_risingDelay" lookTable_FA_X1_A_CO_risingDelay :: CInt -> CInt -> CDouble +table_FA_X1_A_CO_risingDelay :: Table2D CInt TransitionTime Capacitance Time +table_FA_X1_A_CO_risingDelay = mkTimingTable 8 6 lookTrAxis_FA_X1_A_CO_risingDelay lookCapAxis_FA_X1_A_CO_risingDelay lookTable_FA_X1_A_CO_risingDelay + +foreign import ccall "timing.h lookTrAxis_FA_X1_A_CO_fallingDelay" lookTrAxis_FA_X1_A_CO_fallingDelay :: CInt -> CDouble +foreign import ccall "timing.h lookCapAxis_FA_X1_A_CO_fallingDelay" lookCapAxis_FA_X1_A_CO_fallingDelay :: CInt -> CDouble +foreign import ccall "timing.h lookTable_FA_X1_A_CO_fallingDelay" lookTable_FA_X1_A_CO_fallingDelay :: CInt -> CInt -> CDouble +table_FA_X1_A_CO_fallingDelay :: Table2D CInt TransitionTime Capacitance Time +table_FA_X1_A_CO_fallingDelay = mkTimingTable 8 6 lookTrAxis_FA_X1_A_CO_fallingDelay lookCapAxis_FA_X1_A_CO_fallingDelay lookTable_FA_X1_A_CO_fallingDelay + +foreign import ccall "timing.h lookTrAxis_FA_X1_A_CO_risingTransition" lookTrAxis_FA_X1_A_CO_risingTransition :: CInt -> CDouble +foreign import ccall "timing.h lookCapAxis_FA_X1_A_CO_risingTransition" lookCapAxis_FA_X1_A_CO_risingTransition :: CInt -> CDouble +foreign import ccall "timing.h lookTable_FA_X1_A_CO_risingTransition" lookTable_FA_X1_A_CO_risingTransition :: CInt -> CInt -> CDouble +table_FA_X1_A_CO_risingTransition :: Table2D CInt TransitionTime Capacitance TransitionTime +table_FA_X1_A_CO_risingTransition = mkTimingTable 8 6 lookTrAxis_FA_X1_A_CO_risingTransition lookCapAxis_FA_X1_A_CO_risingTransition lookTable_FA_X1_A_CO_risingTransition + +foreign import ccall "timing.h lookTrAxis_FA_X1_A_CO_fallingTransition" lookTrAxis_FA_X1_A_CO_fallingTransition :: CInt -> CDouble +foreign import ccall "timing.h lookCapAxis_FA_X1_A_CO_fallingTransition" lookCapAxis_FA_X1_A_CO_fallingTransition :: CInt -> CDouble +foreign import ccall "timing.h lookTable_FA_X1_A_CO_fallingTransition" lookTable_FA_X1_A_CO_fallingTransition :: CInt -> CInt -> CDouble +table_FA_X1_A_CO_fallingTransition :: Table2D CInt TransitionTime Capacitance TransitionTime +table_FA_X1_A_CO_fallingTransition = mkTimingTable 8 6 lookTrAxis_FA_X1_A_CO_fallingTransition lookCapAxis_FA_X1_A_CO_fallingTransition lookTable_FA_X1_A_CO_fallingTransition + +foreign import ccall "timing.h lookTrAxis_FA_X1_A_S_risingDelay" lookTrAxis_FA_X1_A_S_risingDelay :: CInt -> CDouble +foreign import ccall "timing.h lookCapAxis_FA_X1_A_S_risingDelay" lookCapAxis_FA_X1_A_S_risingDelay :: CInt -> CDouble +foreign import ccall "timing.h lookTable_FA_X1_A_S_risingDelay" lookTable_FA_X1_A_S_risingDelay :: CInt -> CInt -> CDouble +table_FA_X1_A_S_risingDelay :: Table2D CInt TransitionTime Capacitance Time +table_FA_X1_A_S_risingDelay = mkTimingTable 8 6 lookTrAxis_FA_X1_A_S_risingDelay lookCapAxis_FA_X1_A_S_risingDelay lookTable_FA_X1_A_S_risingDelay + +foreign import ccall "timing.h lookTrAxis_FA_X1_A_S_fallingDelay" lookTrAxis_FA_X1_A_S_fallingDelay :: CInt -> CDouble +foreign import ccall "timing.h lookCapAxis_FA_X1_A_S_fallingDelay" lookCapAxis_FA_X1_A_S_fallingDelay :: CInt -> CDouble +foreign import ccall "timing.h lookTable_FA_X1_A_S_fallingDelay" lookTable_FA_X1_A_S_fallingDelay :: CInt -> CInt -> CDouble +table_FA_X1_A_S_fallingDelay :: Table2D CInt TransitionTime Capacitance Time +table_FA_X1_A_S_fallingDelay = mkTimingTable 8 6 lookTrAxis_FA_X1_A_S_fallingDelay lookCapAxis_FA_X1_A_S_fallingDelay lookTable_FA_X1_A_S_fallingDelay + +foreign import ccall "timing.h lookTrAxis_FA_X1_A_S_risingTransition" lookTrAxis_FA_X1_A_S_risingTransition :: CInt -> CDouble +foreign import ccall "timing.h lookCapAxis_FA_X1_A_S_risingTransition" lookCapAxis_FA_X1_A_S_risingTransition :: CInt -> CDouble +foreign import ccall "timing.h lookTable_FA_X1_A_S_risingTransition" lookTable_FA_X1_A_S_risingTransition :: CInt -> CInt -> CDouble +table_FA_X1_A_S_risingTransition :: Table2D CInt TransitionTime Capacitance TransitionTime +table_FA_X1_A_S_risingTransition = mkTimingTable 8 6 lookTrAxis_FA_X1_A_S_risingTransition lookCapAxis_FA_X1_A_S_risingTransition lookTable_FA_X1_A_S_risingTransition + +foreign import ccall "timing.h lookTrAxis_FA_X1_A_S_fallingTransition" lookTrAxis_FA_X1_A_S_fallingTransition :: CInt -> CDouble +foreign import ccall "timing.h lookCapAxis_FA_X1_A_S_fallingTransition" lookCapAxis_FA_X1_A_S_fallingTransition :: CInt -> CDouble +foreign import ccall "timing.h lookTable_FA_X1_A_S_fallingTransition" lookTable_FA_X1_A_S_fallingTransition :: CInt -> CInt -> CDouble +table_FA_X1_A_S_fallingTransition :: Table2D CInt TransitionTime Capacitance TransitionTime +table_FA_X1_A_S_fallingTransition = mkTimingTable 8 6 lookTrAxis_FA_X1_A_S_fallingTransition lookCapAxis_FA_X1_A_S_fallingTransition lookTable_FA_X1_A_S_fallingTransition + +foreign import ccall "timing.h lookTrAxis_FA_X1_B_CO_risingDelay" lookTrAxis_FA_X1_B_CO_risingDelay :: CInt -> CDouble +foreign import ccall "timing.h lookCapAxis_FA_X1_B_CO_risingDelay" lookCapAxis_FA_X1_B_CO_risingDelay :: CInt -> CDouble +foreign import ccall "timing.h lookTable_FA_X1_B_CO_risingDelay" lookTable_FA_X1_B_CO_risingDelay :: CInt -> CInt -> CDouble +table_FA_X1_B_CO_risingDelay :: Table2D CInt TransitionTime Capacitance Time +table_FA_X1_B_CO_risingDelay = mkTimingTable 8 6 lookTrAxis_FA_X1_B_CO_risingDelay lookCapAxis_FA_X1_B_CO_risingDelay lookTable_FA_X1_B_CO_risingDelay + +foreign import ccall "timing.h lookTrAxis_FA_X1_B_CO_fallingDelay" lookTrAxis_FA_X1_B_CO_fallingDelay :: CInt -> CDouble +foreign import ccall "timing.h lookCapAxis_FA_X1_B_CO_fallingDelay" lookCapAxis_FA_X1_B_CO_fallingDelay :: CInt -> CDouble +foreign import ccall "timing.h lookTable_FA_X1_B_CO_fallingDelay" lookTable_FA_X1_B_CO_fallingDelay :: CInt -> CInt -> CDouble +table_FA_X1_B_CO_fallingDelay :: Table2D CInt TransitionTime Capacitance Time +table_FA_X1_B_CO_fallingDelay = mkTimingTable 8 6 lookTrAxis_FA_X1_B_CO_fallingDelay lookCapAxis_FA_X1_B_CO_fallingDelay lookTable_FA_X1_B_CO_fallingDelay + +foreign import ccall "timing.h lookTrAxis_FA_X1_B_CO_risingTransition" lookTrAxis_FA_X1_B_CO_risingTransition :: CInt -> CDouble +foreign import ccall "timing.h lookCapAxis_FA_X1_B_CO_risingTransition" lookCapAxis_FA_X1_B_CO_risingTransition :: CInt -> CDouble +foreign import ccall "timing.h lookTable_FA_X1_B_CO_risingTransition" lookTable_FA_X1_B_CO_risingTransition :: CInt -> CInt -> CDouble +table_FA_X1_B_CO_risingTransition :: Table2D CInt TransitionTime Capacitance TransitionTime +table_FA_X1_B_CO_risingTransition = mkTimingTable 8 6 lookTrAxis_FA_X1_B_CO_risingTransition lookCapAxis_FA_X1_B_CO_risingTransition lookTable_FA_X1_B_CO_risingTransition + +foreign import ccall "timing.h lookTrAxis_FA_X1_B_CO_fallingTransition" lookTrAxis_FA_X1_B_CO_fallingTransition :: CInt -> CDouble +foreign import ccall "timing.h lookCapAxis_FA_X1_B_CO_fallingTransition" lookCapAxis_FA_X1_B_CO_fallingTransition :: CInt -> CDouble +foreign import ccall "timing.h lookTable_FA_X1_B_CO_fallingTransition" lookTable_FA_X1_B_CO_fallingTransition :: CInt -> CInt -> CDouble +table_FA_X1_B_CO_fallingTransition :: Table2D CInt TransitionTime Capacitance TransitionTime +table_FA_X1_B_CO_fallingTransition = mkTimingTable 8 6 lookTrAxis_FA_X1_B_CO_fallingTransition lookCapAxis_FA_X1_B_CO_fallingTransition lookTable_FA_X1_B_CO_fallingTransition + +foreign import ccall "timing.h lookTrAxis_FA_X1_B_S_risingDelay" lookTrAxis_FA_X1_B_S_risingDelay :: CInt -> CDouble +foreign import ccall "timing.h lookCapAxis_FA_X1_B_S_risingDelay" lookCapAxis_FA_X1_B_S_risingDelay :: CInt -> CDouble +foreign import ccall "timing.h lookTable_FA_X1_B_S_risingDelay" lookTable_FA_X1_B_S_risingDelay :: CInt -> CInt -> CDouble +table_FA_X1_B_S_risingDelay :: Table2D CInt TransitionTime Capacitance Time +table_FA_X1_B_S_risingDelay = mkTimingTable 8 6 lookTrAxis_FA_X1_B_S_risingDelay lookCapAxis_FA_X1_B_S_risingDelay lookTable_FA_X1_B_S_risingDelay + +foreign import ccall "timing.h lookTrAxis_FA_X1_B_S_fallingDelay" lookTrAxis_FA_X1_B_S_fallingDelay :: CInt -> CDouble +foreign import ccall "timing.h lookCapAxis_FA_X1_B_S_fallingDelay" lookCapAxis_FA_X1_B_S_fallingDelay :: CInt -> CDouble +foreign import ccall "timing.h lookTable_FA_X1_B_S_fallingDelay" lookTable_FA_X1_B_S_fallingDelay :: CInt -> CInt -> CDouble +table_FA_X1_B_S_fallingDelay :: Table2D CInt TransitionTime Capacitance Time +table_FA_X1_B_S_fallingDelay = mkTimingTable 8 6 lookTrAxis_FA_X1_B_S_fallingDelay lookCapAxis_FA_X1_B_S_fallingDelay lookTable_FA_X1_B_S_fallingDelay + +foreign import ccall "timing.h lookTrAxis_FA_X1_B_S_risingTransition" lookTrAxis_FA_X1_B_S_risingTransition :: CInt -> CDouble +foreign import ccall "timing.h lookCapAxis_FA_X1_B_S_risingTransition" lookCapAxis_FA_X1_B_S_risingTransition :: CInt -> CDouble +foreign import ccall "timing.h lookTable_FA_X1_B_S_risingTransition" lookTable_FA_X1_B_S_risingTransition :: CInt -> CInt -> CDouble +table_FA_X1_B_S_risingTransition :: Table2D CInt TransitionTime Capacitance TransitionTime +table_FA_X1_B_S_risingTransition = mkTimingTable 8 6 lookTrAxis_FA_X1_B_S_risingTransition lookCapAxis_FA_X1_B_S_risingTransition lookTable_FA_X1_B_S_risingTransition + +foreign import ccall "timing.h lookTrAxis_FA_X1_B_S_fallingTransition" lookTrAxis_FA_X1_B_S_fallingTransition :: CInt -> CDouble +foreign import ccall "timing.h lookCapAxis_FA_X1_B_S_fallingTransition" lookCapAxis_FA_X1_B_S_fallingTransition :: CInt -> CDouble +foreign import ccall "timing.h lookTable_FA_X1_B_S_fallingTransition" lookTable_FA_X1_B_S_fallingTransition :: CInt -> CInt -> CDouble +table_FA_X1_B_S_fallingTransition :: Table2D CInt TransitionTime Capacitance TransitionTime +table_FA_X1_B_S_fallingTransition = mkTimingTable 8 6 lookTrAxis_FA_X1_B_S_fallingTransition lookCapAxis_FA_X1_B_S_fallingTransition lookTable_FA_X1_B_S_fallingTransition + +foreign import ccall "timing.h lookTrAxis_FA_X1_CI_CO_risingDelay" lookTrAxis_FA_X1_CI_CO_risingDelay :: CInt -> CDouble +foreign import ccall "timing.h lookCapAxis_FA_X1_CI_CO_risingDelay" lookCapAxis_FA_X1_CI_CO_risingDelay :: CInt -> CDouble +foreign import ccall "timing.h lookTable_FA_X1_CI_CO_risingDelay" lookTable_FA_X1_CI_CO_risingDelay :: CInt -> CInt -> CDouble +table_FA_X1_CI_CO_risingDelay :: Table2D CInt TransitionTime Capacitance Time +table_FA_X1_CI_CO_risingDelay = mkTimingTable 8 6 lookTrAxis_FA_X1_CI_CO_risingDelay lookCapAxis_FA_X1_CI_CO_risingDelay lookTable_FA_X1_CI_CO_risingDelay + +foreign import ccall "timing.h lookTrAxis_FA_X1_CI_CO_fallingDelay" lookTrAxis_FA_X1_CI_CO_fallingDelay :: CInt -> CDouble +foreign import ccall "timing.h lookCapAxis_FA_X1_CI_CO_fallingDelay" lookCapAxis_FA_X1_CI_CO_fallingDelay :: CInt -> CDouble +foreign import ccall "timing.h lookTable_FA_X1_CI_CO_fallingDelay" lookTable_FA_X1_CI_CO_fallingDelay :: CInt -> CInt -> CDouble +table_FA_X1_CI_CO_fallingDelay :: Table2D CInt TransitionTime Capacitance Time +table_FA_X1_CI_CO_fallingDelay = mkTimingTable 8 6 lookTrAxis_FA_X1_CI_CO_fallingDelay lookCapAxis_FA_X1_CI_CO_fallingDelay lookTable_FA_X1_CI_CO_fallingDelay + +foreign import ccall "timing.h lookTrAxis_FA_X1_CI_CO_risingTransition" lookTrAxis_FA_X1_CI_CO_risingTransition :: CInt -> CDouble +foreign import ccall "timing.h lookCapAxis_FA_X1_CI_CO_risingTransition" lookCapAxis_FA_X1_CI_CO_risingTransition :: CInt -> CDouble +foreign import ccall "timing.h lookTable_FA_X1_CI_CO_risingTransition" lookTable_FA_X1_CI_CO_risingTransition :: CInt -> CInt -> CDouble +table_FA_X1_CI_CO_risingTransition :: Table2D CInt TransitionTime Capacitance TransitionTime +table_FA_X1_CI_CO_risingTransition = mkTimingTable 8 6 lookTrAxis_FA_X1_CI_CO_risingTransition lookCapAxis_FA_X1_CI_CO_risingTransition lookTable_FA_X1_CI_CO_risingTransition + +foreign import ccall "timing.h lookTrAxis_FA_X1_CI_CO_fallingTransition" lookTrAxis_FA_X1_CI_CO_fallingTransition :: CInt -> CDouble +foreign import ccall "timing.h lookCapAxis_FA_X1_CI_CO_fallingTransition" lookCapAxis_FA_X1_CI_CO_fallingTransition :: CInt -> CDouble +foreign import ccall "timing.h lookTable_FA_X1_CI_CO_fallingTransition" lookTable_FA_X1_CI_CO_fallingTransition :: CInt -> CInt -> CDouble +table_FA_X1_CI_CO_fallingTransition :: Table2D CInt TransitionTime Capacitance TransitionTime +table_FA_X1_CI_CO_fallingTransition = mkTimingTable 8 6 lookTrAxis_FA_X1_CI_CO_fallingTransition lookCapAxis_FA_X1_CI_CO_fallingTransition lookTable_FA_X1_CI_CO_fallingTransition + +foreign import ccall "timing.h lookTrAxis_FA_X1_CI_S_risingDelay" lookTrAxis_FA_X1_CI_S_risingDelay :: CInt -> CDouble +foreign import ccall "timing.h lookCapAxis_FA_X1_CI_S_risingDelay" lookCapAxis_FA_X1_CI_S_risingDelay :: CInt -> CDouble +foreign import ccall "timing.h lookTable_FA_X1_CI_S_risingDelay" lookTable_FA_X1_CI_S_risingDelay :: CInt -> CInt -> CDouble +table_FA_X1_CI_S_risingDelay :: Table2D CInt TransitionTime Capacitance Time +table_FA_X1_CI_S_risingDelay = mkTimingTable 8 6 lookTrAxis_FA_X1_CI_S_risingDelay lookCapAxis_FA_X1_CI_S_risingDelay lookTable_FA_X1_CI_S_risingDelay + +foreign import ccall "timing.h lookTrAxis_FA_X1_CI_S_fallingDelay" lookTrAxis_FA_X1_CI_S_fallingDelay :: CInt -> CDouble +foreign import ccall "timing.h lookCapAxis_FA_X1_CI_S_fallingDelay" lookCapAxis_FA_X1_CI_S_fallingDelay :: CInt -> CDouble +foreign import ccall "timing.h lookTable_FA_X1_CI_S_fallingDelay" lookTable_FA_X1_CI_S_fallingDelay :: CInt -> CInt -> CDouble +table_FA_X1_CI_S_fallingDelay :: Table2D CInt TransitionTime Capacitance Time +table_FA_X1_CI_S_fallingDelay = mkTimingTable 8 6 lookTrAxis_FA_X1_CI_S_fallingDelay lookCapAxis_FA_X1_CI_S_fallingDelay lookTable_FA_X1_CI_S_fallingDelay + +foreign import ccall "timing.h lookTrAxis_FA_X1_CI_S_risingTransition" lookTrAxis_FA_X1_CI_S_risingTransition :: CInt -> CDouble +foreign import ccall "timing.h lookCapAxis_FA_X1_CI_S_risingTransition" lookCapAxis_FA_X1_CI_S_risingTransition :: CInt -> CDouble +foreign import ccall "timing.h lookTable_FA_X1_CI_S_risingTransition" lookTable_FA_X1_CI_S_risingTransition :: CInt -> CInt -> CDouble +table_FA_X1_CI_S_risingTransition :: Table2D CInt TransitionTime Capacitance TransitionTime +table_FA_X1_CI_S_risingTransition = mkTimingTable 8 6 lookTrAxis_FA_X1_CI_S_risingTransition lookCapAxis_FA_X1_CI_S_risingTransition lookTable_FA_X1_CI_S_risingTransition + +foreign import ccall "timing.h lookTrAxis_FA_X1_CI_S_fallingTransition" lookTrAxis_FA_X1_CI_S_fallingTransition :: CInt -> CDouble +foreign import ccall "timing.h lookCapAxis_FA_X1_CI_S_fallingTransition" lookCapAxis_FA_X1_CI_S_fallingTransition :: CInt -> CDouble +foreign import ccall "timing.h lookTable_FA_X1_CI_S_fallingTransition" lookTable_FA_X1_CI_S_fallingTransition :: CInt -> CInt -> CDouble +table_FA_X1_CI_S_fallingTransition :: Table2D CInt TransitionTime Capacitance TransitionTime +table_FA_X1_CI_S_fallingTransition = mkTimingTable 8 6 lookTrAxis_FA_X1_CI_S_fallingTransition lookCapAxis_FA_X1_CI_S_fallingTransition lookTable_FA_X1_CI_S_fallingTransition + +foreign import ccall "timing.h lookTrAxis_HA_X1_A_CO_risingDelay" lookTrAxis_HA_X1_A_CO_risingDelay :: CInt -> CDouble +foreign import ccall "timing.h lookCapAxis_HA_X1_A_CO_risingDelay" lookCapAxis_HA_X1_A_CO_risingDelay :: CInt -> CDouble +foreign import ccall "timing.h lookTable_HA_X1_A_CO_risingDelay" lookTable_HA_X1_A_CO_risingDelay :: CInt -> CInt -> CDouble +table_HA_X1_A_CO_risingDelay :: Table2D CInt TransitionTime Capacitance Time +table_HA_X1_A_CO_risingDelay = mkTimingTable 8 6 lookTrAxis_HA_X1_A_CO_risingDelay lookCapAxis_HA_X1_A_CO_risingDelay lookTable_HA_X1_A_CO_risingDelay + +foreign import ccall "timing.h lookTrAxis_HA_X1_A_CO_fallingDelay" lookTrAxis_HA_X1_A_CO_fallingDelay :: CInt -> CDouble +foreign import ccall "timing.h lookCapAxis_HA_X1_A_CO_fallingDelay" lookCapAxis_HA_X1_A_CO_fallingDelay :: CInt -> CDouble +foreign import ccall "timing.h lookTable_HA_X1_A_CO_fallingDelay" lookTable_HA_X1_A_CO_fallingDelay :: CInt -> CInt -> CDouble +table_HA_X1_A_CO_fallingDelay :: Table2D CInt TransitionTime Capacitance Time +table_HA_X1_A_CO_fallingDelay = mkTimingTable 8 6 lookTrAxis_HA_X1_A_CO_fallingDelay lookCapAxis_HA_X1_A_CO_fallingDelay lookTable_HA_X1_A_CO_fallingDelay + +foreign import ccall "timing.h lookTrAxis_HA_X1_A_CO_risingTransition" lookTrAxis_HA_X1_A_CO_risingTransition :: CInt -> CDouble +foreign import ccall "timing.h lookCapAxis_HA_X1_A_CO_risingTransition" lookCapAxis_HA_X1_A_CO_risingTransition :: CInt -> CDouble +foreign import ccall "timing.h lookTable_HA_X1_A_CO_risingTransition" lookTable_HA_X1_A_CO_risingTransition :: CInt -> CInt -> CDouble +table_HA_X1_A_CO_risingTransition :: Table2D CInt TransitionTime Capacitance TransitionTime +table_HA_X1_A_CO_risingTransition = mkTimingTable 8 6 lookTrAxis_HA_X1_A_CO_risingTransition lookCapAxis_HA_X1_A_CO_risingTransition lookTable_HA_X1_A_CO_risingTransition + +foreign import ccall "timing.h lookTrAxis_HA_X1_A_CO_fallingTransition" lookTrAxis_HA_X1_A_CO_fallingTransition :: CInt -> CDouble +foreign import ccall "timing.h lookCapAxis_HA_X1_A_CO_fallingTransition" lookCapAxis_HA_X1_A_CO_fallingTransition :: CInt -> CDouble +foreign import ccall "timing.h lookTable_HA_X1_A_CO_fallingTransition" lookTable_HA_X1_A_CO_fallingTransition :: CInt -> CInt -> CDouble +table_HA_X1_A_CO_fallingTransition :: Table2D CInt TransitionTime Capacitance TransitionTime +table_HA_X1_A_CO_fallingTransition = mkTimingTable 8 6 lookTrAxis_HA_X1_A_CO_fallingTransition lookCapAxis_HA_X1_A_CO_fallingTransition lookTable_HA_X1_A_CO_fallingTransition + +foreign import ccall "timing.h lookTrAxis_HA_X1_A_S_risingDelay" lookTrAxis_HA_X1_A_S_risingDelay :: CInt -> CDouble +foreign import ccall "timing.h lookCapAxis_HA_X1_A_S_risingDelay" lookCapAxis_HA_X1_A_S_risingDelay :: CInt -> CDouble +foreign import ccall "timing.h lookTable_HA_X1_A_S_risingDelay" lookTable_HA_X1_A_S_risingDelay :: CInt -> CInt -> CDouble +table_HA_X1_A_S_risingDelay :: Table2D CInt TransitionTime Capacitance Time +table_HA_X1_A_S_risingDelay = mkTimingTable 8 6 lookTrAxis_HA_X1_A_S_risingDelay lookCapAxis_HA_X1_A_S_risingDelay lookTable_HA_X1_A_S_risingDelay + +foreign import ccall "timing.h lookTrAxis_HA_X1_A_S_fallingDelay" lookTrAxis_HA_X1_A_S_fallingDelay :: CInt -> CDouble +foreign import ccall "timing.h lookCapAxis_HA_X1_A_S_fallingDelay" lookCapAxis_HA_X1_A_S_fallingDelay :: CInt -> CDouble +foreign import ccall "timing.h lookTable_HA_X1_A_S_fallingDelay" lookTable_HA_X1_A_S_fallingDelay :: CInt -> CInt -> CDouble +table_HA_X1_A_S_fallingDelay :: Table2D CInt TransitionTime Capacitance Time +table_HA_X1_A_S_fallingDelay = mkTimingTable 8 6 lookTrAxis_HA_X1_A_S_fallingDelay lookCapAxis_HA_X1_A_S_fallingDelay lookTable_HA_X1_A_S_fallingDelay + +foreign import ccall "timing.h lookTrAxis_HA_X1_A_S_risingTransition" lookTrAxis_HA_X1_A_S_risingTransition :: CInt -> CDouble +foreign import ccall "timing.h lookCapAxis_HA_X1_A_S_risingTransition" lookCapAxis_HA_X1_A_S_risingTransition :: CInt -> CDouble +foreign import ccall "timing.h lookTable_HA_X1_A_S_risingTransition" lookTable_HA_X1_A_S_risingTransition :: CInt -> CInt -> CDouble +table_HA_X1_A_S_risingTransition :: Table2D CInt TransitionTime Capacitance TransitionTime +table_HA_X1_A_S_risingTransition = mkTimingTable 8 6 lookTrAxis_HA_X1_A_S_risingTransition lookCapAxis_HA_X1_A_S_risingTransition lookTable_HA_X1_A_S_risingTransition + +foreign import ccall "timing.h lookTrAxis_HA_X1_A_S_fallingTransition" lookTrAxis_HA_X1_A_S_fallingTransition :: CInt -> CDouble +foreign import ccall "timing.h lookCapAxis_HA_X1_A_S_fallingTransition" lookCapAxis_HA_X1_A_S_fallingTransition :: CInt -> CDouble +foreign import ccall "timing.h lookTable_HA_X1_A_S_fallingTransition" lookTable_HA_X1_A_S_fallingTransition :: CInt -> CInt -> CDouble +table_HA_X1_A_S_fallingTransition :: Table2D CInt TransitionTime Capacitance TransitionTime +table_HA_X1_A_S_fallingTransition = mkTimingTable 8 6 lookTrAxis_HA_X1_A_S_fallingTransition lookCapAxis_HA_X1_A_S_fallingTransition lookTable_HA_X1_A_S_fallingTransition + +foreign import ccall "timing.h lookTrAxis_HA_X1_B_CO_risingDelay" lookTrAxis_HA_X1_B_CO_risingDelay :: CInt -> CDouble +foreign import ccall "timing.h lookCapAxis_HA_X1_B_CO_risingDelay" lookCapAxis_HA_X1_B_CO_risingDelay :: CInt -> CDouble +foreign import ccall "timing.h lookTable_HA_X1_B_CO_risingDelay" lookTable_HA_X1_B_CO_risingDelay :: CInt -> CInt -> CDouble +table_HA_X1_B_CO_risingDelay :: Table2D CInt TransitionTime Capacitance Time +table_HA_X1_B_CO_risingDelay = mkTimingTable 8 6 lookTrAxis_HA_X1_B_CO_risingDelay lookCapAxis_HA_X1_B_CO_risingDelay lookTable_HA_X1_B_CO_risingDelay + +foreign import ccall "timing.h lookTrAxis_HA_X1_B_CO_fallingDelay" lookTrAxis_HA_X1_B_CO_fallingDelay :: CInt -> CDouble +foreign import ccall "timing.h lookCapAxis_HA_X1_B_CO_fallingDelay" lookCapAxis_HA_X1_B_CO_fallingDelay :: CInt -> CDouble +foreign import ccall "timing.h lookTable_HA_X1_B_CO_fallingDelay" lookTable_HA_X1_B_CO_fallingDelay :: CInt -> CInt -> CDouble +table_HA_X1_B_CO_fallingDelay :: Table2D CInt TransitionTime Capacitance Time +table_HA_X1_B_CO_fallingDelay = mkTimingTable 8 6 lookTrAxis_HA_X1_B_CO_fallingDelay lookCapAxis_HA_X1_B_CO_fallingDelay lookTable_HA_X1_B_CO_fallingDelay + +foreign import ccall "timing.h lookTrAxis_HA_X1_B_CO_risingTransition" lookTrAxis_HA_X1_B_CO_risingTransition :: CInt -> CDouble +foreign import ccall "timing.h lookCapAxis_HA_X1_B_CO_risingTransition" lookCapAxis_HA_X1_B_CO_risingTransition :: CInt -> CDouble +foreign import ccall "timing.h lookTable_HA_X1_B_CO_risingTransition" lookTable_HA_X1_B_CO_risingTransition :: CInt -> CInt -> CDouble +table_HA_X1_B_CO_risingTransition :: Table2D CInt TransitionTime Capacitance TransitionTime +table_HA_X1_B_CO_risingTransition = mkTimingTable 8 6 lookTrAxis_HA_X1_B_CO_risingTransition lookCapAxis_HA_X1_B_CO_risingTransition lookTable_HA_X1_B_CO_risingTransition + +foreign import ccall "timing.h lookTrAxis_HA_X1_B_CO_fallingTransition" lookTrAxis_HA_X1_B_CO_fallingTransition :: CInt -> CDouble +foreign import ccall "timing.h lookCapAxis_HA_X1_B_CO_fallingTransition" lookCapAxis_HA_X1_B_CO_fallingTransition :: CInt -> CDouble +foreign import ccall "timing.h lookTable_HA_X1_B_CO_fallingTransition" lookTable_HA_X1_B_CO_fallingTransition :: CInt -> CInt -> CDouble +table_HA_X1_B_CO_fallingTransition :: Table2D CInt TransitionTime Capacitance TransitionTime +table_HA_X1_B_CO_fallingTransition = mkTimingTable 8 6 lookTrAxis_HA_X1_B_CO_fallingTransition lookCapAxis_HA_X1_B_CO_fallingTransition lookTable_HA_X1_B_CO_fallingTransition + +foreign import ccall "timing.h lookTrAxis_HA_X1_B_S_risingDelay" lookTrAxis_HA_X1_B_S_risingDelay :: CInt -> CDouble +foreign import ccall "timing.h lookCapAxis_HA_X1_B_S_risingDelay" lookCapAxis_HA_X1_B_S_risingDelay :: CInt -> CDouble +foreign import ccall "timing.h lookTable_HA_X1_B_S_risingDelay" lookTable_HA_X1_B_S_risingDelay :: CInt -> CInt -> CDouble +table_HA_X1_B_S_risingDelay :: Table2D CInt TransitionTime Capacitance Time +table_HA_X1_B_S_risingDelay = mkTimingTable 8 6 lookTrAxis_HA_X1_B_S_risingDelay lookCapAxis_HA_X1_B_S_risingDelay lookTable_HA_X1_B_S_risingDelay + +foreign import ccall "timing.h lookTrAxis_HA_X1_B_S_fallingDelay" lookTrAxis_HA_X1_B_S_fallingDelay :: CInt -> CDouble +foreign import ccall "timing.h lookCapAxis_HA_X1_B_S_fallingDelay" lookCapAxis_HA_X1_B_S_fallingDelay :: CInt -> CDouble +foreign import ccall "timing.h lookTable_HA_X1_B_S_fallingDelay" lookTable_HA_X1_B_S_fallingDelay :: CInt -> CInt -> CDouble +table_HA_X1_B_S_fallingDelay :: Table2D CInt TransitionTime Capacitance Time +table_HA_X1_B_S_fallingDelay = mkTimingTable 8 6 lookTrAxis_HA_X1_B_S_fallingDelay lookCapAxis_HA_X1_B_S_fallingDelay lookTable_HA_X1_B_S_fallingDelay + +foreign import ccall "timing.h lookTrAxis_HA_X1_B_S_risingTransition" lookTrAxis_HA_X1_B_S_risingTransition :: CInt -> CDouble +foreign import ccall "timing.h lookCapAxis_HA_X1_B_S_risingTransition" lookCapAxis_HA_X1_B_S_risingTransition :: CInt -> CDouble +foreign import ccall "timing.h lookTable_HA_X1_B_S_risingTransition" lookTable_HA_X1_B_S_risingTransition :: CInt -> CInt -> CDouble +table_HA_X1_B_S_risingTransition :: Table2D CInt TransitionTime Capacitance TransitionTime +table_HA_X1_B_S_risingTransition = mkTimingTable 8 6 lookTrAxis_HA_X1_B_S_risingTransition lookCapAxis_HA_X1_B_S_risingTransition lookTable_HA_X1_B_S_risingTransition + +foreign import ccall "timing.h lookTrAxis_HA_X1_B_S_fallingTransition" lookTrAxis_HA_X1_B_S_fallingTransition :: CInt -> CDouble +foreign import ccall "timing.h lookCapAxis_HA_X1_B_S_fallingTransition" lookCapAxis_HA_X1_B_S_fallingTransition :: CInt -> CDouble +foreign import ccall "timing.h lookTable_HA_X1_B_S_fallingTransition" lookTable_HA_X1_B_S_fallingTransition :: CInt -> CInt -> CDouble +table_HA_X1_B_S_fallingTransition :: Table2D CInt TransitionTime Capacitance TransitionTime +table_HA_X1_B_S_fallingTransition = mkTimingTable 8 6 lookTrAxis_HA_X1_B_S_fallingTransition lookCapAxis_HA_X1_B_S_fallingTransition lookTable_HA_X1_B_S_fallingTransition + +foreign import ccall "timing.h lookTrAxis_INV_X1_A_ZN_risingDelay" lookTrAxis_INV_X1_A_ZN_risingDelay :: CInt -> CDouble +foreign import ccall "timing.h lookCapAxis_INV_X1_A_ZN_risingDelay" lookCapAxis_INV_X1_A_ZN_risingDelay :: CInt -> CDouble +foreign import ccall "timing.h lookTable_INV_X1_A_ZN_risingDelay" lookTable_INV_X1_A_ZN_risingDelay :: CInt -> CInt -> CDouble +table_INV_X1_A_ZN_risingDelay :: Table2D CInt TransitionTime Capacitance Time +table_INV_X1_A_ZN_risingDelay = mkTimingTable 8 6 lookTrAxis_INV_X1_A_ZN_risingDelay lookCapAxis_INV_X1_A_ZN_risingDelay lookTable_INV_X1_A_ZN_risingDelay + +foreign import ccall "timing.h lookTrAxis_INV_X1_A_ZN_fallingDelay" lookTrAxis_INV_X1_A_ZN_fallingDelay :: CInt -> CDouble +foreign import ccall "timing.h lookCapAxis_INV_X1_A_ZN_fallingDelay" lookCapAxis_INV_X1_A_ZN_fallingDelay :: CInt -> CDouble +foreign import ccall "timing.h lookTable_INV_X1_A_ZN_fallingDelay" lookTable_INV_X1_A_ZN_fallingDelay :: CInt -> CInt -> CDouble +table_INV_X1_A_ZN_fallingDelay :: Table2D CInt TransitionTime Capacitance Time +table_INV_X1_A_ZN_fallingDelay = mkTimingTable 8 6 lookTrAxis_INV_X1_A_ZN_fallingDelay lookCapAxis_INV_X1_A_ZN_fallingDelay lookTable_INV_X1_A_ZN_fallingDelay + +foreign import ccall "timing.h lookTrAxis_INV_X1_A_ZN_risingTransition" lookTrAxis_INV_X1_A_ZN_risingTransition :: CInt -> CDouble +foreign import ccall "timing.h lookCapAxis_INV_X1_A_ZN_risingTransition" lookCapAxis_INV_X1_A_ZN_risingTransition :: CInt -> CDouble +foreign import ccall "timing.h lookTable_INV_X1_A_ZN_risingTransition" lookTable_INV_X1_A_ZN_risingTransition :: CInt -> CInt -> CDouble +table_INV_X1_A_ZN_risingTransition :: Table2D CInt TransitionTime Capacitance TransitionTime +table_INV_X1_A_ZN_risingTransition = mkTimingTable 8 6 lookTrAxis_INV_X1_A_ZN_risingTransition lookCapAxis_INV_X1_A_ZN_risingTransition lookTable_INV_X1_A_ZN_risingTransition + +foreign import ccall "timing.h lookTrAxis_INV_X1_A_ZN_fallingTransition" lookTrAxis_INV_X1_A_ZN_fallingTransition :: CInt -> CDouble +foreign import ccall "timing.h lookCapAxis_INV_X1_A_ZN_fallingTransition" lookCapAxis_INV_X1_A_ZN_fallingTransition :: CInt -> CDouble +foreign import ccall "timing.h lookTable_INV_X1_A_ZN_fallingTransition" lookTable_INV_X1_A_ZN_fallingTransition :: CInt -> CInt -> CDouble +table_INV_X1_A_ZN_fallingTransition :: Table2D CInt TransitionTime Capacitance TransitionTime +table_INV_X1_A_ZN_fallingTransition = mkTimingTable 8 6 lookTrAxis_INV_X1_A_ZN_fallingTransition lookCapAxis_INV_X1_A_ZN_fallingTransition lookTable_INV_X1_A_ZN_fallingTransition + +foreign import ccall "timing.h lookTrAxis_INV_X16_A_ZN_risingDelay" lookTrAxis_INV_X16_A_ZN_risingDelay :: CInt -> CDouble +foreign import ccall "timing.h lookCapAxis_INV_X16_A_ZN_risingDelay" lookCapAxis_INV_X16_A_ZN_risingDelay :: CInt -> CDouble +foreign import ccall "timing.h lookTable_INV_X16_A_ZN_risingDelay" lookTable_INV_X16_A_ZN_risingDelay :: CInt -> CInt -> CDouble +table_INV_X16_A_ZN_risingDelay :: Table2D CInt TransitionTime Capacitance Time +table_INV_X16_A_ZN_risingDelay = mkTimingTable 8 6 lookTrAxis_INV_X16_A_ZN_risingDelay lookCapAxis_INV_X16_A_ZN_risingDelay lookTable_INV_X16_A_ZN_risingDelay + +foreign import ccall "timing.h lookTrAxis_INV_X16_A_ZN_fallingDelay" lookTrAxis_INV_X16_A_ZN_fallingDelay :: CInt -> CDouble +foreign import ccall "timing.h lookCapAxis_INV_X16_A_ZN_fallingDelay" lookCapAxis_INV_X16_A_ZN_fallingDelay :: CInt -> CDouble +foreign import ccall "timing.h lookTable_INV_X16_A_ZN_fallingDelay" lookTable_INV_X16_A_ZN_fallingDelay :: CInt -> CInt -> CDouble +table_INV_X16_A_ZN_fallingDelay :: Table2D CInt TransitionTime Capacitance Time +table_INV_X16_A_ZN_fallingDelay = mkTimingTable 8 6 lookTrAxis_INV_X16_A_ZN_fallingDelay lookCapAxis_INV_X16_A_ZN_fallingDelay lookTable_INV_X16_A_ZN_fallingDelay + +foreign import ccall "timing.h lookTrAxis_INV_X16_A_ZN_risingTransition" lookTrAxis_INV_X16_A_ZN_risingTransition :: CInt -> CDouble +foreign import ccall "timing.h lookCapAxis_INV_X16_A_ZN_risingTransition" lookCapAxis_INV_X16_A_ZN_risingTransition :: CInt -> CDouble +foreign import ccall "timing.h lookTable_INV_X16_A_ZN_risingTransition" lookTable_INV_X16_A_ZN_risingTransition :: CInt -> CInt -> CDouble +table_INV_X16_A_ZN_risingTransition :: Table2D CInt TransitionTime Capacitance TransitionTime +table_INV_X16_A_ZN_risingTransition = mkTimingTable 8 6 lookTrAxis_INV_X16_A_ZN_risingTransition lookCapAxis_INV_X16_A_ZN_risingTransition lookTable_INV_X16_A_ZN_risingTransition + +foreign import ccall "timing.h lookTrAxis_INV_X16_A_ZN_fallingTransition" lookTrAxis_INV_X16_A_ZN_fallingTransition :: CInt -> CDouble +foreign import ccall "timing.h lookCapAxis_INV_X16_A_ZN_fallingTransition" lookCapAxis_INV_X16_A_ZN_fallingTransition :: CInt -> CDouble +foreign import ccall "timing.h lookTable_INV_X16_A_ZN_fallingTransition" lookTable_INV_X16_A_ZN_fallingTransition :: CInt -> CInt -> CDouble +table_INV_X16_A_ZN_fallingTransition :: Table2D CInt TransitionTime Capacitance TransitionTime +table_INV_X16_A_ZN_fallingTransition = mkTimingTable 8 6 lookTrAxis_INV_X16_A_ZN_fallingTransition lookCapAxis_INV_X16_A_ZN_fallingTransition lookTable_INV_X16_A_ZN_fallingTransition + +foreign import ccall "timing.h lookTrAxis_INV_X2_A_ZN_risingDelay" lookTrAxis_INV_X2_A_ZN_risingDelay :: CInt -> CDouble +foreign import ccall "timing.h lookCapAxis_INV_X2_A_ZN_risingDelay" lookCapAxis_INV_X2_A_ZN_risingDelay :: CInt -> CDouble +foreign import ccall "timing.h lookTable_INV_X2_A_ZN_risingDelay" lookTable_INV_X2_A_ZN_risingDelay :: CInt -> CInt -> CDouble +table_INV_X2_A_ZN_risingDelay :: Table2D CInt TransitionTime Capacitance Time +table_INV_X2_A_ZN_risingDelay = mkTimingTable 8 6 lookTrAxis_INV_X2_A_ZN_risingDelay lookCapAxis_INV_X2_A_ZN_risingDelay lookTable_INV_X2_A_ZN_risingDelay + +foreign import ccall "timing.h lookTrAxis_INV_X2_A_ZN_fallingDelay" lookTrAxis_INV_X2_A_ZN_fallingDelay :: CInt -> CDouble +foreign import ccall "timing.h lookCapAxis_INV_X2_A_ZN_fallingDelay" lookCapAxis_INV_X2_A_ZN_fallingDelay :: CInt -> CDouble +foreign import ccall "timing.h lookTable_INV_X2_A_ZN_fallingDelay" lookTable_INV_X2_A_ZN_fallingDelay :: CInt -> CInt -> CDouble +table_INV_X2_A_ZN_fallingDelay :: Table2D CInt TransitionTime Capacitance Time +table_INV_X2_A_ZN_fallingDelay = mkTimingTable 8 6 lookTrAxis_INV_X2_A_ZN_fallingDelay lookCapAxis_INV_X2_A_ZN_fallingDelay lookTable_INV_X2_A_ZN_fallingDelay + +foreign import ccall "timing.h lookTrAxis_INV_X2_A_ZN_risingTransition" lookTrAxis_INV_X2_A_ZN_risingTransition :: CInt -> CDouble +foreign import ccall "timing.h lookCapAxis_INV_X2_A_ZN_risingTransition" lookCapAxis_INV_X2_A_ZN_risingTransition :: CInt -> CDouble +foreign import ccall "timing.h lookTable_INV_X2_A_ZN_risingTransition" lookTable_INV_X2_A_ZN_risingTransition :: CInt -> CInt -> CDouble +table_INV_X2_A_ZN_risingTransition :: Table2D CInt TransitionTime Capacitance TransitionTime +table_INV_X2_A_ZN_risingTransition = mkTimingTable 8 6 lookTrAxis_INV_X2_A_ZN_risingTransition lookCapAxis_INV_X2_A_ZN_risingTransition lookTable_INV_X2_A_ZN_risingTransition + +foreign import ccall "timing.h lookTrAxis_INV_X2_A_ZN_fallingTransition" lookTrAxis_INV_X2_A_ZN_fallingTransition :: CInt -> CDouble +foreign import ccall "timing.h lookCapAxis_INV_X2_A_ZN_fallingTransition" lookCapAxis_INV_X2_A_ZN_fallingTransition :: CInt -> CDouble +foreign import ccall "timing.h lookTable_INV_X2_A_ZN_fallingTransition" lookTable_INV_X2_A_ZN_fallingTransition :: CInt -> CInt -> CDouble +table_INV_X2_A_ZN_fallingTransition :: Table2D CInt TransitionTime Capacitance TransitionTime +table_INV_X2_A_ZN_fallingTransition = mkTimingTable 8 6 lookTrAxis_INV_X2_A_ZN_fallingTransition lookCapAxis_INV_X2_A_ZN_fallingTransition lookTable_INV_X2_A_ZN_fallingTransition + +foreign import ccall "timing.h lookTrAxis_INV_X32_A_ZN_risingDelay" lookTrAxis_INV_X32_A_ZN_risingDelay :: CInt -> CDouble +foreign import ccall "timing.h lookCapAxis_INV_X32_A_ZN_risingDelay" lookCapAxis_INV_X32_A_ZN_risingDelay :: CInt -> CDouble +foreign import ccall "timing.h lookTable_INV_X32_A_ZN_risingDelay" lookTable_INV_X32_A_ZN_risingDelay :: CInt -> CInt -> CDouble +table_INV_X32_A_ZN_risingDelay :: Table2D CInt TransitionTime Capacitance Time +table_INV_X32_A_ZN_risingDelay = mkTimingTable 8 6 lookTrAxis_INV_X32_A_ZN_risingDelay lookCapAxis_INV_X32_A_ZN_risingDelay lookTable_INV_X32_A_ZN_risingDelay + +foreign import ccall "timing.h lookTrAxis_INV_X32_A_ZN_fallingDelay" lookTrAxis_INV_X32_A_ZN_fallingDelay :: CInt -> CDouble +foreign import ccall "timing.h lookCapAxis_INV_X32_A_ZN_fallingDelay" lookCapAxis_INV_X32_A_ZN_fallingDelay :: CInt -> CDouble +foreign import ccall "timing.h lookTable_INV_X32_A_ZN_fallingDelay" lookTable_INV_X32_A_ZN_fallingDelay :: CInt -> CInt -> CDouble +table_INV_X32_A_ZN_fallingDelay :: Table2D CInt TransitionTime Capacitance Time +table_INV_X32_A_ZN_fallingDelay = mkTimingTable 8 6 lookTrAxis_INV_X32_A_ZN_fallingDelay lookCapAxis_INV_X32_A_ZN_fallingDelay lookTable_INV_X32_A_ZN_fallingDelay + +foreign import ccall "timing.h lookTrAxis_INV_X32_A_ZN_risingTransition" lookTrAxis_INV_X32_A_ZN_risingTransition :: CInt -> CDouble +foreign import ccall "timing.h lookCapAxis_INV_X32_A_ZN_risingTransition" lookCapAxis_INV_X32_A_ZN_risingTransition :: CInt -> CDouble +foreign import ccall "timing.h lookTable_INV_X32_A_ZN_risingTransition" lookTable_INV_X32_A_ZN_risingTransition :: CInt -> CInt -> CDouble +table_INV_X32_A_ZN_risingTransition :: Table2D CInt TransitionTime Capacitance TransitionTime +table_INV_X32_A_ZN_risingTransition = mkTimingTable 8 6 lookTrAxis_INV_X32_A_ZN_risingTransition lookCapAxis_INV_X32_A_ZN_risingTransition lookTable_INV_X32_A_ZN_risingTransition + +foreign import ccall "timing.h lookTrAxis_INV_X32_A_ZN_fallingTransition" lookTrAxis_INV_X32_A_ZN_fallingTransition :: CInt -> CDouble +foreign import ccall "timing.h lookCapAxis_INV_X32_A_ZN_fallingTransition" lookCapAxis_INV_X32_A_ZN_fallingTransition :: CInt -> CDouble +foreign import ccall "timing.h lookTable_INV_X32_A_ZN_fallingTransition" lookTable_INV_X32_A_ZN_fallingTransition :: CInt -> CInt -> CDouble +table_INV_X32_A_ZN_fallingTransition :: Table2D CInt TransitionTime Capacitance TransitionTime +table_INV_X32_A_ZN_fallingTransition = mkTimingTable 8 6 lookTrAxis_INV_X32_A_ZN_fallingTransition lookCapAxis_INV_X32_A_ZN_fallingTransition lookTable_INV_X32_A_ZN_fallingTransition + +foreign import ccall "timing.h lookTrAxis_INV_X4_A_ZN_risingDelay" lookTrAxis_INV_X4_A_ZN_risingDelay :: CInt -> CDouble +foreign import ccall "timing.h lookCapAxis_INV_X4_A_ZN_risingDelay" lookCapAxis_INV_X4_A_ZN_risingDelay :: CInt -> CDouble +foreign import ccall "timing.h lookTable_INV_X4_A_ZN_risingDelay" lookTable_INV_X4_A_ZN_risingDelay :: CInt -> CInt -> CDouble +table_INV_X4_A_ZN_risingDelay :: Table2D CInt TransitionTime Capacitance Time +table_INV_X4_A_ZN_risingDelay = mkTimingTable 8 6 lookTrAxis_INV_X4_A_ZN_risingDelay lookCapAxis_INV_X4_A_ZN_risingDelay lookTable_INV_X4_A_ZN_risingDelay + +foreign import ccall "timing.h lookTrAxis_INV_X4_A_ZN_fallingDelay" lookTrAxis_INV_X4_A_ZN_fallingDelay :: CInt -> CDouble +foreign import ccall "timing.h lookCapAxis_INV_X4_A_ZN_fallingDelay" lookCapAxis_INV_X4_A_ZN_fallingDelay :: CInt -> CDouble +foreign import ccall "timing.h lookTable_INV_X4_A_ZN_fallingDelay" lookTable_INV_X4_A_ZN_fallingDelay :: CInt -> CInt -> CDouble +table_INV_X4_A_ZN_fallingDelay :: Table2D CInt TransitionTime Capacitance Time +table_INV_X4_A_ZN_fallingDelay = mkTimingTable 8 6 lookTrAxis_INV_X4_A_ZN_fallingDelay lookCapAxis_INV_X4_A_ZN_fallingDelay lookTable_INV_X4_A_ZN_fallingDelay + +foreign import ccall "timing.h lookTrAxis_INV_X4_A_ZN_risingTransition" lookTrAxis_INV_X4_A_ZN_risingTransition :: CInt -> CDouble +foreign import ccall "timing.h lookCapAxis_INV_X4_A_ZN_risingTransition" lookCapAxis_INV_X4_A_ZN_risingTransition :: CInt -> CDouble +foreign import ccall "timing.h lookTable_INV_X4_A_ZN_risingTransition" lookTable_INV_X4_A_ZN_risingTransition :: CInt -> CInt -> CDouble +table_INV_X4_A_ZN_risingTransition :: Table2D CInt TransitionTime Capacitance TransitionTime +table_INV_X4_A_ZN_risingTransition = mkTimingTable 8 6 lookTrAxis_INV_X4_A_ZN_risingTransition lookCapAxis_INV_X4_A_ZN_risingTransition lookTable_INV_X4_A_ZN_risingTransition + +foreign import ccall "timing.h lookTrAxis_INV_X4_A_ZN_fallingTransition" lookTrAxis_INV_X4_A_ZN_fallingTransition :: CInt -> CDouble +foreign import ccall "timing.h lookCapAxis_INV_X4_A_ZN_fallingTransition" lookCapAxis_INV_X4_A_ZN_fallingTransition :: CInt -> CDouble +foreign import ccall "timing.h lookTable_INV_X4_A_ZN_fallingTransition" lookTable_INV_X4_A_ZN_fallingTransition :: CInt -> CInt -> CDouble +table_INV_X4_A_ZN_fallingTransition :: Table2D CInt TransitionTime Capacitance TransitionTime +table_INV_X4_A_ZN_fallingTransition = mkTimingTable 8 6 lookTrAxis_INV_X4_A_ZN_fallingTransition lookCapAxis_INV_X4_A_ZN_fallingTransition lookTable_INV_X4_A_ZN_fallingTransition + +foreign import ccall "timing.h lookTrAxis_INV_X8_A_ZN_risingDelay" lookTrAxis_INV_X8_A_ZN_risingDelay :: CInt -> CDouble +foreign import ccall "timing.h lookCapAxis_INV_X8_A_ZN_risingDelay" lookCapAxis_INV_X8_A_ZN_risingDelay :: CInt -> CDouble +foreign import ccall "timing.h lookTable_INV_X8_A_ZN_risingDelay" lookTable_INV_X8_A_ZN_risingDelay :: CInt -> CInt -> CDouble +table_INV_X8_A_ZN_risingDelay :: Table2D CInt TransitionTime Capacitance Time +table_INV_X8_A_ZN_risingDelay = mkTimingTable 8 6 lookTrAxis_INV_X8_A_ZN_risingDelay lookCapAxis_INV_X8_A_ZN_risingDelay lookTable_INV_X8_A_ZN_risingDelay + +foreign import ccall "timing.h lookTrAxis_INV_X8_A_ZN_fallingDelay" lookTrAxis_INV_X8_A_ZN_fallingDelay :: CInt -> CDouble +foreign import ccall "timing.h lookCapAxis_INV_X8_A_ZN_fallingDelay" lookCapAxis_INV_X8_A_ZN_fallingDelay :: CInt -> CDouble +foreign import ccall "timing.h lookTable_INV_X8_A_ZN_fallingDelay" lookTable_INV_X8_A_ZN_fallingDelay :: CInt -> CInt -> CDouble +table_INV_X8_A_ZN_fallingDelay :: Table2D CInt TransitionTime Capacitance Time +table_INV_X8_A_ZN_fallingDelay = mkTimingTable 8 6 lookTrAxis_INV_X8_A_ZN_fallingDelay lookCapAxis_INV_X8_A_ZN_fallingDelay lookTable_INV_X8_A_ZN_fallingDelay + +foreign import ccall "timing.h lookTrAxis_INV_X8_A_ZN_risingTransition" lookTrAxis_INV_X8_A_ZN_risingTransition :: CInt -> CDouble +foreign import ccall "timing.h lookCapAxis_INV_X8_A_ZN_risingTransition" lookCapAxis_INV_X8_A_ZN_risingTransition :: CInt -> CDouble +foreign import ccall "timing.h lookTable_INV_X8_A_ZN_risingTransition" lookTable_INV_X8_A_ZN_risingTransition :: CInt -> CInt -> CDouble +table_INV_X8_A_ZN_risingTransition :: Table2D CInt TransitionTime Capacitance TransitionTime +table_INV_X8_A_ZN_risingTransition = mkTimingTable 8 6 lookTrAxis_INV_X8_A_ZN_risingTransition lookCapAxis_INV_X8_A_ZN_risingTransition lookTable_INV_X8_A_ZN_risingTransition + +foreign import ccall "timing.h lookTrAxis_INV_X8_A_ZN_fallingTransition" lookTrAxis_INV_X8_A_ZN_fallingTransition :: CInt -> CDouble +foreign import ccall "timing.h lookCapAxis_INV_X8_A_ZN_fallingTransition" lookCapAxis_INV_X8_A_ZN_fallingTransition :: CInt -> CDouble +foreign import ccall "timing.h lookTable_INV_X8_A_ZN_fallingTransition" lookTable_INV_X8_A_ZN_fallingTransition :: CInt -> CInt -> CDouble +table_INV_X8_A_ZN_fallingTransition :: Table2D CInt TransitionTime Capacitance TransitionTime +table_INV_X8_A_ZN_fallingTransition = mkTimingTable 8 6 lookTrAxis_INV_X8_A_ZN_fallingTransition lookCapAxis_INV_X8_A_ZN_fallingTransition lookTable_INV_X8_A_ZN_fallingTransition + +foreign import ccall "timing.h lookTrAxis_NAND2_X1_A1_ZN_risingDelay" lookTrAxis_NAND2_X1_A1_ZN_risingDelay :: CInt -> CDouble +foreign import ccall "timing.h lookCapAxis_NAND2_X1_A1_ZN_risingDelay" lookCapAxis_NAND2_X1_A1_ZN_risingDelay :: CInt -> CDouble +foreign import ccall "timing.h lookTable_NAND2_X1_A1_ZN_risingDelay" lookTable_NAND2_X1_A1_ZN_risingDelay :: CInt -> CInt -> CDouble +table_NAND2_X1_A1_ZN_risingDelay :: Table2D CInt TransitionTime Capacitance Time +table_NAND2_X1_A1_ZN_risingDelay = mkTimingTable 8 6 lookTrAxis_NAND2_X1_A1_ZN_risingDelay lookCapAxis_NAND2_X1_A1_ZN_risingDelay lookTable_NAND2_X1_A1_ZN_risingDelay + +foreign import ccall "timing.h lookTrAxis_NAND2_X1_A1_ZN_fallingDelay" lookTrAxis_NAND2_X1_A1_ZN_fallingDelay :: CInt -> CDouble +foreign import ccall "timing.h lookCapAxis_NAND2_X1_A1_ZN_fallingDelay" lookCapAxis_NAND2_X1_A1_ZN_fallingDelay :: CInt -> CDouble +foreign import ccall "timing.h lookTable_NAND2_X1_A1_ZN_fallingDelay" lookTable_NAND2_X1_A1_ZN_fallingDelay :: CInt -> CInt -> CDouble +table_NAND2_X1_A1_ZN_fallingDelay :: Table2D CInt TransitionTime Capacitance Time +table_NAND2_X1_A1_ZN_fallingDelay = mkTimingTable 8 6 lookTrAxis_NAND2_X1_A1_ZN_fallingDelay lookCapAxis_NAND2_X1_A1_ZN_fallingDelay lookTable_NAND2_X1_A1_ZN_fallingDelay + +foreign import ccall "timing.h lookTrAxis_NAND2_X1_A1_ZN_risingTransition" lookTrAxis_NAND2_X1_A1_ZN_risingTransition :: CInt -> CDouble +foreign import ccall "timing.h lookCapAxis_NAND2_X1_A1_ZN_risingTransition" lookCapAxis_NAND2_X1_A1_ZN_risingTransition :: CInt -> CDouble +foreign import ccall "timing.h lookTable_NAND2_X1_A1_ZN_risingTransition" lookTable_NAND2_X1_A1_ZN_risingTransition :: CInt -> CInt -> CDouble +table_NAND2_X1_A1_ZN_risingTransition :: Table2D CInt TransitionTime Capacitance TransitionTime +table_NAND2_X1_A1_ZN_risingTransition = mkTimingTable 8 6 lookTrAxis_NAND2_X1_A1_ZN_risingTransition lookCapAxis_NAND2_X1_A1_ZN_risingTransition lookTable_NAND2_X1_A1_ZN_risingTransition + +foreign import ccall "timing.h lookTrAxis_NAND2_X1_A1_ZN_fallingTransition" lookTrAxis_NAND2_X1_A1_ZN_fallingTransition :: CInt -> CDouble +foreign import ccall "timing.h lookCapAxis_NAND2_X1_A1_ZN_fallingTransition" lookCapAxis_NAND2_X1_A1_ZN_fallingTransition :: CInt -> CDouble +foreign import ccall "timing.h lookTable_NAND2_X1_A1_ZN_fallingTransition" lookTable_NAND2_X1_A1_ZN_fallingTransition :: CInt -> CInt -> CDouble +table_NAND2_X1_A1_ZN_fallingTransition :: Table2D CInt TransitionTime Capacitance TransitionTime +table_NAND2_X1_A1_ZN_fallingTransition = mkTimingTable 8 6 lookTrAxis_NAND2_X1_A1_ZN_fallingTransition lookCapAxis_NAND2_X1_A1_ZN_fallingTransition lookTable_NAND2_X1_A1_ZN_fallingTransition + +foreign import ccall "timing.h lookTrAxis_NAND2_X1_A2_ZN_risingDelay" lookTrAxis_NAND2_X1_A2_ZN_risingDelay :: CInt -> CDouble +foreign import ccall "timing.h lookCapAxis_NAND2_X1_A2_ZN_risingDelay" lookCapAxis_NAND2_X1_A2_ZN_risingDelay :: CInt -> CDouble +foreign import ccall "timing.h lookTable_NAND2_X1_A2_ZN_risingDelay" lookTable_NAND2_X1_A2_ZN_risingDelay :: CInt -> CInt -> CDouble +table_NAND2_X1_A2_ZN_risingDelay :: Table2D CInt TransitionTime Capacitance Time +table_NAND2_X1_A2_ZN_risingDelay = mkTimingTable 8 6 lookTrAxis_NAND2_X1_A2_ZN_risingDelay lookCapAxis_NAND2_X1_A2_ZN_risingDelay lookTable_NAND2_X1_A2_ZN_risingDelay + +foreign import ccall "timing.h lookTrAxis_NAND2_X1_A2_ZN_fallingDelay" lookTrAxis_NAND2_X1_A2_ZN_fallingDelay :: CInt -> CDouble +foreign import ccall "timing.h lookCapAxis_NAND2_X1_A2_ZN_fallingDelay" lookCapAxis_NAND2_X1_A2_ZN_fallingDelay :: CInt -> CDouble +foreign import ccall "timing.h lookTable_NAND2_X1_A2_ZN_fallingDelay" lookTable_NAND2_X1_A2_ZN_fallingDelay :: CInt -> CInt -> CDouble +table_NAND2_X1_A2_ZN_fallingDelay :: Table2D CInt TransitionTime Capacitance Time +table_NAND2_X1_A2_ZN_fallingDelay = mkTimingTable 8 6 lookTrAxis_NAND2_X1_A2_ZN_fallingDelay lookCapAxis_NAND2_X1_A2_ZN_fallingDelay lookTable_NAND2_X1_A2_ZN_fallingDelay + +foreign import ccall "timing.h lookTrAxis_NAND2_X1_A2_ZN_risingTransition" lookTrAxis_NAND2_X1_A2_ZN_risingTransition :: CInt -> CDouble +foreign import ccall "timing.h lookCapAxis_NAND2_X1_A2_ZN_risingTransition" lookCapAxis_NAND2_X1_A2_ZN_risingTransition :: CInt -> CDouble +foreign import ccall "timing.h lookTable_NAND2_X1_A2_ZN_risingTransition" lookTable_NAND2_X1_A2_ZN_risingTransition :: CInt -> CInt -> CDouble +table_NAND2_X1_A2_ZN_risingTransition :: Table2D CInt TransitionTime Capacitance TransitionTime +table_NAND2_X1_A2_ZN_risingTransition = mkTimingTable 8 6 lookTrAxis_NAND2_X1_A2_ZN_risingTransition lookCapAxis_NAND2_X1_A2_ZN_risingTransition lookTable_NAND2_X1_A2_ZN_risingTransition + +foreign import ccall "timing.h lookTrAxis_NAND2_X1_A2_ZN_fallingTransition" lookTrAxis_NAND2_X1_A2_ZN_fallingTransition :: CInt -> CDouble +foreign import ccall "timing.h lookCapAxis_NAND2_X1_A2_ZN_fallingTransition" lookCapAxis_NAND2_X1_A2_ZN_fallingTransition :: CInt -> CDouble +foreign import ccall "timing.h lookTable_NAND2_X1_A2_ZN_fallingTransition" lookTable_NAND2_X1_A2_ZN_fallingTransition :: CInt -> CInt -> CDouble +table_NAND2_X1_A2_ZN_fallingTransition :: Table2D CInt TransitionTime Capacitance TransitionTime +table_NAND2_X1_A2_ZN_fallingTransition = mkTimingTable 8 6 lookTrAxis_NAND2_X1_A2_ZN_fallingTransition lookCapAxis_NAND2_X1_A2_ZN_fallingTransition lookTable_NAND2_X1_A2_ZN_fallingTransition + +foreign import ccall "timing.h lookTrAxis_NAND2_X2_A1_ZN_risingDelay" lookTrAxis_NAND2_X2_A1_ZN_risingDelay :: CInt -> CDouble +foreign import ccall "timing.h lookCapAxis_NAND2_X2_A1_ZN_risingDelay" lookCapAxis_NAND2_X2_A1_ZN_risingDelay :: CInt -> CDouble +foreign import ccall "timing.h lookTable_NAND2_X2_A1_ZN_risingDelay" lookTable_NAND2_X2_A1_ZN_risingDelay :: CInt -> CInt -> CDouble +table_NAND2_X2_A1_ZN_risingDelay :: Table2D CInt TransitionTime Capacitance Time +table_NAND2_X2_A1_ZN_risingDelay = mkTimingTable 8 6 lookTrAxis_NAND2_X2_A1_ZN_risingDelay lookCapAxis_NAND2_X2_A1_ZN_risingDelay lookTable_NAND2_X2_A1_ZN_risingDelay + +foreign import ccall "timing.h lookTrAxis_NAND2_X2_A1_ZN_fallingDelay" lookTrAxis_NAND2_X2_A1_ZN_fallingDelay :: CInt -> CDouble +foreign import ccall "timing.h lookCapAxis_NAND2_X2_A1_ZN_fallingDelay" lookCapAxis_NAND2_X2_A1_ZN_fallingDelay :: CInt -> CDouble +foreign import ccall "timing.h lookTable_NAND2_X2_A1_ZN_fallingDelay" lookTable_NAND2_X2_A1_ZN_fallingDelay :: CInt -> CInt -> CDouble +table_NAND2_X2_A1_ZN_fallingDelay :: Table2D CInt TransitionTime Capacitance Time +table_NAND2_X2_A1_ZN_fallingDelay = mkTimingTable 8 6 lookTrAxis_NAND2_X2_A1_ZN_fallingDelay lookCapAxis_NAND2_X2_A1_ZN_fallingDelay lookTable_NAND2_X2_A1_ZN_fallingDelay + +foreign import ccall "timing.h lookTrAxis_NAND2_X2_A1_ZN_risingTransition" lookTrAxis_NAND2_X2_A1_ZN_risingTransition :: CInt -> CDouble +foreign import ccall "timing.h lookCapAxis_NAND2_X2_A1_ZN_risingTransition" lookCapAxis_NAND2_X2_A1_ZN_risingTransition :: CInt -> CDouble +foreign import ccall "timing.h lookTable_NAND2_X2_A1_ZN_risingTransition" lookTable_NAND2_X2_A1_ZN_risingTransition :: CInt -> CInt -> CDouble +table_NAND2_X2_A1_ZN_risingTransition :: Table2D CInt TransitionTime Capacitance TransitionTime +table_NAND2_X2_A1_ZN_risingTransition = mkTimingTable 8 6 lookTrAxis_NAND2_X2_A1_ZN_risingTransition lookCapAxis_NAND2_X2_A1_ZN_risingTransition lookTable_NAND2_X2_A1_ZN_risingTransition + +foreign import ccall "timing.h lookTrAxis_NAND2_X2_A1_ZN_fallingTransition" lookTrAxis_NAND2_X2_A1_ZN_fallingTransition :: CInt -> CDouble +foreign import ccall "timing.h lookCapAxis_NAND2_X2_A1_ZN_fallingTransition" lookCapAxis_NAND2_X2_A1_ZN_fallingTransition :: CInt -> CDouble +foreign import ccall "timing.h lookTable_NAND2_X2_A1_ZN_fallingTransition" lookTable_NAND2_X2_A1_ZN_fallingTransition :: CInt -> CInt -> CDouble +table_NAND2_X2_A1_ZN_fallingTransition :: Table2D CInt TransitionTime Capacitance TransitionTime +table_NAND2_X2_A1_ZN_fallingTransition = mkTimingTable 8 6 lookTrAxis_NAND2_X2_A1_ZN_fallingTransition lookCapAxis_NAND2_X2_A1_ZN_fallingTransition lookTable_NAND2_X2_A1_ZN_fallingTransition + +foreign import ccall "timing.h lookTrAxis_NAND2_X2_A2_ZN_risingDelay" lookTrAxis_NAND2_X2_A2_ZN_risingDelay :: CInt -> CDouble +foreign import ccall "timing.h lookCapAxis_NAND2_X2_A2_ZN_risingDelay" lookCapAxis_NAND2_X2_A2_ZN_risingDelay :: CInt -> CDouble +foreign import ccall "timing.h lookTable_NAND2_X2_A2_ZN_risingDelay" lookTable_NAND2_X2_A2_ZN_risingDelay :: CInt -> CInt -> CDouble +table_NAND2_X2_A2_ZN_risingDelay :: Table2D CInt TransitionTime Capacitance Time +table_NAND2_X2_A2_ZN_risingDelay = mkTimingTable 8 6 lookTrAxis_NAND2_X2_A2_ZN_risingDelay lookCapAxis_NAND2_X2_A2_ZN_risingDelay lookTable_NAND2_X2_A2_ZN_risingDelay + +foreign import ccall "timing.h lookTrAxis_NAND2_X2_A2_ZN_fallingDelay" lookTrAxis_NAND2_X2_A2_ZN_fallingDelay :: CInt -> CDouble +foreign import ccall "timing.h lookCapAxis_NAND2_X2_A2_ZN_fallingDelay" lookCapAxis_NAND2_X2_A2_ZN_fallingDelay :: CInt -> CDouble +foreign import ccall "timing.h lookTable_NAND2_X2_A2_ZN_fallingDelay" lookTable_NAND2_X2_A2_ZN_fallingDelay :: CInt -> CInt -> CDouble +table_NAND2_X2_A2_ZN_fallingDelay :: Table2D CInt TransitionTime Capacitance Time +table_NAND2_X2_A2_ZN_fallingDelay = mkTimingTable 8 6 lookTrAxis_NAND2_X2_A2_ZN_fallingDelay lookCapAxis_NAND2_X2_A2_ZN_fallingDelay lookTable_NAND2_X2_A2_ZN_fallingDelay + +foreign import ccall "timing.h lookTrAxis_NAND2_X2_A2_ZN_risingTransition" lookTrAxis_NAND2_X2_A2_ZN_risingTransition :: CInt -> CDouble +foreign import ccall "timing.h lookCapAxis_NAND2_X2_A2_ZN_risingTransition" lookCapAxis_NAND2_X2_A2_ZN_risingTransition :: CInt -> CDouble +foreign import ccall "timing.h lookTable_NAND2_X2_A2_ZN_risingTransition" lookTable_NAND2_X2_A2_ZN_risingTransition :: CInt -> CInt -> CDouble +table_NAND2_X2_A2_ZN_risingTransition :: Table2D CInt TransitionTime Capacitance TransitionTime +table_NAND2_X2_A2_ZN_risingTransition = mkTimingTable 8 6 lookTrAxis_NAND2_X2_A2_ZN_risingTransition lookCapAxis_NAND2_X2_A2_ZN_risingTransition lookTable_NAND2_X2_A2_ZN_risingTransition + +foreign import ccall "timing.h lookTrAxis_NAND2_X2_A2_ZN_fallingTransition" lookTrAxis_NAND2_X2_A2_ZN_fallingTransition :: CInt -> CDouble +foreign import ccall "timing.h lookCapAxis_NAND2_X2_A2_ZN_fallingTransition" lookCapAxis_NAND2_X2_A2_ZN_fallingTransition :: CInt -> CDouble +foreign import ccall "timing.h lookTable_NAND2_X2_A2_ZN_fallingTransition" lookTable_NAND2_X2_A2_ZN_fallingTransition :: CInt -> CInt -> CDouble +table_NAND2_X2_A2_ZN_fallingTransition :: Table2D CInt TransitionTime Capacitance TransitionTime +table_NAND2_X2_A2_ZN_fallingTransition = mkTimingTable 8 6 lookTrAxis_NAND2_X2_A2_ZN_fallingTransition lookCapAxis_NAND2_X2_A2_ZN_fallingTransition lookTable_NAND2_X2_A2_ZN_fallingTransition + +foreign import ccall "timing.h lookTrAxis_NAND2_X4_A1_ZN_risingDelay" lookTrAxis_NAND2_X4_A1_ZN_risingDelay :: CInt -> CDouble +foreign import ccall "timing.h lookCapAxis_NAND2_X4_A1_ZN_risingDelay" lookCapAxis_NAND2_X4_A1_ZN_risingDelay :: CInt -> CDouble +foreign import ccall "timing.h lookTable_NAND2_X4_A1_ZN_risingDelay" lookTable_NAND2_X4_A1_ZN_risingDelay :: CInt -> CInt -> CDouble +table_NAND2_X4_A1_ZN_risingDelay :: Table2D CInt TransitionTime Capacitance Time +table_NAND2_X4_A1_ZN_risingDelay = mkTimingTable 8 6 lookTrAxis_NAND2_X4_A1_ZN_risingDelay lookCapAxis_NAND2_X4_A1_ZN_risingDelay lookTable_NAND2_X4_A1_ZN_risingDelay + +foreign import ccall "timing.h lookTrAxis_NAND2_X4_A1_ZN_fallingDelay" lookTrAxis_NAND2_X4_A1_ZN_fallingDelay :: CInt -> CDouble +foreign import ccall "timing.h lookCapAxis_NAND2_X4_A1_ZN_fallingDelay" lookCapAxis_NAND2_X4_A1_ZN_fallingDelay :: CInt -> CDouble +foreign import ccall "timing.h lookTable_NAND2_X4_A1_ZN_fallingDelay" lookTable_NAND2_X4_A1_ZN_fallingDelay :: CInt -> CInt -> CDouble +table_NAND2_X4_A1_ZN_fallingDelay :: Table2D CInt TransitionTime Capacitance Time +table_NAND2_X4_A1_ZN_fallingDelay = mkTimingTable 8 6 lookTrAxis_NAND2_X4_A1_ZN_fallingDelay lookCapAxis_NAND2_X4_A1_ZN_fallingDelay lookTable_NAND2_X4_A1_ZN_fallingDelay + +foreign import ccall "timing.h lookTrAxis_NAND2_X4_A1_ZN_risingTransition" lookTrAxis_NAND2_X4_A1_ZN_risingTransition :: CInt -> CDouble +foreign import ccall "timing.h lookCapAxis_NAND2_X4_A1_ZN_risingTransition" lookCapAxis_NAND2_X4_A1_ZN_risingTransition :: CInt -> CDouble +foreign import ccall "timing.h lookTable_NAND2_X4_A1_ZN_risingTransition" lookTable_NAND2_X4_A1_ZN_risingTransition :: CInt -> CInt -> CDouble +table_NAND2_X4_A1_ZN_risingTransition :: Table2D CInt TransitionTime Capacitance TransitionTime +table_NAND2_X4_A1_ZN_risingTransition = mkTimingTable 8 6 lookTrAxis_NAND2_X4_A1_ZN_risingTransition lookCapAxis_NAND2_X4_A1_ZN_risingTransition lookTable_NAND2_X4_A1_ZN_risingTransition + +foreign import ccall "timing.h lookTrAxis_NAND2_X4_A1_ZN_fallingTransition" lookTrAxis_NAND2_X4_A1_ZN_fallingTransition :: CInt -> CDouble +foreign import ccall "timing.h lookCapAxis_NAND2_X4_A1_ZN_fallingTransition" lookCapAxis_NAND2_X4_A1_ZN_fallingTransition :: CInt -> CDouble +foreign import ccall "timing.h lookTable_NAND2_X4_A1_ZN_fallingTransition" lookTable_NAND2_X4_A1_ZN_fallingTransition :: CInt -> CInt -> CDouble +table_NAND2_X4_A1_ZN_fallingTransition :: Table2D CInt TransitionTime Capacitance TransitionTime +table_NAND2_X4_A1_ZN_fallingTransition = mkTimingTable 8 6 lookTrAxis_NAND2_X4_A1_ZN_fallingTransition lookCapAxis_NAND2_X4_A1_ZN_fallingTransition lookTable_NAND2_X4_A1_ZN_fallingTransition + +foreign import ccall "timing.h lookTrAxis_NAND2_X4_A2_ZN_risingDelay" lookTrAxis_NAND2_X4_A2_ZN_risingDelay :: CInt -> CDouble +foreign import ccall "timing.h lookCapAxis_NAND2_X4_A2_ZN_risingDelay" lookCapAxis_NAND2_X4_A2_ZN_risingDelay :: CInt -> CDouble +foreign import ccall "timing.h lookTable_NAND2_X4_A2_ZN_risingDelay" lookTable_NAND2_X4_A2_ZN_risingDelay :: CInt -> CInt -> CDouble +table_NAND2_X4_A2_ZN_risingDelay :: Table2D CInt TransitionTime Capacitance Time +table_NAND2_X4_A2_ZN_risingDelay = mkTimingTable 8 6 lookTrAxis_NAND2_X4_A2_ZN_risingDelay lookCapAxis_NAND2_X4_A2_ZN_risingDelay lookTable_NAND2_X4_A2_ZN_risingDelay + +foreign import ccall "timing.h lookTrAxis_NAND2_X4_A2_ZN_fallingDelay" lookTrAxis_NAND2_X4_A2_ZN_fallingDelay :: CInt -> CDouble +foreign import ccall "timing.h lookCapAxis_NAND2_X4_A2_ZN_fallingDelay" lookCapAxis_NAND2_X4_A2_ZN_fallingDelay :: CInt -> CDouble +foreign import ccall "timing.h lookTable_NAND2_X4_A2_ZN_fallingDelay" lookTable_NAND2_X4_A2_ZN_fallingDelay :: CInt -> CInt -> CDouble +table_NAND2_X4_A2_ZN_fallingDelay :: Table2D CInt TransitionTime Capacitance Time +table_NAND2_X4_A2_ZN_fallingDelay = mkTimingTable 8 6 lookTrAxis_NAND2_X4_A2_ZN_fallingDelay lookCapAxis_NAND2_X4_A2_ZN_fallingDelay lookTable_NAND2_X4_A2_ZN_fallingDelay + +foreign import ccall "timing.h lookTrAxis_NAND2_X4_A2_ZN_risingTransition" lookTrAxis_NAND2_X4_A2_ZN_risingTransition :: CInt -> CDouble +foreign import ccall "timing.h lookCapAxis_NAND2_X4_A2_ZN_risingTransition" lookCapAxis_NAND2_X4_A2_ZN_risingTransition :: CInt -> CDouble +foreign import ccall "timing.h lookTable_NAND2_X4_A2_ZN_risingTransition" lookTable_NAND2_X4_A2_ZN_risingTransition :: CInt -> CInt -> CDouble +table_NAND2_X4_A2_ZN_risingTransition :: Table2D CInt TransitionTime Capacitance TransitionTime +table_NAND2_X4_A2_ZN_risingTransition = mkTimingTable 8 6 lookTrAxis_NAND2_X4_A2_ZN_risingTransition lookCapAxis_NAND2_X4_A2_ZN_risingTransition lookTable_NAND2_X4_A2_ZN_risingTransition + +foreign import ccall "timing.h lookTrAxis_NAND2_X4_A2_ZN_fallingTransition" lookTrAxis_NAND2_X4_A2_ZN_fallingTransition :: CInt -> CDouble +foreign import ccall "timing.h lookCapAxis_NAND2_X4_A2_ZN_fallingTransition" lookCapAxis_NAND2_X4_A2_ZN_fallingTransition :: CInt -> CDouble +foreign import ccall "timing.h lookTable_NAND2_X4_A2_ZN_fallingTransition" lookTable_NAND2_X4_A2_ZN_fallingTransition :: CInt -> CInt -> CDouble +table_NAND2_X4_A2_ZN_fallingTransition :: Table2D CInt TransitionTime Capacitance TransitionTime +table_NAND2_X4_A2_ZN_fallingTransition = mkTimingTable 8 6 lookTrAxis_NAND2_X4_A2_ZN_fallingTransition lookCapAxis_NAND2_X4_A2_ZN_fallingTransition lookTable_NAND2_X4_A2_ZN_fallingTransition + +foreign import ccall "timing.h lookTrAxis_NOR2_X1_A1_ZN_risingDelay" lookTrAxis_NOR2_X1_A1_ZN_risingDelay :: CInt -> CDouble +foreign import ccall "timing.h lookCapAxis_NOR2_X1_A1_ZN_risingDelay" lookCapAxis_NOR2_X1_A1_ZN_risingDelay :: CInt -> CDouble +foreign import ccall "timing.h lookTable_NOR2_X1_A1_ZN_risingDelay" lookTable_NOR2_X1_A1_ZN_risingDelay :: CInt -> CInt -> CDouble +table_NOR2_X1_A1_ZN_risingDelay :: Table2D CInt TransitionTime Capacitance Time +table_NOR2_X1_A1_ZN_risingDelay = mkTimingTable 8 6 lookTrAxis_NOR2_X1_A1_ZN_risingDelay lookCapAxis_NOR2_X1_A1_ZN_risingDelay lookTable_NOR2_X1_A1_ZN_risingDelay + +foreign import ccall "timing.h lookTrAxis_NOR2_X1_A1_ZN_fallingDelay" lookTrAxis_NOR2_X1_A1_ZN_fallingDelay :: CInt -> CDouble +foreign import ccall "timing.h lookCapAxis_NOR2_X1_A1_ZN_fallingDelay" lookCapAxis_NOR2_X1_A1_ZN_fallingDelay :: CInt -> CDouble +foreign import ccall "timing.h lookTable_NOR2_X1_A1_ZN_fallingDelay" lookTable_NOR2_X1_A1_ZN_fallingDelay :: CInt -> CInt -> CDouble +table_NOR2_X1_A1_ZN_fallingDelay :: Table2D CInt TransitionTime Capacitance Time +table_NOR2_X1_A1_ZN_fallingDelay = mkTimingTable 8 6 lookTrAxis_NOR2_X1_A1_ZN_fallingDelay lookCapAxis_NOR2_X1_A1_ZN_fallingDelay lookTable_NOR2_X1_A1_ZN_fallingDelay + +foreign import ccall "timing.h lookTrAxis_NOR2_X1_A1_ZN_risingTransition" lookTrAxis_NOR2_X1_A1_ZN_risingTransition :: CInt -> CDouble +foreign import ccall "timing.h lookCapAxis_NOR2_X1_A1_ZN_risingTransition" lookCapAxis_NOR2_X1_A1_ZN_risingTransition :: CInt -> CDouble +foreign import ccall "timing.h lookTable_NOR2_X1_A1_ZN_risingTransition" lookTable_NOR2_X1_A1_ZN_risingTransition :: CInt -> CInt -> CDouble +table_NOR2_X1_A1_ZN_risingTransition :: Table2D CInt TransitionTime Capacitance TransitionTime +table_NOR2_X1_A1_ZN_risingTransition = mkTimingTable 8 6 lookTrAxis_NOR2_X1_A1_ZN_risingTransition lookCapAxis_NOR2_X1_A1_ZN_risingTransition lookTable_NOR2_X1_A1_ZN_risingTransition + +foreign import ccall "timing.h lookTrAxis_NOR2_X1_A1_ZN_fallingTransition" lookTrAxis_NOR2_X1_A1_ZN_fallingTransition :: CInt -> CDouble +foreign import ccall "timing.h lookCapAxis_NOR2_X1_A1_ZN_fallingTransition" lookCapAxis_NOR2_X1_A1_ZN_fallingTransition :: CInt -> CDouble +foreign import ccall "timing.h lookTable_NOR2_X1_A1_ZN_fallingTransition" lookTable_NOR2_X1_A1_ZN_fallingTransition :: CInt -> CInt -> CDouble +table_NOR2_X1_A1_ZN_fallingTransition :: Table2D CInt TransitionTime Capacitance TransitionTime +table_NOR2_X1_A1_ZN_fallingTransition = mkTimingTable 8 6 lookTrAxis_NOR2_X1_A1_ZN_fallingTransition lookCapAxis_NOR2_X1_A1_ZN_fallingTransition lookTable_NOR2_X1_A1_ZN_fallingTransition + +foreign import ccall "timing.h lookTrAxis_NOR2_X1_A2_ZN_risingDelay" lookTrAxis_NOR2_X1_A2_ZN_risingDelay :: CInt -> CDouble +foreign import ccall "timing.h lookCapAxis_NOR2_X1_A2_ZN_risingDelay" lookCapAxis_NOR2_X1_A2_ZN_risingDelay :: CInt -> CDouble +foreign import ccall "timing.h lookTable_NOR2_X1_A2_ZN_risingDelay" lookTable_NOR2_X1_A2_ZN_risingDelay :: CInt -> CInt -> CDouble +table_NOR2_X1_A2_ZN_risingDelay :: Table2D CInt TransitionTime Capacitance Time +table_NOR2_X1_A2_ZN_risingDelay = mkTimingTable 8 6 lookTrAxis_NOR2_X1_A2_ZN_risingDelay lookCapAxis_NOR2_X1_A2_ZN_risingDelay lookTable_NOR2_X1_A2_ZN_risingDelay + +foreign import ccall "timing.h lookTrAxis_NOR2_X1_A2_ZN_fallingDelay" lookTrAxis_NOR2_X1_A2_ZN_fallingDelay :: CInt -> CDouble +foreign import ccall "timing.h lookCapAxis_NOR2_X1_A2_ZN_fallingDelay" lookCapAxis_NOR2_X1_A2_ZN_fallingDelay :: CInt -> CDouble +foreign import ccall "timing.h lookTable_NOR2_X1_A2_ZN_fallingDelay" lookTable_NOR2_X1_A2_ZN_fallingDelay :: CInt -> CInt -> CDouble +table_NOR2_X1_A2_ZN_fallingDelay :: Table2D CInt TransitionTime Capacitance Time +table_NOR2_X1_A2_ZN_fallingDelay = mkTimingTable 8 6 lookTrAxis_NOR2_X1_A2_ZN_fallingDelay lookCapAxis_NOR2_X1_A2_ZN_fallingDelay lookTable_NOR2_X1_A2_ZN_fallingDelay + +foreign import ccall "timing.h lookTrAxis_NOR2_X1_A2_ZN_risingTransition" lookTrAxis_NOR2_X1_A2_ZN_risingTransition :: CInt -> CDouble +foreign import ccall "timing.h lookCapAxis_NOR2_X1_A2_ZN_risingTransition" lookCapAxis_NOR2_X1_A2_ZN_risingTransition :: CInt -> CDouble +foreign import ccall "timing.h lookTable_NOR2_X1_A2_ZN_risingTransition" lookTable_NOR2_X1_A2_ZN_risingTransition :: CInt -> CInt -> CDouble +table_NOR2_X1_A2_ZN_risingTransition :: Table2D CInt TransitionTime Capacitance TransitionTime +table_NOR2_X1_A2_ZN_risingTransition = mkTimingTable 8 6 lookTrAxis_NOR2_X1_A2_ZN_risingTransition lookCapAxis_NOR2_X1_A2_ZN_risingTransition lookTable_NOR2_X1_A2_ZN_risingTransition + +foreign import ccall "timing.h lookTrAxis_NOR2_X1_A2_ZN_fallingTransition" lookTrAxis_NOR2_X1_A2_ZN_fallingTransition :: CInt -> CDouble +foreign import ccall "timing.h lookCapAxis_NOR2_X1_A2_ZN_fallingTransition" lookCapAxis_NOR2_X1_A2_ZN_fallingTransition :: CInt -> CDouble +foreign import ccall "timing.h lookTable_NOR2_X1_A2_ZN_fallingTransition" lookTable_NOR2_X1_A2_ZN_fallingTransition :: CInt -> CInt -> CDouble +table_NOR2_X1_A2_ZN_fallingTransition :: Table2D CInt TransitionTime Capacitance TransitionTime +table_NOR2_X1_A2_ZN_fallingTransition = mkTimingTable 8 6 lookTrAxis_NOR2_X1_A2_ZN_fallingTransition lookCapAxis_NOR2_X1_A2_ZN_fallingTransition lookTable_NOR2_X1_A2_ZN_fallingTransition + +foreign import ccall "timing.h lookTrAxis_NOR2_X2_A1_ZN_risingDelay" lookTrAxis_NOR2_X2_A1_ZN_risingDelay :: CInt -> CDouble +foreign import ccall "timing.h lookCapAxis_NOR2_X2_A1_ZN_risingDelay" lookCapAxis_NOR2_X2_A1_ZN_risingDelay :: CInt -> CDouble +foreign import ccall "timing.h lookTable_NOR2_X2_A1_ZN_risingDelay" lookTable_NOR2_X2_A1_ZN_risingDelay :: CInt -> CInt -> CDouble +table_NOR2_X2_A1_ZN_risingDelay :: Table2D CInt TransitionTime Capacitance Time +table_NOR2_X2_A1_ZN_risingDelay = mkTimingTable 8 6 lookTrAxis_NOR2_X2_A1_ZN_risingDelay lookCapAxis_NOR2_X2_A1_ZN_risingDelay lookTable_NOR2_X2_A1_ZN_risingDelay + +foreign import ccall "timing.h lookTrAxis_NOR2_X2_A1_ZN_fallingDelay" lookTrAxis_NOR2_X2_A1_ZN_fallingDelay :: CInt -> CDouble +foreign import ccall "timing.h lookCapAxis_NOR2_X2_A1_ZN_fallingDelay" lookCapAxis_NOR2_X2_A1_ZN_fallingDelay :: CInt -> CDouble +foreign import ccall "timing.h lookTable_NOR2_X2_A1_ZN_fallingDelay" lookTable_NOR2_X2_A1_ZN_fallingDelay :: CInt -> CInt -> CDouble +table_NOR2_X2_A1_ZN_fallingDelay :: Table2D CInt TransitionTime Capacitance Time +table_NOR2_X2_A1_ZN_fallingDelay = mkTimingTable 8 6 lookTrAxis_NOR2_X2_A1_ZN_fallingDelay lookCapAxis_NOR2_X2_A1_ZN_fallingDelay lookTable_NOR2_X2_A1_ZN_fallingDelay + +foreign import ccall "timing.h lookTrAxis_NOR2_X2_A1_ZN_risingTransition" lookTrAxis_NOR2_X2_A1_ZN_risingTransition :: CInt -> CDouble +foreign import ccall "timing.h lookCapAxis_NOR2_X2_A1_ZN_risingTransition" lookCapAxis_NOR2_X2_A1_ZN_risingTransition :: CInt -> CDouble +foreign import ccall "timing.h lookTable_NOR2_X2_A1_ZN_risingTransition" lookTable_NOR2_X2_A1_ZN_risingTransition :: CInt -> CInt -> CDouble +table_NOR2_X2_A1_ZN_risingTransition :: Table2D CInt TransitionTime Capacitance TransitionTime +table_NOR2_X2_A1_ZN_risingTransition = mkTimingTable 8 6 lookTrAxis_NOR2_X2_A1_ZN_risingTransition lookCapAxis_NOR2_X2_A1_ZN_risingTransition lookTable_NOR2_X2_A1_ZN_risingTransition + +foreign import ccall "timing.h lookTrAxis_NOR2_X2_A1_ZN_fallingTransition" lookTrAxis_NOR2_X2_A1_ZN_fallingTransition :: CInt -> CDouble +foreign import ccall "timing.h lookCapAxis_NOR2_X2_A1_ZN_fallingTransition" lookCapAxis_NOR2_X2_A1_ZN_fallingTransition :: CInt -> CDouble +foreign import ccall "timing.h lookTable_NOR2_X2_A1_ZN_fallingTransition" lookTable_NOR2_X2_A1_ZN_fallingTransition :: CInt -> CInt -> CDouble +table_NOR2_X2_A1_ZN_fallingTransition :: Table2D CInt TransitionTime Capacitance TransitionTime +table_NOR2_X2_A1_ZN_fallingTransition = mkTimingTable 8 6 lookTrAxis_NOR2_X2_A1_ZN_fallingTransition lookCapAxis_NOR2_X2_A1_ZN_fallingTransition lookTable_NOR2_X2_A1_ZN_fallingTransition + +foreign import ccall "timing.h lookTrAxis_NOR2_X2_A2_ZN_risingDelay" lookTrAxis_NOR2_X2_A2_ZN_risingDelay :: CInt -> CDouble +foreign import ccall "timing.h lookCapAxis_NOR2_X2_A2_ZN_risingDelay" lookCapAxis_NOR2_X2_A2_ZN_risingDelay :: CInt -> CDouble +foreign import ccall "timing.h lookTable_NOR2_X2_A2_ZN_risingDelay" lookTable_NOR2_X2_A2_ZN_risingDelay :: CInt -> CInt -> CDouble +table_NOR2_X2_A2_ZN_risingDelay :: Table2D CInt TransitionTime Capacitance Time +table_NOR2_X2_A2_ZN_risingDelay = mkTimingTable 8 6 lookTrAxis_NOR2_X2_A2_ZN_risingDelay lookCapAxis_NOR2_X2_A2_ZN_risingDelay lookTable_NOR2_X2_A2_ZN_risingDelay + +foreign import ccall "timing.h lookTrAxis_NOR2_X2_A2_ZN_fallingDelay" lookTrAxis_NOR2_X2_A2_ZN_fallingDelay :: CInt -> CDouble +foreign import ccall "timing.h lookCapAxis_NOR2_X2_A2_ZN_fallingDelay" lookCapAxis_NOR2_X2_A2_ZN_fallingDelay :: CInt -> CDouble +foreign import ccall "timing.h lookTable_NOR2_X2_A2_ZN_fallingDelay" lookTable_NOR2_X2_A2_ZN_fallingDelay :: CInt -> CInt -> CDouble +table_NOR2_X2_A2_ZN_fallingDelay :: Table2D CInt TransitionTime Capacitance Time +table_NOR2_X2_A2_ZN_fallingDelay = mkTimingTable 8 6 lookTrAxis_NOR2_X2_A2_ZN_fallingDelay lookCapAxis_NOR2_X2_A2_ZN_fallingDelay lookTable_NOR2_X2_A2_ZN_fallingDelay + +foreign import ccall "timing.h lookTrAxis_NOR2_X2_A2_ZN_risingTransition" lookTrAxis_NOR2_X2_A2_ZN_risingTransition :: CInt -> CDouble +foreign import ccall "timing.h lookCapAxis_NOR2_X2_A2_ZN_risingTransition" lookCapAxis_NOR2_X2_A2_ZN_risingTransition :: CInt -> CDouble +foreign import ccall "timing.h lookTable_NOR2_X2_A2_ZN_risingTransition" lookTable_NOR2_X2_A2_ZN_risingTransition :: CInt -> CInt -> CDouble +table_NOR2_X2_A2_ZN_risingTransition :: Table2D CInt TransitionTime Capacitance TransitionTime +table_NOR2_X2_A2_ZN_risingTransition = mkTimingTable 8 6 lookTrAxis_NOR2_X2_A2_ZN_risingTransition lookCapAxis_NOR2_X2_A2_ZN_risingTransition lookTable_NOR2_X2_A2_ZN_risingTransition + +foreign import ccall "timing.h lookTrAxis_NOR2_X2_A2_ZN_fallingTransition" lookTrAxis_NOR2_X2_A2_ZN_fallingTransition :: CInt -> CDouble +foreign import ccall "timing.h lookCapAxis_NOR2_X2_A2_ZN_fallingTransition" lookCapAxis_NOR2_X2_A2_ZN_fallingTransition :: CInt -> CDouble +foreign import ccall "timing.h lookTable_NOR2_X2_A2_ZN_fallingTransition" lookTable_NOR2_X2_A2_ZN_fallingTransition :: CInt -> CInt -> CDouble +table_NOR2_X2_A2_ZN_fallingTransition :: Table2D CInt TransitionTime Capacitance TransitionTime +table_NOR2_X2_A2_ZN_fallingTransition = mkTimingTable 8 6 lookTrAxis_NOR2_X2_A2_ZN_fallingTransition lookCapAxis_NOR2_X2_A2_ZN_fallingTransition lookTable_NOR2_X2_A2_ZN_fallingTransition + +foreign import ccall "timing.h lookTrAxis_NOR2_X4_A1_ZN_risingDelay" lookTrAxis_NOR2_X4_A1_ZN_risingDelay :: CInt -> CDouble +foreign import ccall "timing.h lookCapAxis_NOR2_X4_A1_ZN_risingDelay" lookCapAxis_NOR2_X4_A1_ZN_risingDelay :: CInt -> CDouble +foreign import ccall "timing.h lookTable_NOR2_X4_A1_ZN_risingDelay" lookTable_NOR2_X4_A1_ZN_risingDelay :: CInt -> CInt -> CDouble +table_NOR2_X4_A1_ZN_risingDelay :: Table2D CInt TransitionTime Capacitance Time +table_NOR2_X4_A1_ZN_risingDelay = mkTimingTable 8 6 lookTrAxis_NOR2_X4_A1_ZN_risingDelay lookCapAxis_NOR2_X4_A1_ZN_risingDelay lookTable_NOR2_X4_A1_ZN_risingDelay + +foreign import ccall "timing.h lookTrAxis_NOR2_X4_A1_ZN_fallingDelay" lookTrAxis_NOR2_X4_A1_ZN_fallingDelay :: CInt -> CDouble +foreign import ccall "timing.h lookCapAxis_NOR2_X4_A1_ZN_fallingDelay" lookCapAxis_NOR2_X4_A1_ZN_fallingDelay :: CInt -> CDouble +foreign import ccall "timing.h lookTable_NOR2_X4_A1_ZN_fallingDelay" lookTable_NOR2_X4_A1_ZN_fallingDelay :: CInt -> CInt -> CDouble +table_NOR2_X4_A1_ZN_fallingDelay :: Table2D CInt TransitionTime Capacitance Time +table_NOR2_X4_A1_ZN_fallingDelay = mkTimingTable 8 6 lookTrAxis_NOR2_X4_A1_ZN_fallingDelay lookCapAxis_NOR2_X4_A1_ZN_fallingDelay lookTable_NOR2_X4_A1_ZN_fallingDelay + +foreign import ccall "timing.h lookTrAxis_NOR2_X4_A1_ZN_risingTransition" lookTrAxis_NOR2_X4_A1_ZN_risingTransition :: CInt -> CDouble +foreign import ccall "timing.h lookCapAxis_NOR2_X4_A1_ZN_risingTransition" lookCapAxis_NOR2_X4_A1_ZN_risingTransition :: CInt -> CDouble +foreign import ccall "timing.h lookTable_NOR2_X4_A1_ZN_risingTransition" lookTable_NOR2_X4_A1_ZN_risingTransition :: CInt -> CInt -> CDouble +table_NOR2_X4_A1_ZN_risingTransition :: Table2D CInt TransitionTime Capacitance TransitionTime +table_NOR2_X4_A1_ZN_risingTransition = mkTimingTable 8 6 lookTrAxis_NOR2_X4_A1_ZN_risingTransition lookCapAxis_NOR2_X4_A1_ZN_risingTransition lookTable_NOR2_X4_A1_ZN_risingTransition + +foreign import ccall "timing.h lookTrAxis_NOR2_X4_A1_ZN_fallingTransition" lookTrAxis_NOR2_X4_A1_ZN_fallingTransition :: CInt -> CDouble +foreign import ccall "timing.h lookCapAxis_NOR2_X4_A1_ZN_fallingTransition" lookCapAxis_NOR2_X4_A1_ZN_fallingTransition :: CInt -> CDouble +foreign import ccall "timing.h lookTable_NOR2_X4_A1_ZN_fallingTransition" lookTable_NOR2_X4_A1_ZN_fallingTransition :: CInt -> CInt -> CDouble +table_NOR2_X4_A1_ZN_fallingTransition :: Table2D CInt TransitionTime Capacitance TransitionTime +table_NOR2_X4_A1_ZN_fallingTransition = mkTimingTable 8 6 lookTrAxis_NOR2_X4_A1_ZN_fallingTransition lookCapAxis_NOR2_X4_A1_ZN_fallingTransition lookTable_NOR2_X4_A1_ZN_fallingTransition + +foreign import ccall "timing.h lookTrAxis_NOR2_X4_A2_ZN_risingDelay" lookTrAxis_NOR2_X4_A2_ZN_risingDelay :: CInt -> CDouble +foreign import ccall "timing.h lookCapAxis_NOR2_X4_A2_ZN_risingDelay" lookCapAxis_NOR2_X4_A2_ZN_risingDelay :: CInt -> CDouble +foreign import ccall "timing.h lookTable_NOR2_X4_A2_ZN_risingDelay" lookTable_NOR2_X4_A2_ZN_risingDelay :: CInt -> CInt -> CDouble +table_NOR2_X4_A2_ZN_risingDelay :: Table2D CInt TransitionTime Capacitance Time +table_NOR2_X4_A2_ZN_risingDelay = mkTimingTable 8 6 lookTrAxis_NOR2_X4_A2_ZN_risingDelay lookCapAxis_NOR2_X4_A2_ZN_risingDelay lookTable_NOR2_X4_A2_ZN_risingDelay + +foreign import ccall "timing.h lookTrAxis_NOR2_X4_A2_ZN_fallingDelay" lookTrAxis_NOR2_X4_A2_ZN_fallingDelay :: CInt -> CDouble +foreign import ccall "timing.h lookCapAxis_NOR2_X4_A2_ZN_fallingDelay" lookCapAxis_NOR2_X4_A2_ZN_fallingDelay :: CInt -> CDouble +foreign import ccall "timing.h lookTable_NOR2_X4_A2_ZN_fallingDelay" lookTable_NOR2_X4_A2_ZN_fallingDelay :: CInt -> CInt -> CDouble +table_NOR2_X4_A2_ZN_fallingDelay :: Table2D CInt TransitionTime Capacitance Time +table_NOR2_X4_A2_ZN_fallingDelay = mkTimingTable 8 6 lookTrAxis_NOR2_X4_A2_ZN_fallingDelay lookCapAxis_NOR2_X4_A2_ZN_fallingDelay lookTable_NOR2_X4_A2_ZN_fallingDelay + +foreign import ccall "timing.h lookTrAxis_NOR2_X4_A2_ZN_risingTransition" lookTrAxis_NOR2_X4_A2_ZN_risingTransition :: CInt -> CDouble +foreign import ccall "timing.h lookCapAxis_NOR2_X4_A2_ZN_risingTransition" lookCapAxis_NOR2_X4_A2_ZN_risingTransition :: CInt -> CDouble +foreign import ccall "timing.h lookTable_NOR2_X4_A2_ZN_risingTransition" lookTable_NOR2_X4_A2_ZN_risingTransition :: CInt -> CInt -> CDouble +table_NOR2_X4_A2_ZN_risingTransition :: Table2D CInt TransitionTime Capacitance TransitionTime +table_NOR2_X4_A2_ZN_risingTransition = mkTimingTable 8 6 lookTrAxis_NOR2_X4_A2_ZN_risingTransition lookCapAxis_NOR2_X4_A2_ZN_risingTransition lookTable_NOR2_X4_A2_ZN_risingTransition + +foreign import ccall "timing.h lookTrAxis_NOR2_X4_A2_ZN_fallingTransition" lookTrAxis_NOR2_X4_A2_ZN_fallingTransition :: CInt -> CDouble +foreign import ccall "timing.h lookCapAxis_NOR2_X4_A2_ZN_fallingTransition" lookCapAxis_NOR2_X4_A2_ZN_fallingTransition :: CInt -> CDouble +foreign import ccall "timing.h lookTable_NOR2_X4_A2_ZN_fallingTransition" lookTable_NOR2_X4_A2_ZN_fallingTransition :: CInt -> CInt -> CDouble +table_NOR2_X4_A2_ZN_fallingTransition :: Table2D CInt TransitionTime Capacitance TransitionTime +table_NOR2_X4_A2_ZN_fallingTransition = mkTimingTable 8 6 lookTrAxis_NOR2_X4_A2_ZN_fallingTransition lookCapAxis_NOR2_X4_A2_ZN_fallingTransition lookTable_NOR2_X4_A2_ZN_fallingTransition + +foreign import ccall "timing.h lookTrAxis_OR2_X1_A1_ZN_risingDelay" lookTrAxis_OR2_X1_A1_ZN_risingDelay :: CInt -> CDouble +foreign import ccall "timing.h lookCapAxis_OR2_X1_A1_ZN_risingDelay" lookCapAxis_OR2_X1_A1_ZN_risingDelay :: CInt -> CDouble +foreign import ccall "timing.h lookTable_OR2_X1_A1_ZN_risingDelay" lookTable_OR2_X1_A1_ZN_risingDelay :: CInt -> CInt -> CDouble +table_OR2_X1_A1_ZN_risingDelay :: Table2D CInt TransitionTime Capacitance Time +table_OR2_X1_A1_ZN_risingDelay = mkTimingTable 8 6 lookTrAxis_OR2_X1_A1_ZN_risingDelay lookCapAxis_OR2_X1_A1_ZN_risingDelay lookTable_OR2_X1_A1_ZN_risingDelay + +foreign import ccall "timing.h lookTrAxis_OR2_X1_A1_ZN_fallingDelay" lookTrAxis_OR2_X1_A1_ZN_fallingDelay :: CInt -> CDouble +foreign import ccall "timing.h lookCapAxis_OR2_X1_A1_ZN_fallingDelay" lookCapAxis_OR2_X1_A1_ZN_fallingDelay :: CInt -> CDouble +foreign import ccall "timing.h lookTable_OR2_X1_A1_ZN_fallingDelay" lookTable_OR2_X1_A1_ZN_fallingDelay :: CInt -> CInt -> CDouble +table_OR2_X1_A1_ZN_fallingDelay :: Table2D CInt TransitionTime Capacitance Time +table_OR2_X1_A1_ZN_fallingDelay = mkTimingTable 8 6 lookTrAxis_OR2_X1_A1_ZN_fallingDelay lookCapAxis_OR2_X1_A1_ZN_fallingDelay lookTable_OR2_X1_A1_ZN_fallingDelay + +foreign import ccall "timing.h lookTrAxis_OR2_X1_A1_ZN_risingTransition" lookTrAxis_OR2_X1_A1_ZN_risingTransition :: CInt -> CDouble +foreign import ccall "timing.h lookCapAxis_OR2_X1_A1_ZN_risingTransition" lookCapAxis_OR2_X1_A1_ZN_risingTransition :: CInt -> CDouble +foreign import ccall "timing.h lookTable_OR2_X1_A1_ZN_risingTransition" lookTable_OR2_X1_A1_ZN_risingTransition :: CInt -> CInt -> CDouble +table_OR2_X1_A1_ZN_risingTransition :: Table2D CInt TransitionTime Capacitance TransitionTime +table_OR2_X1_A1_ZN_risingTransition = mkTimingTable 8 6 lookTrAxis_OR2_X1_A1_ZN_risingTransition lookCapAxis_OR2_X1_A1_ZN_risingTransition lookTable_OR2_X1_A1_ZN_risingTransition + +foreign import ccall "timing.h lookTrAxis_OR2_X1_A1_ZN_fallingTransition" lookTrAxis_OR2_X1_A1_ZN_fallingTransition :: CInt -> CDouble +foreign import ccall "timing.h lookCapAxis_OR2_X1_A1_ZN_fallingTransition" lookCapAxis_OR2_X1_A1_ZN_fallingTransition :: CInt -> CDouble +foreign import ccall "timing.h lookTable_OR2_X1_A1_ZN_fallingTransition" lookTable_OR2_X1_A1_ZN_fallingTransition :: CInt -> CInt -> CDouble +table_OR2_X1_A1_ZN_fallingTransition :: Table2D CInt TransitionTime Capacitance TransitionTime +table_OR2_X1_A1_ZN_fallingTransition = mkTimingTable 8 6 lookTrAxis_OR2_X1_A1_ZN_fallingTransition lookCapAxis_OR2_X1_A1_ZN_fallingTransition lookTable_OR2_X1_A1_ZN_fallingTransition + +foreign import ccall "timing.h lookTrAxis_OR2_X1_A2_ZN_risingDelay" lookTrAxis_OR2_X1_A2_ZN_risingDelay :: CInt -> CDouble +foreign import ccall "timing.h lookCapAxis_OR2_X1_A2_ZN_risingDelay" lookCapAxis_OR2_X1_A2_ZN_risingDelay :: CInt -> CDouble +foreign import ccall "timing.h lookTable_OR2_X1_A2_ZN_risingDelay" lookTable_OR2_X1_A2_ZN_risingDelay :: CInt -> CInt -> CDouble +table_OR2_X1_A2_ZN_risingDelay :: Table2D CInt TransitionTime Capacitance Time +table_OR2_X1_A2_ZN_risingDelay = mkTimingTable 8 6 lookTrAxis_OR2_X1_A2_ZN_risingDelay lookCapAxis_OR2_X1_A2_ZN_risingDelay lookTable_OR2_X1_A2_ZN_risingDelay + +foreign import ccall "timing.h lookTrAxis_OR2_X1_A2_ZN_fallingDelay" lookTrAxis_OR2_X1_A2_ZN_fallingDelay :: CInt -> CDouble +foreign import ccall "timing.h lookCapAxis_OR2_X1_A2_ZN_fallingDelay" lookCapAxis_OR2_X1_A2_ZN_fallingDelay :: CInt -> CDouble +foreign import ccall "timing.h lookTable_OR2_X1_A2_ZN_fallingDelay" lookTable_OR2_X1_A2_ZN_fallingDelay :: CInt -> CInt -> CDouble +table_OR2_X1_A2_ZN_fallingDelay :: Table2D CInt TransitionTime Capacitance Time +table_OR2_X1_A2_ZN_fallingDelay = mkTimingTable 8 6 lookTrAxis_OR2_X1_A2_ZN_fallingDelay lookCapAxis_OR2_X1_A2_ZN_fallingDelay lookTable_OR2_X1_A2_ZN_fallingDelay + +foreign import ccall "timing.h lookTrAxis_OR2_X1_A2_ZN_risingTransition" lookTrAxis_OR2_X1_A2_ZN_risingTransition :: CInt -> CDouble +foreign import ccall "timing.h lookCapAxis_OR2_X1_A2_ZN_risingTransition" lookCapAxis_OR2_X1_A2_ZN_risingTransition :: CInt -> CDouble +foreign import ccall "timing.h lookTable_OR2_X1_A2_ZN_risingTransition" lookTable_OR2_X1_A2_ZN_risingTransition :: CInt -> CInt -> CDouble +table_OR2_X1_A2_ZN_risingTransition :: Table2D CInt TransitionTime Capacitance TransitionTime +table_OR2_X1_A2_ZN_risingTransition = mkTimingTable 8 6 lookTrAxis_OR2_X1_A2_ZN_risingTransition lookCapAxis_OR2_X1_A2_ZN_risingTransition lookTable_OR2_X1_A2_ZN_risingTransition + +foreign import ccall "timing.h lookTrAxis_OR2_X1_A2_ZN_fallingTransition" lookTrAxis_OR2_X1_A2_ZN_fallingTransition :: CInt -> CDouble +foreign import ccall "timing.h lookCapAxis_OR2_X1_A2_ZN_fallingTransition" lookCapAxis_OR2_X1_A2_ZN_fallingTransition :: CInt -> CDouble +foreign import ccall "timing.h lookTable_OR2_X1_A2_ZN_fallingTransition" lookTable_OR2_X1_A2_ZN_fallingTransition :: CInt -> CInt -> CDouble +table_OR2_X1_A2_ZN_fallingTransition :: Table2D CInt TransitionTime Capacitance TransitionTime +table_OR2_X1_A2_ZN_fallingTransition = mkTimingTable 8 6 lookTrAxis_OR2_X1_A2_ZN_fallingTransition lookCapAxis_OR2_X1_A2_ZN_fallingTransition lookTable_OR2_X1_A2_ZN_fallingTransition + +foreign import ccall "timing.h lookTrAxis_OR2_X2_A1_ZN_risingDelay" lookTrAxis_OR2_X2_A1_ZN_risingDelay :: CInt -> CDouble +foreign import ccall "timing.h lookCapAxis_OR2_X2_A1_ZN_risingDelay" lookCapAxis_OR2_X2_A1_ZN_risingDelay :: CInt -> CDouble +foreign import ccall "timing.h lookTable_OR2_X2_A1_ZN_risingDelay" lookTable_OR2_X2_A1_ZN_risingDelay :: CInt -> CInt -> CDouble +table_OR2_X2_A1_ZN_risingDelay :: Table2D CInt TransitionTime Capacitance Time +table_OR2_X2_A1_ZN_risingDelay = mkTimingTable 8 6 lookTrAxis_OR2_X2_A1_ZN_risingDelay lookCapAxis_OR2_X2_A1_ZN_risingDelay lookTable_OR2_X2_A1_ZN_risingDelay + +foreign import ccall "timing.h lookTrAxis_OR2_X2_A1_ZN_fallingDelay" lookTrAxis_OR2_X2_A1_ZN_fallingDelay :: CInt -> CDouble +foreign import ccall "timing.h lookCapAxis_OR2_X2_A1_ZN_fallingDelay" lookCapAxis_OR2_X2_A1_ZN_fallingDelay :: CInt -> CDouble +foreign import ccall "timing.h lookTable_OR2_X2_A1_ZN_fallingDelay" lookTable_OR2_X2_A1_ZN_fallingDelay :: CInt -> CInt -> CDouble +table_OR2_X2_A1_ZN_fallingDelay :: Table2D CInt TransitionTime Capacitance Time +table_OR2_X2_A1_ZN_fallingDelay = mkTimingTable 8 6 lookTrAxis_OR2_X2_A1_ZN_fallingDelay lookCapAxis_OR2_X2_A1_ZN_fallingDelay lookTable_OR2_X2_A1_ZN_fallingDelay + +foreign import ccall "timing.h lookTrAxis_OR2_X2_A1_ZN_risingTransition" lookTrAxis_OR2_X2_A1_ZN_risingTransition :: CInt -> CDouble +foreign import ccall "timing.h lookCapAxis_OR2_X2_A1_ZN_risingTransition" lookCapAxis_OR2_X2_A1_ZN_risingTransition :: CInt -> CDouble +foreign import ccall "timing.h lookTable_OR2_X2_A1_ZN_risingTransition" lookTable_OR2_X2_A1_ZN_risingTransition :: CInt -> CInt -> CDouble +table_OR2_X2_A1_ZN_risingTransition :: Table2D CInt TransitionTime Capacitance TransitionTime +table_OR2_X2_A1_ZN_risingTransition = mkTimingTable 8 6 lookTrAxis_OR2_X2_A1_ZN_risingTransition lookCapAxis_OR2_X2_A1_ZN_risingTransition lookTable_OR2_X2_A1_ZN_risingTransition + +foreign import ccall "timing.h lookTrAxis_OR2_X2_A1_ZN_fallingTransition" lookTrAxis_OR2_X2_A1_ZN_fallingTransition :: CInt -> CDouble +foreign import ccall "timing.h lookCapAxis_OR2_X2_A1_ZN_fallingTransition" lookCapAxis_OR2_X2_A1_ZN_fallingTransition :: CInt -> CDouble +foreign import ccall "timing.h lookTable_OR2_X2_A1_ZN_fallingTransition" lookTable_OR2_X2_A1_ZN_fallingTransition :: CInt -> CInt -> CDouble +table_OR2_X2_A1_ZN_fallingTransition :: Table2D CInt TransitionTime Capacitance TransitionTime +table_OR2_X2_A1_ZN_fallingTransition = mkTimingTable 8 6 lookTrAxis_OR2_X2_A1_ZN_fallingTransition lookCapAxis_OR2_X2_A1_ZN_fallingTransition lookTable_OR2_X2_A1_ZN_fallingTransition + +foreign import ccall "timing.h lookTrAxis_OR2_X2_A2_ZN_risingDelay" lookTrAxis_OR2_X2_A2_ZN_risingDelay :: CInt -> CDouble +foreign import ccall "timing.h lookCapAxis_OR2_X2_A2_ZN_risingDelay" lookCapAxis_OR2_X2_A2_ZN_risingDelay :: CInt -> CDouble +foreign import ccall "timing.h lookTable_OR2_X2_A2_ZN_risingDelay" lookTable_OR2_X2_A2_ZN_risingDelay :: CInt -> CInt -> CDouble +table_OR2_X2_A2_ZN_risingDelay :: Table2D CInt TransitionTime Capacitance Time +table_OR2_X2_A2_ZN_risingDelay = mkTimingTable 8 6 lookTrAxis_OR2_X2_A2_ZN_risingDelay lookCapAxis_OR2_X2_A2_ZN_risingDelay lookTable_OR2_X2_A2_ZN_risingDelay + +foreign import ccall "timing.h lookTrAxis_OR2_X2_A2_ZN_fallingDelay" lookTrAxis_OR2_X2_A2_ZN_fallingDelay :: CInt -> CDouble +foreign import ccall "timing.h lookCapAxis_OR2_X2_A2_ZN_fallingDelay" lookCapAxis_OR2_X2_A2_ZN_fallingDelay :: CInt -> CDouble +foreign import ccall "timing.h lookTable_OR2_X2_A2_ZN_fallingDelay" lookTable_OR2_X2_A2_ZN_fallingDelay :: CInt -> CInt -> CDouble +table_OR2_X2_A2_ZN_fallingDelay :: Table2D CInt TransitionTime Capacitance Time +table_OR2_X2_A2_ZN_fallingDelay = mkTimingTable 8 6 lookTrAxis_OR2_X2_A2_ZN_fallingDelay lookCapAxis_OR2_X2_A2_ZN_fallingDelay lookTable_OR2_X2_A2_ZN_fallingDelay + +foreign import ccall "timing.h lookTrAxis_OR2_X2_A2_ZN_risingTransition" lookTrAxis_OR2_X2_A2_ZN_risingTransition :: CInt -> CDouble +foreign import ccall "timing.h lookCapAxis_OR2_X2_A2_ZN_risingTransition" lookCapAxis_OR2_X2_A2_ZN_risingTransition :: CInt -> CDouble +foreign import ccall "timing.h lookTable_OR2_X2_A2_ZN_risingTransition" lookTable_OR2_X2_A2_ZN_risingTransition :: CInt -> CInt -> CDouble +table_OR2_X2_A2_ZN_risingTransition :: Table2D CInt TransitionTime Capacitance TransitionTime +table_OR2_X2_A2_ZN_risingTransition = mkTimingTable 8 6 lookTrAxis_OR2_X2_A2_ZN_risingTransition lookCapAxis_OR2_X2_A2_ZN_risingTransition lookTable_OR2_X2_A2_ZN_risingTransition + +foreign import ccall "timing.h lookTrAxis_OR2_X2_A2_ZN_fallingTransition" lookTrAxis_OR2_X2_A2_ZN_fallingTransition :: CInt -> CDouble +foreign import ccall "timing.h lookCapAxis_OR2_X2_A2_ZN_fallingTransition" lookCapAxis_OR2_X2_A2_ZN_fallingTransition :: CInt -> CDouble +foreign import ccall "timing.h lookTable_OR2_X2_A2_ZN_fallingTransition" lookTable_OR2_X2_A2_ZN_fallingTransition :: CInt -> CInt -> CDouble +table_OR2_X2_A2_ZN_fallingTransition :: Table2D CInt TransitionTime Capacitance TransitionTime +table_OR2_X2_A2_ZN_fallingTransition = mkTimingTable 8 6 lookTrAxis_OR2_X2_A2_ZN_fallingTransition lookCapAxis_OR2_X2_A2_ZN_fallingTransition lookTable_OR2_X2_A2_ZN_fallingTransition + +foreign import ccall "timing.h lookTrAxis_OR2_X4_A1_ZN_risingDelay" lookTrAxis_OR2_X4_A1_ZN_risingDelay :: CInt -> CDouble +foreign import ccall "timing.h lookCapAxis_OR2_X4_A1_ZN_risingDelay" lookCapAxis_OR2_X4_A1_ZN_risingDelay :: CInt -> CDouble +foreign import ccall "timing.h lookTable_OR2_X4_A1_ZN_risingDelay" lookTable_OR2_X4_A1_ZN_risingDelay :: CInt -> CInt -> CDouble +table_OR2_X4_A1_ZN_risingDelay :: Table2D CInt TransitionTime Capacitance Time +table_OR2_X4_A1_ZN_risingDelay = mkTimingTable 8 6 lookTrAxis_OR2_X4_A1_ZN_risingDelay lookCapAxis_OR2_X4_A1_ZN_risingDelay lookTable_OR2_X4_A1_ZN_risingDelay + +foreign import ccall "timing.h lookTrAxis_OR2_X4_A1_ZN_fallingDelay" lookTrAxis_OR2_X4_A1_ZN_fallingDelay :: CInt -> CDouble +foreign import ccall "timing.h lookCapAxis_OR2_X4_A1_ZN_fallingDelay" lookCapAxis_OR2_X4_A1_ZN_fallingDelay :: CInt -> CDouble +foreign import ccall "timing.h lookTable_OR2_X4_A1_ZN_fallingDelay" lookTable_OR2_X4_A1_ZN_fallingDelay :: CInt -> CInt -> CDouble +table_OR2_X4_A1_ZN_fallingDelay :: Table2D CInt TransitionTime Capacitance Time +table_OR2_X4_A1_ZN_fallingDelay = mkTimingTable 8 6 lookTrAxis_OR2_X4_A1_ZN_fallingDelay lookCapAxis_OR2_X4_A1_ZN_fallingDelay lookTable_OR2_X4_A1_ZN_fallingDelay + +foreign import ccall "timing.h lookTrAxis_OR2_X4_A1_ZN_risingTransition" lookTrAxis_OR2_X4_A1_ZN_risingTransition :: CInt -> CDouble +foreign import ccall "timing.h lookCapAxis_OR2_X4_A1_ZN_risingTransition" lookCapAxis_OR2_X4_A1_ZN_risingTransition :: CInt -> CDouble +foreign import ccall "timing.h lookTable_OR2_X4_A1_ZN_risingTransition" lookTable_OR2_X4_A1_ZN_risingTransition :: CInt -> CInt -> CDouble +table_OR2_X4_A1_ZN_risingTransition :: Table2D CInt TransitionTime Capacitance TransitionTime +table_OR2_X4_A1_ZN_risingTransition = mkTimingTable 8 6 lookTrAxis_OR2_X4_A1_ZN_risingTransition lookCapAxis_OR2_X4_A1_ZN_risingTransition lookTable_OR2_X4_A1_ZN_risingTransition + +foreign import ccall "timing.h lookTrAxis_OR2_X4_A1_ZN_fallingTransition" lookTrAxis_OR2_X4_A1_ZN_fallingTransition :: CInt -> CDouble +foreign import ccall "timing.h lookCapAxis_OR2_X4_A1_ZN_fallingTransition" lookCapAxis_OR2_X4_A1_ZN_fallingTransition :: CInt -> CDouble +foreign import ccall "timing.h lookTable_OR2_X4_A1_ZN_fallingTransition" lookTable_OR2_X4_A1_ZN_fallingTransition :: CInt -> CInt -> CDouble +table_OR2_X4_A1_ZN_fallingTransition :: Table2D CInt TransitionTime Capacitance TransitionTime +table_OR2_X4_A1_ZN_fallingTransition = mkTimingTable 8 6 lookTrAxis_OR2_X4_A1_ZN_fallingTransition lookCapAxis_OR2_X4_A1_ZN_fallingTransition lookTable_OR2_X4_A1_ZN_fallingTransition + +foreign import ccall "timing.h lookTrAxis_OR2_X4_A2_ZN_risingDelay" lookTrAxis_OR2_X4_A2_ZN_risingDelay :: CInt -> CDouble +foreign import ccall "timing.h lookCapAxis_OR2_X4_A2_ZN_risingDelay" lookCapAxis_OR2_X4_A2_ZN_risingDelay :: CInt -> CDouble +foreign import ccall "timing.h lookTable_OR2_X4_A2_ZN_risingDelay" lookTable_OR2_X4_A2_ZN_risingDelay :: CInt -> CInt -> CDouble +table_OR2_X4_A2_ZN_risingDelay :: Table2D CInt TransitionTime Capacitance Time +table_OR2_X4_A2_ZN_risingDelay = mkTimingTable 8 6 lookTrAxis_OR2_X4_A2_ZN_risingDelay lookCapAxis_OR2_X4_A2_ZN_risingDelay lookTable_OR2_X4_A2_ZN_risingDelay + +foreign import ccall "timing.h lookTrAxis_OR2_X4_A2_ZN_fallingDelay" lookTrAxis_OR2_X4_A2_ZN_fallingDelay :: CInt -> CDouble +foreign import ccall "timing.h lookCapAxis_OR2_X4_A2_ZN_fallingDelay" lookCapAxis_OR2_X4_A2_ZN_fallingDelay :: CInt -> CDouble +foreign import ccall "timing.h lookTable_OR2_X4_A2_ZN_fallingDelay" lookTable_OR2_X4_A2_ZN_fallingDelay :: CInt -> CInt -> CDouble +table_OR2_X4_A2_ZN_fallingDelay :: Table2D CInt TransitionTime Capacitance Time +table_OR2_X4_A2_ZN_fallingDelay = mkTimingTable 8 6 lookTrAxis_OR2_X4_A2_ZN_fallingDelay lookCapAxis_OR2_X4_A2_ZN_fallingDelay lookTable_OR2_X4_A2_ZN_fallingDelay + +foreign import ccall "timing.h lookTrAxis_OR2_X4_A2_ZN_risingTransition" lookTrAxis_OR2_X4_A2_ZN_risingTransition :: CInt -> CDouble +foreign import ccall "timing.h lookCapAxis_OR2_X4_A2_ZN_risingTransition" lookCapAxis_OR2_X4_A2_ZN_risingTransition :: CInt -> CDouble +foreign import ccall "timing.h lookTable_OR2_X4_A2_ZN_risingTransition" lookTable_OR2_X4_A2_ZN_risingTransition :: CInt -> CInt -> CDouble +table_OR2_X4_A2_ZN_risingTransition :: Table2D CInt TransitionTime Capacitance TransitionTime +table_OR2_X4_A2_ZN_risingTransition = mkTimingTable 8 6 lookTrAxis_OR2_X4_A2_ZN_risingTransition lookCapAxis_OR2_X4_A2_ZN_risingTransition lookTable_OR2_X4_A2_ZN_risingTransition + +foreign import ccall "timing.h lookTrAxis_OR2_X4_A2_ZN_fallingTransition" lookTrAxis_OR2_X4_A2_ZN_fallingTransition :: CInt -> CDouble +foreign import ccall "timing.h lookCapAxis_OR2_X4_A2_ZN_fallingTransition" lookCapAxis_OR2_X4_A2_ZN_fallingTransition :: CInt -> CDouble +foreign import ccall "timing.h lookTable_OR2_X4_A2_ZN_fallingTransition" lookTable_OR2_X4_A2_ZN_fallingTransition :: CInt -> CInt -> CDouble +table_OR2_X4_A2_ZN_fallingTransition :: Table2D CInt TransitionTime Capacitance TransitionTime +table_OR2_X4_A2_ZN_fallingTransition = mkTimingTable 8 6 lookTrAxis_OR2_X4_A2_ZN_fallingTransition lookCapAxis_OR2_X4_A2_ZN_fallingTransition lookTable_OR2_X4_A2_ZN_fallingTransition + +foreign import ccall "timing.h lookTrAxis_XNOR2_X1_A_ZN_risingDelay" lookTrAxis_XNOR2_X1_A_ZN_risingDelay :: CInt -> CDouble +foreign import ccall "timing.h lookCapAxis_XNOR2_X1_A_ZN_risingDelay" lookCapAxis_XNOR2_X1_A_ZN_risingDelay :: CInt -> CDouble +foreign import ccall "timing.h lookTable_XNOR2_X1_A_ZN_risingDelay" lookTable_XNOR2_X1_A_ZN_risingDelay :: CInt -> CInt -> CDouble +table_XNOR2_X1_A_ZN_risingDelay :: Table2D CInt TransitionTime Capacitance Time +table_XNOR2_X1_A_ZN_risingDelay = mkTimingTable 8 6 lookTrAxis_XNOR2_X1_A_ZN_risingDelay lookCapAxis_XNOR2_X1_A_ZN_risingDelay lookTable_XNOR2_X1_A_ZN_risingDelay + +foreign import ccall "timing.h lookTrAxis_XNOR2_X1_A_ZN_fallingDelay" lookTrAxis_XNOR2_X1_A_ZN_fallingDelay :: CInt -> CDouble +foreign import ccall "timing.h lookCapAxis_XNOR2_X1_A_ZN_fallingDelay" lookCapAxis_XNOR2_X1_A_ZN_fallingDelay :: CInt -> CDouble +foreign import ccall "timing.h lookTable_XNOR2_X1_A_ZN_fallingDelay" lookTable_XNOR2_X1_A_ZN_fallingDelay :: CInt -> CInt -> CDouble +table_XNOR2_X1_A_ZN_fallingDelay :: Table2D CInt TransitionTime Capacitance Time +table_XNOR2_X1_A_ZN_fallingDelay = mkTimingTable 8 6 lookTrAxis_XNOR2_X1_A_ZN_fallingDelay lookCapAxis_XNOR2_X1_A_ZN_fallingDelay lookTable_XNOR2_X1_A_ZN_fallingDelay + +foreign import ccall "timing.h lookTrAxis_XNOR2_X1_A_ZN_risingTransition" lookTrAxis_XNOR2_X1_A_ZN_risingTransition :: CInt -> CDouble +foreign import ccall "timing.h lookCapAxis_XNOR2_X1_A_ZN_risingTransition" lookCapAxis_XNOR2_X1_A_ZN_risingTransition :: CInt -> CDouble +foreign import ccall "timing.h lookTable_XNOR2_X1_A_ZN_risingTransition" lookTable_XNOR2_X1_A_ZN_risingTransition :: CInt -> CInt -> CDouble +table_XNOR2_X1_A_ZN_risingTransition :: Table2D CInt TransitionTime Capacitance TransitionTime +table_XNOR2_X1_A_ZN_risingTransition = mkTimingTable 8 6 lookTrAxis_XNOR2_X1_A_ZN_risingTransition lookCapAxis_XNOR2_X1_A_ZN_risingTransition lookTable_XNOR2_X1_A_ZN_risingTransition + +foreign import ccall "timing.h lookTrAxis_XNOR2_X1_A_ZN_fallingTransition" lookTrAxis_XNOR2_X1_A_ZN_fallingTransition :: CInt -> CDouble +foreign import ccall "timing.h lookCapAxis_XNOR2_X1_A_ZN_fallingTransition" lookCapAxis_XNOR2_X1_A_ZN_fallingTransition :: CInt -> CDouble +foreign import ccall "timing.h lookTable_XNOR2_X1_A_ZN_fallingTransition" lookTable_XNOR2_X1_A_ZN_fallingTransition :: CInt -> CInt -> CDouble +table_XNOR2_X1_A_ZN_fallingTransition :: Table2D CInt TransitionTime Capacitance TransitionTime +table_XNOR2_X1_A_ZN_fallingTransition = mkTimingTable 8 6 lookTrAxis_XNOR2_X1_A_ZN_fallingTransition lookCapAxis_XNOR2_X1_A_ZN_fallingTransition lookTable_XNOR2_X1_A_ZN_fallingTransition + +foreign import ccall "timing.h lookTrAxis_XNOR2_X1_B_ZN_risingDelay" lookTrAxis_XNOR2_X1_B_ZN_risingDelay :: CInt -> CDouble +foreign import ccall "timing.h lookCapAxis_XNOR2_X1_B_ZN_risingDelay" lookCapAxis_XNOR2_X1_B_ZN_risingDelay :: CInt -> CDouble +foreign import ccall "timing.h lookTable_XNOR2_X1_B_ZN_risingDelay" lookTable_XNOR2_X1_B_ZN_risingDelay :: CInt -> CInt -> CDouble +table_XNOR2_X1_B_ZN_risingDelay :: Table2D CInt TransitionTime Capacitance Time +table_XNOR2_X1_B_ZN_risingDelay = mkTimingTable 8 6 lookTrAxis_XNOR2_X1_B_ZN_risingDelay lookCapAxis_XNOR2_X1_B_ZN_risingDelay lookTable_XNOR2_X1_B_ZN_risingDelay + +foreign import ccall "timing.h lookTrAxis_XNOR2_X1_B_ZN_fallingDelay" lookTrAxis_XNOR2_X1_B_ZN_fallingDelay :: CInt -> CDouble +foreign import ccall "timing.h lookCapAxis_XNOR2_X1_B_ZN_fallingDelay" lookCapAxis_XNOR2_X1_B_ZN_fallingDelay :: CInt -> CDouble +foreign import ccall "timing.h lookTable_XNOR2_X1_B_ZN_fallingDelay" lookTable_XNOR2_X1_B_ZN_fallingDelay :: CInt -> CInt -> CDouble +table_XNOR2_X1_B_ZN_fallingDelay :: Table2D CInt TransitionTime Capacitance Time +table_XNOR2_X1_B_ZN_fallingDelay = mkTimingTable 8 6 lookTrAxis_XNOR2_X1_B_ZN_fallingDelay lookCapAxis_XNOR2_X1_B_ZN_fallingDelay lookTable_XNOR2_X1_B_ZN_fallingDelay + +foreign import ccall "timing.h lookTrAxis_XNOR2_X1_B_ZN_risingTransition" lookTrAxis_XNOR2_X1_B_ZN_risingTransition :: CInt -> CDouble +foreign import ccall "timing.h lookCapAxis_XNOR2_X1_B_ZN_risingTransition" lookCapAxis_XNOR2_X1_B_ZN_risingTransition :: CInt -> CDouble +foreign import ccall "timing.h lookTable_XNOR2_X1_B_ZN_risingTransition" lookTable_XNOR2_X1_B_ZN_risingTransition :: CInt -> CInt -> CDouble +table_XNOR2_X1_B_ZN_risingTransition :: Table2D CInt TransitionTime Capacitance TransitionTime +table_XNOR2_X1_B_ZN_risingTransition = mkTimingTable 8 6 lookTrAxis_XNOR2_X1_B_ZN_risingTransition lookCapAxis_XNOR2_X1_B_ZN_risingTransition lookTable_XNOR2_X1_B_ZN_risingTransition + +foreign import ccall "timing.h lookTrAxis_XNOR2_X1_B_ZN_fallingTransition" lookTrAxis_XNOR2_X1_B_ZN_fallingTransition :: CInt -> CDouble +foreign import ccall "timing.h lookCapAxis_XNOR2_X1_B_ZN_fallingTransition" lookCapAxis_XNOR2_X1_B_ZN_fallingTransition :: CInt -> CDouble +foreign import ccall "timing.h lookTable_XNOR2_X1_B_ZN_fallingTransition" lookTable_XNOR2_X1_B_ZN_fallingTransition :: CInt -> CInt -> CDouble +table_XNOR2_X1_B_ZN_fallingTransition :: Table2D CInt TransitionTime Capacitance TransitionTime +table_XNOR2_X1_B_ZN_fallingTransition = mkTimingTable 8 6 lookTrAxis_XNOR2_X1_B_ZN_fallingTransition lookCapAxis_XNOR2_X1_B_ZN_fallingTransition lookTable_XNOR2_X1_B_ZN_fallingTransition + +foreign import ccall "timing.h lookTrAxis_XNOR2_X2_A_ZN_risingDelay" lookTrAxis_XNOR2_X2_A_ZN_risingDelay :: CInt -> CDouble +foreign import ccall "timing.h lookCapAxis_XNOR2_X2_A_ZN_risingDelay" lookCapAxis_XNOR2_X2_A_ZN_risingDelay :: CInt -> CDouble +foreign import ccall "timing.h lookTable_XNOR2_X2_A_ZN_risingDelay" lookTable_XNOR2_X2_A_ZN_risingDelay :: CInt -> CInt -> CDouble +table_XNOR2_X2_A_ZN_risingDelay :: Table2D CInt TransitionTime Capacitance Time +table_XNOR2_X2_A_ZN_risingDelay = mkTimingTable 8 6 lookTrAxis_XNOR2_X2_A_ZN_risingDelay lookCapAxis_XNOR2_X2_A_ZN_risingDelay lookTable_XNOR2_X2_A_ZN_risingDelay + +foreign import ccall "timing.h lookTrAxis_XNOR2_X2_A_ZN_fallingDelay" lookTrAxis_XNOR2_X2_A_ZN_fallingDelay :: CInt -> CDouble +foreign import ccall "timing.h lookCapAxis_XNOR2_X2_A_ZN_fallingDelay" lookCapAxis_XNOR2_X2_A_ZN_fallingDelay :: CInt -> CDouble +foreign import ccall "timing.h lookTable_XNOR2_X2_A_ZN_fallingDelay" lookTable_XNOR2_X2_A_ZN_fallingDelay :: CInt -> CInt -> CDouble +table_XNOR2_X2_A_ZN_fallingDelay :: Table2D CInt TransitionTime Capacitance Time +table_XNOR2_X2_A_ZN_fallingDelay = mkTimingTable 8 6 lookTrAxis_XNOR2_X2_A_ZN_fallingDelay lookCapAxis_XNOR2_X2_A_ZN_fallingDelay lookTable_XNOR2_X2_A_ZN_fallingDelay + +foreign import ccall "timing.h lookTrAxis_XNOR2_X2_A_ZN_risingTransition" lookTrAxis_XNOR2_X2_A_ZN_risingTransition :: CInt -> CDouble +foreign import ccall "timing.h lookCapAxis_XNOR2_X2_A_ZN_risingTransition" lookCapAxis_XNOR2_X2_A_ZN_risingTransition :: CInt -> CDouble +foreign import ccall "timing.h lookTable_XNOR2_X2_A_ZN_risingTransition" lookTable_XNOR2_X2_A_ZN_risingTransition :: CInt -> CInt -> CDouble +table_XNOR2_X2_A_ZN_risingTransition :: Table2D CInt TransitionTime Capacitance TransitionTime +table_XNOR2_X2_A_ZN_risingTransition = mkTimingTable 8 6 lookTrAxis_XNOR2_X2_A_ZN_risingTransition lookCapAxis_XNOR2_X2_A_ZN_risingTransition lookTable_XNOR2_X2_A_ZN_risingTransition + +foreign import ccall "timing.h lookTrAxis_XNOR2_X2_A_ZN_fallingTransition" lookTrAxis_XNOR2_X2_A_ZN_fallingTransition :: CInt -> CDouble +foreign import ccall "timing.h lookCapAxis_XNOR2_X2_A_ZN_fallingTransition" lookCapAxis_XNOR2_X2_A_ZN_fallingTransition :: CInt -> CDouble +foreign import ccall "timing.h lookTable_XNOR2_X2_A_ZN_fallingTransition" lookTable_XNOR2_X2_A_ZN_fallingTransition :: CInt -> CInt -> CDouble +table_XNOR2_X2_A_ZN_fallingTransition :: Table2D CInt TransitionTime Capacitance TransitionTime +table_XNOR2_X2_A_ZN_fallingTransition = mkTimingTable 8 6 lookTrAxis_XNOR2_X2_A_ZN_fallingTransition lookCapAxis_XNOR2_X2_A_ZN_fallingTransition lookTable_XNOR2_X2_A_ZN_fallingTransition + +foreign import ccall "timing.h lookTrAxis_XNOR2_X2_B_ZN_risingDelay" lookTrAxis_XNOR2_X2_B_ZN_risingDelay :: CInt -> CDouble +foreign import ccall "timing.h lookCapAxis_XNOR2_X2_B_ZN_risingDelay" lookCapAxis_XNOR2_X2_B_ZN_risingDelay :: CInt -> CDouble +foreign import ccall "timing.h lookTable_XNOR2_X2_B_ZN_risingDelay" lookTable_XNOR2_X2_B_ZN_risingDelay :: CInt -> CInt -> CDouble +table_XNOR2_X2_B_ZN_risingDelay :: Table2D CInt TransitionTime Capacitance Time +table_XNOR2_X2_B_ZN_risingDelay = mkTimingTable 8 6 lookTrAxis_XNOR2_X2_B_ZN_risingDelay lookCapAxis_XNOR2_X2_B_ZN_risingDelay lookTable_XNOR2_X2_B_ZN_risingDelay + +foreign import ccall "timing.h lookTrAxis_XNOR2_X2_B_ZN_fallingDelay" lookTrAxis_XNOR2_X2_B_ZN_fallingDelay :: CInt -> CDouble +foreign import ccall "timing.h lookCapAxis_XNOR2_X2_B_ZN_fallingDelay" lookCapAxis_XNOR2_X2_B_ZN_fallingDelay :: CInt -> CDouble +foreign import ccall "timing.h lookTable_XNOR2_X2_B_ZN_fallingDelay" lookTable_XNOR2_X2_B_ZN_fallingDelay :: CInt -> CInt -> CDouble +table_XNOR2_X2_B_ZN_fallingDelay :: Table2D CInt TransitionTime Capacitance Time +table_XNOR2_X2_B_ZN_fallingDelay = mkTimingTable 8 6 lookTrAxis_XNOR2_X2_B_ZN_fallingDelay lookCapAxis_XNOR2_X2_B_ZN_fallingDelay lookTable_XNOR2_X2_B_ZN_fallingDelay + +foreign import ccall "timing.h lookTrAxis_XNOR2_X2_B_ZN_risingTransition" lookTrAxis_XNOR2_X2_B_ZN_risingTransition :: CInt -> CDouble +foreign import ccall "timing.h lookCapAxis_XNOR2_X2_B_ZN_risingTransition" lookCapAxis_XNOR2_X2_B_ZN_risingTransition :: CInt -> CDouble +foreign import ccall "timing.h lookTable_XNOR2_X2_B_ZN_risingTransition" lookTable_XNOR2_X2_B_ZN_risingTransition :: CInt -> CInt -> CDouble +table_XNOR2_X2_B_ZN_risingTransition :: Table2D CInt TransitionTime Capacitance TransitionTime +table_XNOR2_X2_B_ZN_risingTransition = mkTimingTable 8 6 lookTrAxis_XNOR2_X2_B_ZN_risingTransition lookCapAxis_XNOR2_X2_B_ZN_risingTransition lookTable_XNOR2_X2_B_ZN_risingTransition + +foreign import ccall "timing.h lookTrAxis_XNOR2_X2_B_ZN_fallingTransition" lookTrAxis_XNOR2_X2_B_ZN_fallingTransition :: CInt -> CDouble +foreign import ccall "timing.h lookCapAxis_XNOR2_X2_B_ZN_fallingTransition" lookCapAxis_XNOR2_X2_B_ZN_fallingTransition :: CInt -> CDouble +foreign import ccall "timing.h lookTable_XNOR2_X2_B_ZN_fallingTransition" lookTable_XNOR2_X2_B_ZN_fallingTransition :: CInt -> CInt -> CDouble +table_XNOR2_X2_B_ZN_fallingTransition :: Table2D CInt TransitionTime Capacitance TransitionTime +table_XNOR2_X2_B_ZN_fallingTransition = mkTimingTable 8 6 lookTrAxis_XNOR2_X2_B_ZN_fallingTransition lookCapAxis_XNOR2_X2_B_ZN_fallingTransition lookTable_XNOR2_X2_B_ZN_fallingTransition + +foreign import ccall "timing.h lookTrAxis_XOR2_X1_A_Z_risingDelay" lookTrAxis_XOR2_X1_A_Z_risingDelay :: CInt -> CDouble +foreign import ccall "timing.h lookCapAxis_XOR2_X1_A_Z_risingDelay" lookCapAxis_XOR2_X1_A_Z_risingDelay :: CInt -> CDouble +foreign import ccall "timing.h lookTable_XOR2_X1_A_Z_risingDelay" lookTable_XOR2_X1_A_Z_risingDelay :: CInt -> CInt -> CDouble +table_XOR2_X1_A_Z_risingDelay :: Table2D CInt TransitionTime Capacitance Time +table_XOR2_X1_A_Z_risingDelay = mkTimingTable 8 6 lookTrAxis_XOR2_X1_A_Z_risingDelay lookCapAxis_XOR2_X1_A_Z_risingDelay lookTable_XOR2_X1_A_Z_risingDelay + +foreign import ccall "timing.h lookTrAxis_XOR2_X1_A_Z_fallingDelay" lookTrAxis_XOR2_X1_A_Z_fallingDelay :: CInt -> CDouble +foreign import ccall "timing.h lookCapAxis_XOR2_X1_A_Z_fallingDelay" lookCapAxis_XOR2_X1_A_Z_fallingDelay :: CInt -> CDouble +foreign import ccall "timing.h lookTable_XOR2_X1_A_Z_fallingDelay" lookTable_XOR2_X1_A_Z_fallingDelay :: CInt -> CInt -> CDouble +table_XOR2_X1_A_Z_fallingDelay :: Table2D CInt TransitionTime Capacitance Time +table_XOR2_X1_A_Z_fallingDelay = mkTimingTable 8 6 lookTrAxis_XOR2_X1_A_Z_fallingDelay lookCapAxis_XOR2_X1_A_Z_fallingDelay lookTable_XOR2_X1_A_Z_fallingDelay + +foreign import ccall "timing.h lookTrAxis_XOR2_X1_A_Z_risingTransition" lookTrAxis_XOR2_X1_A_Z_risingTransition :: CInt -> CDouble +foreign import ccall "timing.h lookCapAxis_XOR2_X1_A_Z_risingTransition" lookCapAxis_XOR2_X1_A_Z_risingTransition :: CInt -> CDouble +foreign import ccall "timing.h lookTable_XOR2_X1_A_Z_risingTransition" lookTable_XOR2_X1_A_Z_risingTransition :: CInt -> CInt -> CDouble +table_XOR2_X1_A_Z_risingTransition :: Table2D CInt TransitionTime Capacitance TransitionTime +table_XOR2_X1_A_Z_risingTransition = mkTimingTable 8 6 lookTrAxis_XOR2_X1_A_Z_risingTransition lookCapAxis_XOR2_X1_A_Z_risingTransition lookTable_XOR2_X1_A_Z_risingTransition + +foreign import ccall "timing.h lookTrAxis_XOR2_X1_A_Z_fallingTransition" lookTrAxis_XOR2_X1_A_Z_fallingTransition :: CInt -> CDouble +foreign import ccall "timing.h lookCapAxis_XOR2_X1_A_Z_fallingTransition" lookCapAxis_XOR2_X1_A_Z_fallingTransition :: CInt -> CDouble +foreign import ccall "timing.h lookTable_XOR2_X1_A_Z_fallingTransition" lookTable_XOR2_X1_A_Z_fallingTransition :: CInt -> CInt -> CDouble +table_XOR2_X1_A_Z_fallingTransition :: Table2D CInt TransitionTime Capacitance TransitionTime +table_XOR2_X1_A_Z_fallingTransition = mkTimingTable 8 6 lookTrAxis_XOR2_X1_A_Z_fallingTransition lookCapAxis_XOR2_X1_A_Z_fallingTransition lookTable_XOR2_X1_A_Z_fallingTransition + +foreign import ccall "timing.h lookTrAxis_XOR2_X1_B_Z_risingDelay" lookTrAxis_XOR2_X1_B_Z_risingDelay :: CInt -> CDouble +foreign import ccall "timing.h lookCapAxis_XOR2_X1_B_Z_risingDelay" lookCapAxis_XOR2_X1_B_Z_risingDelay :: CInt -> CDouble +foreign import ccall "timing.h lookTable_XOR2_X1_B_Z_risingDelay" lookTable_XOR2_X1_B_Z_risingDelay :: CInt -> CInt -> CDouble +table_XOR2_X1_B_Z_risingDelay :: Table2D CInt TransitionTime Capacitance Time +table_XOR2_X1_B_Z_risingDelay = mkTimingTable 8 6 lookTrAxis_XOR2_X1_B_Z_risingDelay lookCapAxis_XOR2_X1_B_Z_risingDelay lookTable_XOR2_X1_B_Z_risingDelay + +foreign import ccall "timing.h lookTrAxis_XOR2_X1_B_Z_fallingDelay" lookTrAxis_XOR2_X1_B_Z_fallingDelay :: CInt -> CDouble +foreign import ccall "timing.h lookCapAxis_XOR2_X1_B_Z_fallingDelay" lookCapAxis_XOR2_X1_B_Z_fallingDelay :: CInt -> CDouble +foreign import ccall "timing.h lookTable_XOR2_X1_B_Z_fallingDelay" lookTable_XOR2_X1_B_Z_fallingDelay :: CInt -> CInt -> CDouble +table_XOR2_X1_B_Z_fallingDelay :: Table2D CInt TransitionTime Capacitance Time +table_XOR2_X1_B_Z_fallingDelay = mkTimingTable 8 6 lookTrAxis_XOR2_X1_B_Z_fallingDelay lookCapAxis_XOR2_X1_B_Z_fallingDelay lookTable_XOR2_X1_B_Z_fallingDelay + +foreign import ccall "timing.h lookTrAxis_XOR2_X1_B_Z_risingTransition" lookTrAxis_XOR2_X1_B_Z_risingTransition :: CInt -> CDouble +foreign import ccall "timing.h lookCapAxis_XOR2_X1_B_Z_risingTransition" lookCapAxis_XOR2_X1_B_Z_risingTransition :: CInt -> CDouble +foreign import ccall "timing.h lookTable_XOR2_X1_B_Z_risingTransition" lookTable_XOR2_X1_B_Z_risingTransition :: CInt -> CInt -> CDouble +table_XOR2_X1_B_Z_risingTransition :: Table2D CInt TransitionTime Capacitance TransitionTime +table_XOR2_X1_B_Z_risingTransition = mkTimingTable 8 6 lookTrAxis_XOR2_X1_B_Z_risingTransition lookCapAxis_XOR2_X1_B_Z_risingTransition lookTable_XOR2_X1_B_Z_risingTransition + +foreign import ccall "timing.h lookTrAxis_XOR2_X1_B_Z_fallingTransition" lookTrAxis_XOR2_X1_B_Z_fallingTransition :: CInt -> CDouble +foreign import ccall "timing.h lookCapAxis_XOR2_X1_B_Z_fallingTransition" lookCapAxis_XOR2_X1_B_Z_fallingTransition :: CInt -> CDouble +foreign import ccall "timing.h lookTable_XOR2_X1_B_Z_fallingTransition" lookTable_XOR2_X1_B_Z_fallingTransition :: CInt -> CInt -> CDouble +table_XOR2_X1_B_Z_fallingTransition :: Table2D CInt TransitionTime Capacitance TransitionTime +table_XOR2_X1_B_Z_fallingTransition = mkTimingTable 8 6 lookTrAxis_XOR2_X1_B_Z_fallingTransition lookCapAxis_XOR2_X1_B_Z_fallingTransition lookTable_XOR2_X1_B_Z_fallingTransition + +foreign import ccall "timing.h lookTrAxis_XOR2_X2_A_Z_risingDelay" lookTrAxis_XOR2_X2_A_Z_risingDelay :: CInt -> CDouble +foreign import ccall "timing.h lookCapAxis_XOR2_X2_A_Z_risingDelay" lookCapAxis_XOR2_X2_A_Z_risingDelay :: CInt -> CDouble +foreign import ccall "timing.h lookTable_XOR2_X2_A_Z_risingDelay" lookTable_XOR2_X2_A_Z_risingDelay :: CInt -> CInt -> CDouble +table_XOR2_X2_A_Z_risingDelay :: Table2D CInt TransitionTime Capacitance Time +table_XOR2_X2_A_Z_risingDelay = mkTimingTable 8 6 lookTrAxis_XOR2_X2_A_Z_risingDelay lookCapAxis_XOR2_X2_A_Z_risingDelay lookTable_XOR2_X2_A_Z_risingDelay + +foreign import ccall "timing.h lookTrAxis_XOR2_X2_A_Z_fallingDelay" lookTrAxis_XOR2_X2_A_Z_fallingDelay :: CInt -> CDouble +foreign import ccall "timing.h lookCapAxis_XOR2_X2_A_Z_fallingDelay" lookCapAxis_XOR2_X2_A_Z_fallingDelay :: CInt -> CDouble +foreign import ccall "timing.h lookTable_XOR2_X2_A_Z_fallingDelay" lookTable_XOR2_X2_A_Z_fallingDelay :: CInt -> CInt -> CDouble +table_XOR2_X2_A_Z_fallingDelay :: Table2D CInt TransitionTime Capacitance Time +table_XOR2_X2_A_Z_fallingDelay = mkTimingTable 8 6 lookTrAxis_XOR2_X2_A_Z_fallingDelay lookCapAxis_XOR2_X2_A_Z_fallingDelay lookTable_XOR2_X2_A_Z_fallingDelay + +foreign import ccall "timing.h lookTrAxis_XOR2_X2_A_Z_risingTransition" lookTrAxis_XOR2_X2_A_Z_risingTransition :: CInt -> CDouble +foreign import ccall "timing.h lookCapAxis_XOR2_X2_A_Z_risingTransition" lookCapAxis_XOR2_X2_A_Z_risingTransition :: CInt -> CDouble +foreign import ccall "timing.h lookTable_XOR2_X2_A_Z_risingTransition" lookTable_XOR2_X2_A_Z_risingTransition :: CInt -> CInt -> CDouble +table_XOR2_X2_A_Z_risingTransition :: Table2D CInt TransitionTime Capacitance TransitionTime +table_XOR2_X2_A_Z_risingTransition = mkTimingTable 8 6 lookTrAxis_XOR2_X2_A_Z_risingTransition lookCapAxis_XOR2_X2_A_Z_risingTransition lookTable_XOR2_X2_A_Z_risingTransition + +foreign import ccall "timing.h lookTrAxis_XOR2_X2_A_Z_fallingTransition" lookTrAxis_XOR2_X2_A_Z_fallingTransition :: CInt -> CDouble +foreign import ccall "timing.h lookCapAxis_XOR2_X2_A_Z_fallingTransition" lookCapAxis_XOR2_X2_A_Z_fallingTransition :: CInt -> CDouble +foreign import ccall "timing.h lookTable_XOR2_X2_A_Z_fallingTransition" lookTable_XOR2_X2_A_Z_fallingTransition :: CInt -> CInt -> CDouble +table_XOR2_X2_A_Z_fallingTransition :: Table2D CInt TransitionTime Capacitance TransitionTime +table_XOR2_X2_A_Z_fallingTransition = mkTimingTable 8 6 lookTrAxis_XOR2_X2_A_Z_fallingTransition lookCapAxis_XOR2_X2_A_Z_fallingTransition lookTable_XOR2_X2_A_Z_fallingTransition + +foreign import ccall "timing.h lookTrAxis_XOR2_X2_B_Z_risingDelay" lookTrAxis_XOR2_X2_B_Z_risingDelay :: CInt -> CDouble +foreign import ccall "timing.h lookCapAxis_XOR2_X2_B_Z_risingDelay" lookCapAxis_XOR2_X2_B_Z_risingDelay :: CInt -> CDouble +foreign import ccall "timing.h lookTable_XOR2_X2_B_Z_risingDelay" lookTable_XOR2_X2_B_Z_risingDelay :: CInt -> CInt -> CDouble +table_XOR2_X2_B_Z_risingDelay :: Table2D CInt TransitionTime Capacitance Time +table_XOR2_X2_B_Z_risingDelay = mkTimingTable 8 6 lookTrAxis_XOR2_X2_B_Z_risingDelay lookCapAxis_XOR2_X2_B_Z_risingDelay lookTable_XOR2_X2_B_Z_risingDelay + +foreign import ccall "timing.h lookTrAxis_XOR2_X2_B_Z_fallingDelay" lookTrAxis_XOR2_X2_B_Z_fallingDelay :: CInt -> CDouble +foreign import ccall "timing.h lookCapAxis_XOR2_X2_B_Z_fallingDelay" lookCapAxis_XOR2_X2_B_Z_fallingDelay :: CInt -> CDouble +foreign import ccall "timing.h lookTable_XOR2_X2_B_Z_fallingDelay" lookTable_XOR2_X2_B_Z_fallingDelay :: CInt -> CInt -> CDouble +table_XOR2_X2_B_Z_fallingDelay :: Table2D CInt TransitionTime Capacitance Time +table_XOR2_X2_B_Z_fallingDelay = mkTimingTable 8 6 lookTrAxis_XOR2_X2_B_Z_fallingDelay lookCapAxis_XOR2_X2_B_Z_fallingDelay lookTable_XOR2_X2_B_Z_fallingDelay + +foreign import ccall "timing.h lookTrAxis_XOR2_X2_B_Z_risingTransition" lookTrAxis_XOR2_X2_B_Z_risingTransition :: CInt -> CDouble +foreign import ccall "timing.h lookCapAxis_XOR2_X2_B_Z_risingTransition" lookCapAxis_XOR2_X2_B_Z_risingTransition :: CInt -> CDouble +foreign import ccall "timing.h lookTable_XOR2_X2_B_Z_risingTransition" lookTable_XOR2_X2_B_Z_risingTransition :: CInt -> CInt -> CDouble +table_XOR2_X2_B_Z_risingTransition :: Table2D CInt TransitionTime Capacitance TransitionTime +table_XOR2_X2_B_Z_risingTransition = mkTimingTable 8 6 lookTrAxis_XOR2_X2_B_Z_risingTransition lookCapAxis_XOR2_X2_B_Z_risingTransition lookTable_XOR2_X2_B_Z_risingTransition + +foreign import ccall "timing.h lookTrAxis_XOR2_X2_B_Z_fallingTransition" lookTrAxis_XOR2_X2_B_Z_fallingTransition :: CInt -> CDouble +foreign import ccall "timing.h lookCapAxis_XOR2_X2_B_Z_fallingTransition" lookCapAxis_XOR2_X2_B_Z_fallingTransition :: CInt -> CDouble +foreign import ccall "timing.h lookTable_XOR2_X2_B_Z_fallingTransition" lookTable_XOR2_X2_B_Z_fallingTransition :: CInt -> CInt -> CDouble +table_XOR2_X2_B_Z_fallingTransition :: Table2D CInt TransitionTime Capacitance TransitionTime +table_XOR2_X2_B_Z_fallingTransition = mkTimingTable 8 6 lookTrAxis_XOR2_X2_B_Z_fallingTransition lookCapAxis_XOR2_X2_B_Z_fallingTransition lookTable_XOR2_X2_B_Z_fallingTransition + diff --git a/Libs/Nangate45/Wired.hs b/Libs/Nangate45/Wired.hs new file mode 100644 --- /dev/null +++ b/Libs/Nangate45/Wired.hs @@ -0,0 +1,583 @@ +{-# OPTIONS_GHC -fno-warn-missing-fields #-} + +-- | +-- Copyright : Copyright (c) 2008, Emil Axelsson +-- License : BSD3 +-- Maintainer : Emil Axelsson +-- Stability : experimental +-- +-- Wired interface to the Nangate45 library. +-- +-- The data in this file is derived from Nangate's Open Cell Library, +-- and is subject to the license restrictions stated in +-- "Libs.Nangate45.LICENSE". +module Libs.Nangate45.Wired + ( + -- * Library type + Nangate45 + + -- * Cells + , and2_x1 + , and2_x2 + , and2_x4 + , buf_x1 + , buf_x16 + , buf_x2 + , buf_x32 + , buf_x4 + , buf_x8 + , fa_x1 + , fillcell_x1 + , fillcell_x16 + , fillcell_x2 + , fillcell_x32 + , fillcell_x4 + , fillcell_x8 + , ha_x1 + , inv_x1 + , inv_x16 + , inv_x2 + , inv_x32 + , inv_x4 + , inv_x8 + , logic0_x1 + , logic1_x1 + , nand2_x1 + , nand2_x2 + , nand2_x4 + , nor2_x1 + , nor2_x2 + , nor2_x4 + , or2_x1 + , or2_x2 + , or2_x4 + , xnor2_x1 + , xnor2_x2 + , xor2_x1 + , xor2_x2 + ) where + +import Data.Hardware.Internal +import Wired.Model +import Wired +import Analysis.Timing.Library +import qualified Libs.Nangate45.Lava as Lava +import Libs.Nangate45.Lava (Nangate45) + +instance WiredLibrary Nangate45 + where + featureSize = R (Length 450) + + guideLength 1 = R (Length 0) + guideLength 2 = R (Length 0) + guideLength 3 = R (Length 0) + guideLength 4 = R (Length 0) + guideLength 5 = R (Length 0) + guideLength 6 = R (Length 0) + guideLength 7 = R (Length 0) + guideLength 8 = R (Length 0) + guideLength 9 = R (Length 0) + guideLength 10 = R (Length 0) + + rowHeight = R (Length 14000) + +instance WireTimingLibrary Nangate45 + where + layerProps 1 = R $ LayerProps (Length 650) 7.71613e-5 3.86e-11 + layerProps 2 = R $ LayerProps (Length 700) 4.08957e-5 2.04e-11 + layerProps 3 = R $ LayerProps (Length 700) 2.7745e-5 1.39e-11 + layerProps 4 = R $ LayerProps (Length 1400) 2.07429e-5 1.04e-11 + layerProps 5 = R $ LayerProps (Length 1400) 1.3527e-5 6.7599999999999995e-12 + layerProps 6 = R $ LayerProps (Length 1400) 1.00359e-5 5.02e-12 + layerProps 7 = R $ LayerProps (Length 4000) 7.97709e-6 3.99e-12 + layerProps 8 = R $ LayerProps (Length 4000) 5.0391e-6 2.5199999999999998e-12 + layerProps 9 = R $ LayerProps (Length 8000) 3.68273e-6 1.84e-12 + layerProps 10 = R $ LayerProps (Length 8000) 2.21236e-6 1.11e-12 + +-- | Interface: +-- +-- > (A1, A2) -> ZN +-- +-- Function: +-- +-- > ZN = and [A1, A2] +and2_x1 :: (Signal, Signal) -> Wired Nangate45 Signal +and2_x1 (a1, a2) = stacked $ do + zn <- mkCell "AND2_X1" (Length 7600) (Length 14000) $ Lava.and2_x1 (a1, a2) + translate (Length 625) (Length 4225) $ guide 1 (Length 0) a1 + translate (Length 4025) (Length 8425) $ guide 1 (Length 0) a2 + translate (Length 6325) (Length 2775) $ guide 1 (Length 0) zn + return zn + +-- | Interface: +-- +-- > (A1, A2) -> ZN +-- +-- Function: +-- +-- > ZN = and [A1, A2] +and2_x2 :: (Signal, Signal) -> Wired Nangate45 Signal +and2_x2 (a1, a2) = stacked $ do + zn <- mkCell "AND2_X2" (Length 7600) (Length 14000) $ Lava.and2_x2 (a1, a2) + translate (Length 625) (Length 4225) $ guide 1 (Length 0) a1 + translate (Length 4425) (Length 8075) $ guide 1 (Length 0) a2 + translate (Length 6325) (Length 3275) $ guide 1 (Length 0) zn + return zn + +-- | Interface: +-- +-- > (A1, A2) -> ZN +-- +-- Function: +-- +-- > ZN = and [A1, A2] +and2_x4 :: (Signal, Signal) -> Wired Nangate45 Signal +and2_x4 (a1, a2) = stacked $ do + zn <- mkCell "AND2_X4" (Length 7600) (Length 14000) $ Lava.and2_x4 (a1, a2) + translate (Length 625) (Length 7025) $ guide 1 (Length 0) a1 + translate (Length 4250) (Length 7375) $ guide 1 (Length 0) a2 + translate (Length 6250) (Length 8775) $ guide 1 (Length 0) zn + return zn + +-- | Interface: +-- +-- > A -> Z +-- +-- Function: +-- +-- > Z = A +buf_x1 :: Signal -> Wired Nangate45 Signal +buf_x1 a = stacked $ do + z <- mkCell "BUF_X1" (Length 5700) (Length 14000) $ Lava.buf_x1 a + translate (Length 2400) (Length 5975) $ guide 1 (Length 0) a + translate (Length 4200) (Length 7375) $ guide 1 (Length 0) z + return z + +-- | Interface: +-- +-- > A -> Z +-- +-- Function: +-- +-- > Z = A +buf_x16 :: Signal -> Wired Nangate45 Signal +buf_x16 a = stacked $ do + z <- mkCell "BUF_X16" (Length 11400) (Length 14000) $ Lava.buf_x16 a + translate (Length 2650) (Length 7375) $ guide 1 (Length 0) a + translate (Length 5300) (Length 5975) $ guide 1 (Length 0) z + return z + +-- | Interface: +-- +-- > A -> Z +-- +-- Function: +-- +-- > Z = A +buf_x2 :: Signal -> Wired Nangate45 Signal +buf_x2 a = stacked $ do + z <- mkCell "BUF_X2" (Length 5700) (Length 14000) $ Lava.buf_x2 a + translate (Length 2400) (Length 5975) $ guide 1 (Length 0) a + translate (Length 4350) (Length 7375) $ guide 1 (Length 0) z + return z + +-- | Interface: +-- +-- > A -> Z +-- +-- Function: +-- +-- > Z = A +buf_x32 :: Signal -> Wired Nangate45 Signal +buf_x32 a = stacked $ do + z <- mkCell "BUF_X32" (Length 17100) (Length 14000) $ Lava.buf_x32 a + translate (Length 2500) (Length 7375) $ guide 1 (Length 0) a + translate (Length 12200) (Length 4100) $ guide 1 (Length 0) z + return z + +-- | Interface: +-- +-- > A -> Z +-- +-- Function: +-- +-- > Z = A +buf_x4 :: Signal -> Wired Nangate45 Signal +buf_x4 a = stacked $ do + z <- mkCell "BUF_X4" (Length 5700) (Length 14000) $ Lava.buf_x4 a + translate (Length 2400) (Length 7375) $ guide 1 (Length 0) a + translate (Length 4350) (Length 8775) $ guide 1 (Length 0) z + return z + +-- | Interface: +-- +-- > A -> Z +-- +-- Function: +-- +-- > Z = A +buf_x8 :: Signal -> Wired Nangate45 Signal +buf_x8 a = stacked $ do + z <- mkCell "BUF_X8" (Length 7600) (Length 14000) $ Lava.buf_x8 a + translate (Length 2475) (Length 8425) $ guide 1 (Length 0) a + translate (Length 4425) (Length 2250) $ guide 1 (Length 0) z + return z + +-- | Interface: +-- +-- > (CI, (A, B)) -> (S, CO) +-- +-- Function: +-- +-- > S = or [and [or [and [A, B'], and [A', B]], CI'], and [(or [and [A, B'], and [A', B]])', CI]] +-- > CO = or [and [A, B], and [A, CI], and [B, CI]] +fa_x1 :: (Signal, (Signal, Signal)) -> Wired Nangate45 (Signal, Signal) +fa_x1 (ci, (a, b)) = stacked $ do + (s, co) <- mkCell "FA_X1" (Length 34200) (Length 14000) $ Lava.fa_x1 (ci, (a, b)) + translate (Length 19450) (Length 9325) $ guide 1 (Length 0) ci + translate (Length 6300) (Length 6200) $ guide 1 (Length 0) a + translate (Length 18375) (Length 4225) $ guide 1 (Length 0) b + translate (Length 32850) (Length 2400) $ guide 1 (Length 0) s + translate (Length 700) (Length 5575) $ guide 1 (Length 0) co + return (s, co) + +fillcell_x1 :: a -> Wired Nangate45 a +fillcell_x1 = mkCell "FILLCELL_X1" (Length 1900) (Length 14000) . Lava.fillcell_x1 + +fillcell_x16 :: a -> Wired Nangate45 a +fillcell_x16 = mkCell "FILLCELL_X16" (Length 30400) (Length 14000) . Lava.fillcell_x16 + +fillcell_x2 :: a -> Wired Nangate45 a +fillcell_x2 = mkCell "FILLCELL_X2" (Length 3800) (Length 14000) . Lava.fillcell_x2 + +fillcell_x32 :: a -> Wired Nangate45 a +fillcell_x32 = mkCell "FILLCELL_X32" (Length 60800) (Length 14000) . Lava.fillcell_x32 + +fillcell_x4 :: a -> Wired Nangate45 a +fillcell_x4 = mkCell "FILLCELL_X4" (Length 7600) (Length 14000) . Lava.fillcell_x4 + +fillcell_x8 :: a -> Wired Nangate45 a +fillcell_x8 = mkCell "FILLCELL_X8" (Length 15200) (Length 14000) . Lava.fillcell_x8 + +-- | Interface: +-- +-- > (A, B) -> (S, CO) +-- +-- Function: +-- +-- > S = or [and [A, B'], and [A', B]] +-- > CO = and [A, B] +ha_x1 :: (Signal, Signal) -> Wired Nangate45 (Signal, Signal) +ha_x1 (a, b) = stacked $ do + (s, co) <- mkCell "HA_X1" (Length 20900) (Length 14000) $ Lava.ha_x1 (a, b) + translate (Length 7175) (Length 4675) $ guide 1 (Length 0) a + translate (Length 2575) (Length 6225) $ guide 1 (Length 0) b + translate (Length 15725) (Length 4925) $ guide 1 (Length 0) s + translate (Length 19925) (Length 6975) $ guide 1 (Length 0) co + return (s, co) + +-- | Interface: +-- +-- > A -> ZN +-- +-- Function: +-- +-- > ZN = A' +inv_x1 :: Signal -> Wired Nangate45 Signal +inv_x1 a = stacked $ do + zn <- mkCell "INV_X1" (Length 3800) (Length 14000) $ Lava.inv_x1 a + translate (Length 625) (Length 7025) $ guide 1 (Length 0) a + translate (Length 2300) (Length 5575) $ guide 1 (Length 0) zn + return zn + +-- | Interface: +-- +-- > A -> ZN +-- +-- Function: +-- +-- > ZN = A' +inv_x16 :: Signal -> Wired Nangate45 Signal +inv_x16 a = stacked $ do + zn <- mkCell "INV_X16" (Length 9500) (Length 14000) $ Lava.inv_x16 a + translate (Length 625) (Length 5925) $ guide 1 (Length 0) a + translate (Length 6100) (Length 6625) $ guide 1 (Length 0) zn + return zn + +-- | Interface: +-- +-- > A -> ZN +-- +-- Function: +-- +-- > ZN = A' +inv_x2 :: Signal -> Wired Nangate45 Signal +inv_x2 a = stacked $ do + zn <- mkCell "INV_X2" (Length 3800) (Length 14000) $ Lava.inv_x2 a + translate (Length 625) (Length 5625) $ guide 1 (Length 0) a + translate (Length 2300) (Length 4175) $ guide 1 (Length 0) zn + return zn + +-- | Interface: +-- +-- > A -> ZN +-- +-- Function: +-- +-- > ZN = A' +inv_x32 :: Signal -> Wired Nangate45 Signal +inv_x32 a = stacked $ do + zn <- mkCell "INV_X32" (Length 15200) (Length 14000) $ Lava.inv_x32 a + translate (Length 1275) (Length 5225) $ guide 1 (Length 0) a + translate (Length 9900) (Length 4850) $ guide 1 (Length 0) zn + return zn + +-- | Interface: +-- +-- > A -> ZN +-- +-- Function: +-- +-- > ZN = A' +inv_x4 :: Signal -> Wired Nangate45 Signal +inv_x4 a = stacked $ do + zn <- mkCell "INV_X4" (Length 3800) (Length 14000) $ Lava.inv_x4 a + translate (Length 625) (Length 4225) $ guide 1 (Length 0) a + translate (Length 2300) (Length 8425) $ guide 1 (Length 0) zn + return zn + +-- | Interface: +-- +-- > A -> ZN +-- +-- Function: +-- +-- > ZN = A' +inv_x8 :: Signal -> Wired Nangate45 Signal +inv_x8 a = stacked $ do + zn <- mkCell "INV_X8" (Length 5700) (Length 14000) $ Lava.inv_x8 a + translate (Length 1275) (Length 7375) $ guide 1 (Length 0) a + translate (Length 2950) (Length 8775) $ guide 1 (Length 0) zn + return zn + +-- | Interface: +-- +-- > Z +-- +-- Function: +-- +-- > Z = 0 +logic0_x1 :: Wired Nangate45 Signal +logic0_x1 = stacked $ do + z <- mkCell "LOGIC0_X1" (Length 3800) (Length 14000) Lava.logic0_x1 + translate (Length 625) (Length 2825) $ guide 1 (Length 0) z + return z + +-- | Interface: +-- +-- > Z +-- +-- Function: +-- +-- > Z = 1 +logic1_x1 :: Wired Nangate45 Signal +logic1_x1 = stacked $ do + z <- mkCell "LOGIC1_X1" (Length 3800) (Length 14000) Lava.logic1_x1 + translate (Length 625) (Length 8425) $ guide 1 (Length 0) z + return z + +-- | Interface: +-- +-- > (A1, A2) -> ZN +-- +-- Function: +-- +-- > ZN = (and [A1, A2])' +nand2_x1 :: (Signal, Signal) -> Wired Nangate45 Signal +nand2_x1 (a1, a2) = stacked $ do + zn <- mkCell "NAND2_X1" (Length 5700) (Length 14000) $ Lava.nand2_x1 (a1, a2) + translate (Length 2525) (Length 4225) $ guide 1 (Length 0) a1 + translate (Length 625) (Length 7025) $ guide 1 (Length 0) a2 + translate (Length 4200) (Length 7025) $ guide 1 (Length 0) zn + return zn + +-- | Interface: +-- +-- > (A1, A2) -> ZN +-- +-- Function: +-- +-- > ZN = (and [A1, A2])' +nand2_x2 :: (Signal, Signal) -> Wired Nangate45 Signal +nand2_x2 (a1, a2) = stacked $ do + zn <- mkCell "NAND2_X2" (Length 5700) (Length 14000) $ Lava.nand2_x2 (a1, a2) + translate (Length 2525) (Length 4225) $ guide 1 (Length 0) a1 + translate (Length 625) (Length 7025) $ guide 1 (Length 0) a2 + translate (Length 3175) (Length 8375) $ guide 1 (Length 0) zn + return zn + +-- | Interface: +-- +-- > (A1, A2) -> ZN +-- +-- Function: +-- +-- > ZN = (and [A1, A2])' +nand2_x4 :: (Signal, Signal) -> Wired Nangate45 Signal +nand2_x4 (a1, a2) = stacked $ do + zn <- mkCell "NAND2_X4" (Length 9500) (Length 14000) $ Lava.nand2_x4 (a1, a2) + translate (Length 8225) (Length 7125) $ guide 1 (Length 0) a1 + translate (Length 6325) (Length 4175) $ guide 1 (Length 0) a2 + translate (Length 4425) (Length 8425) $ guide 1 (Length 0) zn + return zn + +-- | Interface: +-- +-- > (A1, A2) -> ZN +-- +-- Function: +-- +-- > ZN = (or [A1, A2])' +nor2_x1 :: (Signal, Signal) -> Wired Nangate45 Signal +nor2_x1 (a1, a2) = stacked $ do + zn <- mkCell "NOR2_X1" (Length 5700) (Length 14000) $ Lava.nor2_x1 (a1, a2) + translate (Length 4425) (Length 7025) $ guide 1 (Length 0) a1 + translate (Length 625) (Length 8425) $ guide 1 (Length 0) a2 + translate (Length 3050) (Length 9625) $ guide 1 (Length 0) zn + return zn + +-- | Interface: +-- +-- > (A1, A2) -> ZN +-- +-- Function: +-- +-- > ZN = (or [A1, A2])' +nor2_x2 :: (Signal, Signal) -> Wired Nangate45 Signal +nor2_x2 (a1, a2) = stacked $ do + zn <- mkCell "NOR2_X2" (Length 5700) (Length 14000) $ Lava.nor2_x2 (a1, a2) + translate (Length 4425) (Length 4225) $ guide 1 (Length 0) a1 + translate (Length 625) (Length 4225) $ guide 1 (Length 0) a2 + translate (Length 4200) (Length 8425) $ guide 1 (Length 0) zn + return zn + +-- | Interface: +-- +-- > (A1, A2) -> ZN +-- +-- Function: +-- +-- > ZN = (or [A1, A2])' +nor2_x4 :: (Signal, Signal) -> Wired Nangate45 Signal +nor2_x4 (a1, a2) = stacked $ do + zn <- mkCell "NOR2_X4" (Length 9500) (Length 14000) $ Lava.nor2_x4 (a1, a2) + translate (Length 4425) (Length 5625) $ guide 1 (Length 0) a1 + translate (Length 6325) (Length 8000) $ guide 1 (Length 0) a2 + translate (Length 3775) (Length 7625) $ guide 1 (Length 0) zn + return zn + +-- | Interface: +-- +-- > (A1, A2) -> ZN +-- +-- Function: +-- +-- > ZN = or [A1, A2] +or2_x1 :: (Signal, Signal) -> Wired Nangate45 Signal +or2_x1 (a1, a2) = stacked $ do + zn <- mkCell "OR2_X1" (Length 7600) (Length 14000) $ Lava.or2_x1 (a1, a2) + translate (Length 2800) (Length 8025) $ guide 1 (Length 0) a1 + translate (Length 4200) (Length 9425) $ guide 1 (Length 0) a2 + translate (Length 6500) (Length 6625) $ guide 1 (Length 0) zn + return zn + +-- | Interface: +-- +-- > (A1, A2) -> ZN +-- +-- Function: +-- +-- > ZN = or [A1, A2] +or2_x2 :: (Signal, Signal) -> Wired Nangate45 Signal +or2_x2 (a1, a2) = stacked $ do + zn <- mkCell "OR2_X2" (Length 7600) (Length 14000) $ Lava.or2_x2 (a1, a2) + translate (Length 2475) (Length 5975) $ guide 1 (Length 0) a1 + translate (Length 3375) (Length 8775) $ guide 1 (Length 0) a2 + translate (Length 6325) (Length 2725) $ guide 1 (Length 0) zn + return zn + +-- | Interface: +-- +-- > (A1, A2) -> ZN +-- +-- Function: +-- +-- > ZN = or [A1, A2] +or2_x4 :: (Signal, Signal) -> Wired Nangate45 Signal +or2_x4 (a1, a2) = stacked $ do + zn <- mkCell "OR2_X4" (Length 7600) (Length 14000) $ Lava.or2_x4 (a1, a2) + translate (Length 2475) (Length 11575) $ guide 1 (Length 0) a1 + translate (Length 3875) (Length 8775) $ guide 1 (Length 0) a2 + translate (Length 6325) (Length 2775) $ guide 1 (Length 0) zn + return zn + +-- | Interface: +-- +-- > (A, B) -> ZN +-- +-- Function: +-- +-- > ZN = (or [and [A, B'], and [A', B]])' +xnor2_x1 :: (Signal, Signal) -> Wired Nangate45 Signal +xnor2_x1 (a, b) = stacked $ do + zn <- mkCell "XNOR2_X1" (Length 11400) (Length 14000) $ Lava.xnor2_x1 (a, b) + translate (Length 2175) (Length 4575) $ guide 1 (Length 0) a + translate (Length 5425) (Length 9800) $ guide 1 (Length 0) b + translate (Length 8575) (Length 10450) $ guide 1 (Length 0) zn + return zn + +-- | Interface: +-- +-- > (A, B) -> ZN +-- +-- Function: +-- +-- > ZN = (or [and [A, B'], and [A', B]])' +xnor2_x2 :: (Signal, Signal) -> Wired Nangate45 Signal +xnor2_x2 (a, b) = stacked $ do + zn <- mkCell "XNOR2_X2" (Length 11400) (Length 14000) $ Lava.xnor2_x2 (a, b) + translate (Length 3525) (Length 5725) $ guide 1 (Length 0) a + translate (Length 7875) (Length 8375) $ guide 1 (Length 0) b + translate (Length 8650) (Length 6325) $ guide 1 (Length 0) zn + return zn + +-- | Interface: +-- +-- > (A, B) -> Z +-- +-- Function: +-- +-- > Z = or [and [A, B'], and [A', B]] +xor2_x1 :: (Signal, Signal) -> Wired Nangate45 Signal +xor2_x1 (a, b) = stacked $ do + z <- mkCell "XOR2_X1" (Length 11400) (Length 14000) $ Lava.xor2_x1 (a, b) + translate (Length 1900) (Length 7600) $ guide 1 (Length 0) a + translate (Length 8450) (Length 6625) $ guide 1 (Length 0) b + translate (Length 6575) (Length 3825) $ guide 1 (Length 0) z + return z + +-- | Interface: +-- +-- > (A, B) -> Z +-- +-- Function: +-- +-- > Z = or [and [A, B'], and [A', B]] +xor2_x2 :: (Signal, Signal) -> Wired Nangate45 Signal +xor2_x2 (a, b) = stacked $ do + z <- mkCell "XOR2_X2" (Length 11400) (Length 14000) $ Lava.xor2_x2 (a, b) + translate (Length 5425) (Length 8450) $ guide 1 (Length 0) a + translate (Length 8225) (Length 6500) $ guide 1 (Length 0) b + translate (Length 8750) (Length 8400) $ guide 1 (Length 0) z + return z + diff --git a/Libs/Nangate45/timing.c b/Libs/Nangate45/timing.c new file mode 100644 --- /dev/null +++ b/Libs/Nangate45/timing.c @@ -0,0 +1,1515 @@ +// Copyright : Copyright (c) 2008, Emil Axelsson +// License : BSD3 + +double trAxis_AND2_X1_A1_ZN_risingDelay[8] = {7.5e-12, 1.5e-11, 3.0e-11, 6.0e-11, 1.2e-10, 2.4e-10, 4.8e-10, 9.6e-10}; +double capAxis_AND2_X1_A1_ZN_risingDelay[6] = {4.0e-16, 8.0e-16, 1.6e-15, 3.2e-15, 6.4e-15, 1.28e-14}; +double table_AND2_X1_A1_ZN_risingDelay[6][8] = {{3.620000000000001e-11, 3.93e-11, 4.490000000000001e-11, 5.1400000000000005e-11, 5.750000000000001e-11, 5.910000000000001e-11, 4.7500000000000004e-11, 6.5e-12}, {4.14e-11, 4.45e-11, 5.01e-11, 5.680000000000001e-11, 6.310000000000001e-11, 6.58e-11, 5.5700000000000005e-11, 1.65e-11}, {5.1400000000000005e-11, 5.4500000000000006e-11, 6.0e-11, 6.68e-11, 7.330000000000001e-11, 7.7e-11, 6.980000000000001e-11, 3.3700000000000004e-11}, {7.07e-11, 7.360000000000001e-11, 7.900000000000001e-11, 8.61e-11, 9.260000000000001e-11, 9.690000000000001e-11, 9.210000000000001e-11, 6.230000000000001e-11}, {1.0840000000000001e-10, 1.113e-10, 1.166e-10, 1.2360000000000002e-10, 1.303e-10, 1.3469999999999998e-10, 1.314e-10, 1.069e-10}, {1.838e-10, 1.867e-10, 1.9210000000000001e-10, 1.989e-10, 2.0560000000000002e-10, 2.0990000000000002e-10, 2.0720000000000002e-10, 1.8540000000000003e-10}}; +double lookTrAxis_AND2_X1_A1_ZN_risingDelay(int iTr) {return trAxis_AND2_X1_A1_ZN_risingDelay[iTr];} +double lookCapAxis_AND2_X1_A1_ZN_risingDelay(int iCap) {return capAxis_AND2_X1_A1_ZN_risingDelay[iCap];} +double lookTable_AND2_X1_A1_ZN_risingDelay(int iTr, int iCap) {return table_AND2_X1_A1_ZN_risingDelay[iCap][iTr];} + +double trAxis_AND2_X1_A1_ZN_fallingDelay[8] = {7.5e-12, 1.5e-11, 3.0e-11, 6.0e-11, 1.2e-10, 2.4e-10, 4.8e-10, 9.6e-10}; +double capAxis_AND2_X1_A1_ZN_fallingDelay[6] = {4.0e-16, 8.0e-16, 1.6e-15, 3.2e-15, 6.4e-15, 1.28e-14}; +double table_AND2_X1_A1_ZN_fallingDelay[6][8] = {{4.14e-11, 4.5100000000000005e-11, 5.32e-11, 6.750000000000001e-11, 8.790000000000001e-11, 1.1820000000000002e-10, 1.658e-10, 2.452e-10}, {4.52e-11, 4.89e-11, 5.6900000000000005e-11, 7.15e-11, 9.24e-11, 1.2350000000000001e-10, 1.7230000000000002e-10, 2.531e-10}, {5.1700000000000006e-11, 5.55e-11, 6.35e-11, 7.840000000000001e-11, 1.001e-10, 1.324e-10, 1.8320000000000002e-10, 2.6640000000000003e-10}, {6.310000000000001e-11, 6.700000000000001e-11, 7.5e-11, 9.0e-11, 1.128e-10, 1.467e-10, 2.0030000000000002e-10, 2.88e-10}, {8.320000000000001e-11, 8.7e-11, 9.510000000000001e-11, 1.104e-10, 1.3430000000000002e-10, 1.699e-10, 2.2710000000000002e-10, 3.213e-10}, {1.214e-10, 1.2509999999999999e-10, 1.3320000000000002e-10, 1.485e-10, 1.7280000000000001e-10, 2.097e-10, 2.7039999999999997e-10, 3.726e-10}}; +double lookTrAxis_AND2_X1_A1_ZN_fallingDelay(int iTr) {return trAxis_AND2_X1_A1_ZN_fallingDelay[iTr];} +double lookCapAxis_AND2_X1_A1_ZN_fallingDelay(int iCap) {return capAxis_AND2_X1_A1_ZN_fallingDelay[iCap];} +double lookTable_AND2_X1_A1_ZN_fallingDelay(int iTr, int iCap) {return table_AND2_X1_A1_ZN_fallingDelay[iCap][iTr];} + +double trAxis_AND2_X1_A1_ZN_risingTransition[8] = {7.5e-12, 1.5e-11, 3.0e-11, 6.0e-11, 1.2e-10, 2.4e-10, 4.8e-10, 9.6e-10}; +double capAxis_AND2_X1_A1_ZN_risingTransition[6] = {4.0e-16, 8.0e-16, 1.6e-15, 3.2e-15, 6.4e-15, 1.28e-14}; +double table_AND2_X1_A1_ZN_risingTransition[6][8] = {{1.2800000000000002e-11, 1.2800000000000002e-11, 1.3e-11, 1.36e-11, 1.5400000000000003e-11, 1.91e-11, 2.5100000000000003e-11, 3.46e-11}, {1.68e-11, 1.68e-11, 1.7000000000000003e-11, 1.7500000000000004e-11, 1.89e-11, 2.26e-11, 2.94e-11, 3.980000000000001e-11}, {2.52e-11, 2.52e-11, 2.5300000000000002e-11, 2.5700000000000002e-11, 2.66e-11, 2.94e-11, 3.65e-11, 4.9000000000000005e-11}, {4.26e-11, 4.26e-11, 4.2700000000000005e-11, 4.29e-11, 4.3400000000000007e-11, 4.5e-11, 5.0200000000000005e-11, 6.390000000000001e-11}, {7.83e-11, 7.83e-11, 7.83e-11, 7.840000000000001e-11, 7.86e-11, 7.93e-11, 8.22e-11, 9.180000000000001e-11}, {1.5e-10, 1.5e-10, 1.5e-10, 1.5e-10, 1.5010000000000003e-10, 1.5040000000000002e-10, 1.522e-10, 1.583e-10}}; +double lookTrAxis_AND2_X1_A1_ZN_risingTransition(int iTr) {return trAxis_AND2_X1_A1_ZN_risingTransition[iTr];} +double lookCapAxis_AND2_X1_A1_ZN_risingTransition(int iCap) {return capAxis_AND2_X1_A1_ZN_risingTransition[iCap];} +double lookTable_AND2_X1_A1_ZN_risingTransition(int iTr, int iCap) {return table_AND2_X1_A1_ZN_risingTransition[iCap][iTr];} + +double trAxis_AND2_X1_A1_ZN_fallingTransition[8] = {7.5e-12, 1.5e-11, 3.0e-11, 6.0e-11, 1.2e-10, 2.4e-10, 4.8e-10, 9.6e-10}; +double capAxis_AND2_X1_A1_ZN_fallingTransition[6] = {4.0e-16, 8.0e-16, 1.6e-15, 3.2e-15, 6.4e-15, 1.28e-14}; +double table_AND2_X1_A1_ZN_fallingTransition[6][8] = {{9.3e-12, 9.3e-12, 9.400000000000001e-12, 1.0500000000000001e-11, 1.29e-11, 1.6299999999999998e-11, 2.2100000000000003e-11, 3.19e-11}, {1.13e-11, 1.13e-11, 1.14e-11, 1.24e-11, 1.4800000000000003e-11, 1.85e-11, 2.4500000000000003e-11, 3.4900000000000004e-11}, {1.52e-11, 1.52e-11, 1.52e-11, 1.6000000000000003e-11, 1.85e-11, 2.2300000000000003e-11, 2.88e-11, 4.0000000000000004e-11}, {2.2700000000000003e-11, 2.2700000000000003e-11, 2.28e-11, 2.3300000000000003e-11, 2.5600000000000004e-11, 2.93e-11, 3.63e-11, 4.8700000000000004e-11}, {3.7600000000000005e-11, 3.77e-11, 3.77e-11, 3.8000000000000004e-11, 3.9500000000000006e-11, 4.2800000000000003e-11, 4.96e-11, 6.34e-11}, {6.92e-11, 6.92e-11, 6.92e-11, 6.930000000000001e-11, 6.980000000000001e-11, 7.140000000000001e-11, 7.660000000000001e-11, 8.980000000000002e-11}}; +double lookTrAxis_AND2_X1_A1_ZN_fallingTransition(int iTr) {return trAxis_AND2_X1_A1_ZN_fallingTransition[iTr];} +double lookCapAxis_AND2_X1_A1_ZN_fallingTransition(int iCap) {return capAxis_AND2_X1_A1_ZN_fallingTransition[iCap];} +double lookTable_AND2_X1_A1_ZN_fallingTransition(int iTr, int iCap) {return table_AND2_X1_A1_ZN_fallingTransition[iCap][iTr];} + +double trAxis_AND2_X1_A2_ZN_risingDelay[8] = {7.5e-12, 1.5e-11, 3.0e-11, 6.0e-11, 1.2e-10, 2.4e-10, 4.8e-10, 9.6e-10}; +double capAxis_AND2_X1_A2_ZN_risingDelay[6] = {4.0e-16, 8.0e-16, 1.6e-15, 3.2e-15, 6.4e-15, 1.28e-14}; +double table_AND2_X1_A2_ZN_risingDelay[6][8] = {{4.3100000000000005e-11, 4.5900000000000004e-11, 5.0500000000000007e-11, 5.7000000000000003e-11, 6.35e-11, 6.55e-11, 5.43e-11, 1.21e-11}, {4.84e-11, 5.11e-11, 5.5700000000000005e-11, 6.24e-11, 6.92e-11, 7.21e-11, 6.230000000000001e-11, 2.1700000000000003e-11}, {5.83e-11, 6.11e-11, 6.560000000000001e-11, 7.240000000000002e-11, 7.950000000000001e-11, 8.34e-11, 7.600000000000001e-11, 3.8800000000000004e-11}, {7.760000000000001e-11, 8.04e-11, 8.47e-11, 9.17e-11, 9.900000000000001e-11, 1.035e-10, 9.850000000000001e-11, 6.62e-11}, {1.152e-10, 1.1820000000000002e-10, 1.224e-10, 1.293e-10, 1.368e-10, 1.416e-10, 1.3800000000000001e-10, 1.105e-10}, {1.9070000000000002e-10, 1.936e-10, 1.977e-10, 2.0460000000000002e-10, 2.1210000000000002e-10, 2.1680000000000002e-10, 2.1420000000000002e-10, 1.8950000000000002e-10}}; +double lookTrAxis_AND2_X1_A2_ZN_risingDelay(int iTr) {return trAxis_AND2_X1_A2_ZN_risingDelay[iTr];} +double lookCapAxis_AND2_X1_A2_ZN_risingDelay(int iCap) {return capAxis_AND2_X1_A2_ZN_risingDelay[iCap];} +double lookTable_AND2_X1_A2_ZN_risingDelay(int iTr, int iCap) {return table_AND2_X1_A2_ZN_risingDelay[iCap][iTr];} + +double trAxis_AND2_X1_A2_ZN_fallingDelay[8] = {7.5e-12, 1.5e-11, 3.0e-11, 6.0e-11, 1.2e-10, 2.4e-10, 4.8e-10, 9.6e-10}; +double capAxis_AND2_X1_A2_ZN_fallingDelay[6] = {4.0e-16, 8.0e-16, 1.6e-15, 3.2e-15, 6.4e-15, 1.28e-14}; +double table_AND2_X1_A2_ZN_fallingDelay[6][8] = {{5.32e-11, 5.7000000000000003e-11, 6.49e-11, 8.13e-11, 1.07e-10, 1.44e-10, 2.0120000000000001e-10, 2.96e-10}, {5.7200000000000007e-11, 6.1e-11, 6.89e-11, 8.540000000000001e-11, 1.115e-10, 1.492e-10, 2.0720000000000002e-10, 3.0320000000000005e-10}, {6.41e-11, 6.79e-11, 7.59e-11, 9.220000000000002e-11, 1.192e-10, 1.5780000000000001e-10, 2.1730000000000001e-10, 3.1530000000000004e-10}, {7.59e-11, 7.960000000000001e-11, 8.77e-11, 1.04e-10, 1.318e-10, 1.7180000000000002e-10, 2.334e-10, 3.344e-10}, {9.660000000000001e-11, 1.002e-10, 1.0840000000000001e-10, 1.2470000000000002e-10, 1.5320000000000002e-10, 1.9470000000000004e-10, 2.586e-10, 3.6420000000000005e-10}, {1.3519999999999998e-10, 1.3880000000000003e-10, 1.469e-10, 1.6320000000000002e-10, 1.918e-10, 2.343e-10, 3.0030000000000004e-10, 4.1060000000000006e-10}}; +double lookTrAxis_AND2_X1_A2_ZN_fallingDelay(int iTr) {return trAxis_AND2_X1_A2_ZN_fallingDelay[iTr];} +double lookCapAxis_AND2_X1_A2_ZN_fallingDelay(int iCap) {return capAxis_AND2_X1_A2_ZN_fallingDelay[iCap];} +double lookTable_AND2_X1_A2_ZN_fallingDelay(int iTr, int iCap) {return table_AND2_X1_A2_ZN_fallingDelay[iCap][iTr];} + +double trAxis_AND2_X1_A2_ZN_risingTransition[8] = {7.5e-12, 1.5e-11, 3.0e-11, 6.0e-11, 1.2e-10, 2.4e-10, 4.8e-10, 9.6e-10}; +double capAxis_AND2_X1_A2_ZN_risingTransition[6] = {4.0e-16, 8.0e-16, 1.6e-15, 3.2e-15, 6.4e-15, 1.28e-14}; +double table_AND2_X1_A2_ZN_risingTransition[6][8] = {{1.2800000000000002e-11, 1.2800000000000002e-11, 1.29e-11, 1.35e-11, 1.49e-11, 1.8100000000000004e-11, 2.32e-11, 3.05e-11}, {1.68e-11, 1.68e-11, 1.6899999999999998e-11, 1.74e-11, 1.86e-11, 2.1800000000000002e-11, 2.76e-11, 3.5900000000000007e-11}, {2.52e-11, 2.52e-11, 2.52e-11, 2.55e-11, 2.64e-11, 2.9000000000000003e-11, 3.51e-11, 4.52e-11}, {4.26e-11, 4.26e-11, 4.26e-11, 4.2700000000000005e-11, 4.3200000000000003e-11, 4.48e-11, 4.96e-11, 6.06e-11}, {7.83e-11, 7.83e-11, 7.840000000000001e-11, 7.840000000000001e-11, 7.85e-11, 7.91e-11, 8.21e-11, 9.01e-11}, {1.5e-10, 1.5e-10, 1.5e-10, 1.5e-10, 1.5e-10, 1.502e-10, 1.5200000000000002e-10, 1.577e-10}}; +double lookTrAxis_AND2_X1_A2_ZN_risingTransition(int iTr) {return trAxis_AND2_X1_A2_ZN_risingTransition[iTr];} +double lookCapAxis_AND2_X1_A2_ZN_risingTransition(int iCap) {return capAxis_AND2_X1_A2_ZN_risingTransition[iCap];} +double lookTable_AND2_X1_A2_ZN_risingTransition(int iTr, int iCap) {return table_AND2_X1_A2_ZN_risingTransition[iCap][iTr];} + +double trAxis_AND2_X1_A2_ZN_fallingTransition[8] = {7.5e-12, 1.5e-11, 3.0e-11, 6.0e-11, 1.2e-10, 2.4e-10, 4.8e-10, 9.6e-10}; +double capAxis_AND2_X1_A2_ZN_fallingTransition[6] = {4.0e-16, 8.0e-16, 1.6e-15, 3.2e-15, 6.4e-15, 1.28e-14}; +double table_AND2_X1_A2_ZN_fallingTransition[6][8] = {{1.0200000000000001e-11, 1.0200000000000001e-11, 1.0300000000000001e-11, 1.0500000000000001e-11, 1.29e-11, 1.61e-11, 2.0800000000000002e-11, 2.8500000000000002e-11}, {1.2200000000000002e-11, 1.2200000000000002e-11, 1.2200000000000002e-11, 1.2500000000000002e-11, 1.47e-11, 1.8100000000000004e-11, 2.2900000000000003e-11, 3.0900000000000004e-11}, {1.61e-11, 1.61e-11, 1.61e-11, 1.6299999999999998e-11, 1.83e-11, 2.1700000000000003e-11, 2.6800000000000004e-11, 3.500000000000001e-11}, {2.37e-11, 2.37e-11, 2.36e-11, 2.3800000000000004e-11, 2.55e-11, 2.8700000000000002e-11, 3.3700000000000004e-11, 4.26e-11}, {3.84e-11, 3.85e-11, 3.84e-11, 3.85e-11, 3.9500000000000006e-11, 4.23e-11, 4.69e-11, 5.59e-11}, {6.980000000000001e-11, 6.980000000000001e-11, 6.980000000000001e-11, 6.980000000000001e-11, 7.02e-11, 7.15e-11, 7.45e-11, 8.190000000000001e-11}}; +double lookTrAxis_AND2_X1_A2_ZN_fallingTransition(int iTr) {return trAxis_AND2_X1_A2_ZN_fallingTransition[iTr];} +double lookCapAxis_AND2_X1_A2_ZN_fallingTransition(int iCap) {return capAxis_AND2_X1_A2_ZN_fallingTransition[iCap];} +double lookTable_AND2_X1_A2_ZN_fallingTransition(int iTr, int iCap) {return table_AND2_X1_A2_ZN_fallingTransition[iCap][iTr];} + +double trAxis_AND2_X2_A1_ZN_risingDelay[8] = {7.5e-12, 1.5e-11, 3.0e-11, 6.0e-11, 1.2e-10, 2.4e-10, 4.8e-10, 9.6e-10}; +double capAxis_AND2_X2_A1_ZN_risingDelay[6] = {4.0e-16, 1.6e-15, 3.2e-15, 6.4e-15, 1.28e-14, 2.56e-14}; +double table_AND2_X2_A1_ZN_risingDelay[6][8] = {{3.43e-11, 3.740000000000001e-11, 4.33e-11, 5.08e-11, 5.7800000000000003e-11, 6.03e-11, 5.0300000000000003e-11, 1.17e-11}, {4.250000000000001e-11, 4.57e-11, 5.16e-11, 5.93e-11, 6.71e-11, 7.120000000000001e-11, 6.33e-11, 2.7100000000000002e-11}, {5.25e-11, 5.56e-11, 6.14e-11, 6.930000000000001e-11, 7.720000000000002e-11, 8.28e-11, 7.75e-11, 4.4200000000000006e-11}, {7.120000000000001e-11, 7.420000000000001e-11, 7.99e-11, 8.8e-11, 9.610000000000001e-11, 1.022e-10, 1.0000000000000002e-10, 7.27e-11}, {1.0760000000000001e-10, 1.1060000000000001e-10, 1.163e-10, 1.2420000000000002e-10, 1.324e-10, 1.387e-10, 1.3800000000000001e-10, 1.168e-10}, {1.8040000000000002e-10, 1.834e-10, 1.8900000000000002e-10, 1.969e-10, 2.049e-10, 2.11e-10, 2.108e-10, 1.9220000000000002e-10}}; +double lookTrAxis_AND2_X2_A1_ZN_risingDelay(int iTr) {return trAxis_AND2_X2_A1_ZN_risingDelay[iTr];} +double lookCapAxis_AND2_X2_A1_ZN_risingDelay(int iCap) {return capAxis_AND2_X2_A1_ZN_risingDelay[iCap];} +double lookTable_AND2_X2_A1_ZN_risingDelay(int iTr, int iCap) {return table_AND2_X2_A1_ZN_risingDelay[iCap][iTr];} + +double trAxis_AND2_X2_A1_ZN_fallingDelay[8] = {7.5e-12, 1.5e-11, 3.0e-11, 6.0e-11, 1.2e-10, 2.4e-10, 4.8e-10, 9.6e-10}; +double capAxis_AND2_X2_A1_ZN_fallingDelay[6] = {4.0e-16, 1.6e-15, 3.2e-15, 6.4e-15, 1.28e-14, 2.56e-14}; +double table_AND2_X2_A1_ZN_fallingDelay[6][8] = {{4.220000000000001e-11, 4.5900000000000004e-11, 5.390000000000001e-11, 6.900000000000001e-11, 9.06e-11, 1.221e-10, 1.716e-10, 2.535e-10}, {4.850000000000001e-11, 5.2200000000000005e-11, 6.02e-11, 7.56e-11, 9.810000000000002e-11, 1.309e-10, 1.8200000000000002e-10, 2.66e-10}, {5.5400000000000004e-11, 5.910000000000001e-11, 6.72e-11, 8.260000000000002e-11, 1.0600000000000001e-10, 1.401e-10, 1.93e-10, 2.7920000000000003e-10}, {6.700000000000001e-11, 7.07e-11, 7.88e-11, 9.44e-11, 1.1890000000000002e-10, 1.546e-10, 2.103e-10, 3.0070000000000006e-10}, {8.71e-11, 9.070000000000001e-11, 9.880000000000001e-11, 1.146e-10, 1.401e-10, 1.7780000000000002e-10, 2.37e-10, 3.337e-10}, {1.2420000000000002e-10, 1.2790000000000002e-10, 1.3600000000000002e-10, 1.5160000000000002e-10, 1.7770000000000002e-10, 2.167e-10, 2.7950000000000007e-10, 3.841e-10}}; +double lookTrAxis_AND2_X2_A1_ZN_fallingDelay(int iTr) {return trAxis_AND2_X2_A1_ZN_fallingDelay[iTr];} +double lookCapAxis_AND2_X2_A1_ZN_fallingDelay(int iCap) {return capAxis_AND2_X2_A1_ZN_fallingDelay[iCap];} +double lookTable_AND2_X2_A1_ZN_fallingDelay(int iTr, int iCap) {return table_AND2_X2_A1_ZN_fallingDelay[iCap][iTr];} + +double trAxis_AND2_X2_A1_ZN_risingTransition[8] = {7.5e-12, 1.5e-11, 3.0e-11, 6.0e-11, 1.2e-10, 2.4e-10, 4.8e-10, 9.6e-10}; +double capAxis_AND2_X2_A1_ZN_risingTransition[6] = {4.0e-16, 1.6e-15, 3.2e-15, 6.4e-15, 1.28e-14, 2.56e-14}; +double table_AND2_X2_A1_ZN_risingTransition[6][8] = {{1.0000000000000001e-11, 9.900000000000001e-12, 1.0100000000000001e-11, 1.1e-11, 1.3100000000000002e-11, 1.67e-11, 2.24e-11, 3.24e-11}, {1.5800000000000003e-11, 1.5699999999999998e-11, 1.59e-11, 1.65e-11, 1.8200000000000002e-11, 2.22e-11, 2.9000000000000003e-11, 3.980000000000001e-11}, {2.37e-11, 2.37e-11, 2.3800000000000004e-11, 2.43e-11, 2.54e-11, 2.8700000000000002e-11, 3.63e-11, 4.880000000000001e-11}, {4.0300000000000006e-11, 4.0300000000000006e-11, 4.0400000000000004e-11, 4.06e-11, 4.130000000000001e-11, 4.3100000000000005e-11, 4.92e-11, 6.35e-11}, {7.46e-11, 7.45e-11, 7.46e-11, 7.46e-11, 7.49e-11, 7.56e-11, 7.900000000000001e-11, 8.970000000000001e-11}, {1.437e-10, 1.4360000000000003e-10, 1.437e-10, 1.4360000000000003e-10, 1.437e-10, 1.4410000000000002e-10, 1.4580000000000003e-10, 1.5190000000000001e-10}}; +double lookTrAxis_AND2_X2_A1_ZN_risingTransition(int iTr) {return trAxis_AND2_X2_A1_ZN_risingTransition[iTr];} +double lookCapAxis_AND2_X2_A1_ZN_risingTransition(int iCap) {return capAxis_AND2_X2_A1_ZN_risingTransition[iCap];} +double lookTable_AND2_X2_A1_ZN_risingTransition(int iTr, int iCap) {return table_AND2_X2_A1_ZN_risingTransition[iCap][iTr];} + +double trAxis_AND2_X2_A1_ZN_fallingTransition[8] = {7.5e-12, 1.5e-11, 3.0e-11, 6.0e-11, 1.2e-10, 2.4e-10, 4.8e-10, 9.6e-10}; +double capAxis_AND2_X2_A1_ZN_fallingTransition[6] = {4.0e-16, 1.6e-15, 3.2e-15, 6.4e-15, 1.28e-14, 2.56e-14}; +double table_AND2_X2_A1_ZN_fallingTransition[6][8] = {{8.500000000000001e-12, 8.500000000000001e-12, 8.500000000000001e-12, 9.6e-12, 1.23e-11, 1.6000000000000003e-11, 2.2100000000000003e-11, 3.2500000000000004e-11}, {1.16e-11, 1.16e-11, 1.16e-11, 1.2500000000000002e-11, 1.53e-11, 1.9300000000000004e-11, 2.5700000000000002e-11, 3.6800000000000005e-11}, {1.5400000000000003e-11, 1.5400000000000003e-11, 1.5400000000000003e-11, 1.61e-11, 1.8800000000000002e-11, 2.3e-11, 2.99e-11, 4.17e-11}, {2.26e-11, 2.26e-11, 2.26e-11, 2.31e-11, 2.5600000000000004e-11, 2.98e-11, 3.7100000000000006e-11, 5.000000000000001e-11}, {3.6800000000000005e-11, 3.6800000000000005e-11, 3.6800000000000005e-11, 3.7100000000000006e-11, 3.87e-11, 4.2400000000000004e-11, 4.98e-11, 6.400000000000001e-11}, {6.67e-11, 6.68e-11, 6.67e-11, 6.68e-11, 6.740000000000001e-11, 6.96e-11, 7.51e-11, 8.890000000000001e-11}}; +double lookTrAxis_AND2_X2_A1_ZN_fallingTransition(int iTr) {return trAxis_AND2_X2_A1_ZN_fallingTransition[iTr];} +double lookCapAxis_AND2_X2_A1_ZN_fallingTransition(int iCap) {return capAxis_AND2_X2_A1_ZN_fallingTransition[iCap];} +double lookTable_AND2_X2_A1_ZN_fallingTransition(int iTr, int iCap) {return table_AND2_X2_A1_ZN_fallingTransition[iCap][iTr];} + +double trAxis_AND2_X2_A2_ZN_risingDelay[8] = {7.5e-12, 1.5e-11, 3.0e-11, 6.0e-11, 1.2e-10, 2.4e-10, 4.8e-10, 9.6e-10}; +double capAxis_AND2_X2_A2_ZN_risingDelay[6] = {4.0e-16, 1.6e-15, 3.2e-15, 6.4e-15, 1.28e-14, 2.56e-14}; +double table_AND2_X2_A2_ZN_risingDelay[6][8] = {{4.1200000000000004e-11, 4.4e-11, 4.8700000000000004e-11, 5.56e-11, 6.29e-11, 6.59e-11, 5.6200000000000004e-11, 1.6600000000000003e-11}, {4.9500000000000004e-11, 5.2200000000000005e-11, 5.7000000000000003e-11, 6.41e-11, 7.2e-11, 7.650000000000001e-11, 6.880000000000001e-11, 3.1399999999999996e-11}, {5.940000000000001e-11, 6.22e-11, 6.68e-11, 7.420000000000001e-11, 8.240000000000001e-11, 8.790000000000001e-11, 8.260000000000002e-11, 4.8200000000000005e-11}, {7.810000000000001e-11, 8.09e-11, 8.550000000000001e-11, 9.29e-11, 1.0140000000000001e-10, 1.0770000000000001e-10, 1.0480000000000002e-10, 7.54e-11}, {1.146e-10, 1.174e-10, 1.2190000000000001e-10, 1.291e-10, 1.377e-10, 1.445e-10, 1.432e-10, 1.1880000000000002e-10}, {1.8730000000000001e-10, 1.9020000000000003e-10, 1.946e-10, 2.0180000000000002e-10, 2.1040000000000002e-10, 2.17e-10, 2.165e-10, 1.9480000000000001e-10}}; +double lookTrAxis_AND2_X2_A2_ZN_risingDelay(int iTr) {return trAxis_AND2_X2_A2_ZN_risingDelay[iTr];} +double lookCapAxis_AND2_X2_A2_ZN_risingDelay(int iCap) {return capAxis_AND2_X2_A2_ZN_risingDelay[iCap];} +double lookTable_AND2_X2_A2_ZN_risingDelay(int iTr, int iCap) {return table_AND2_X2_A2_ZN_risingDelay[iCap][iTr];} + +double trAxis_AND2_X2_A2_ZN_fallingDelay[8] = {7.5e-12, 1.5e-11, 3.0e-11, 6.0e-11, 1.2e-10, 2.4e-10, 4.8e-10, 9.6e-10}; +double capAxis_AND2_X2_A2_ZN_fallingDelay[6] = {4.0e-16, 1.6e-15, 3.2e-15, 6.4e-15, 1.28e-14, 2.56e-14}; +double table_AND2_X2_A2_ZN_fallingDelay[6][8] = {{5.3800000000000004e-11, 5.750000000000001e-11, 6.55e-11, 8.200000000000001e-11, 1.088e-10, 1.469e-10, 2.052e-10, 3.0230000000000003e-10}, {6.05e-11, 6.43e-11, 7.220000000000001e-11, 8.87e-11, 1.163e-10, 1.556e-10, 2.153e-10, 3.1410000000000003e-10}, {6.77e-11, 7.140000000000001e-11, 7.94e-11, 9.59e-11, 1.2410000000000002e-10, 1.644e-10, 2.2600000000000002e-10, 3.262e-10}, {7.98e-11, 8.350000000000001e-11, 9.150000000000001e-11, 1.079e-10, 1.368e-10, 1.788e-10, 2.423e-10, 3.459e-10}, {1.003e-10, 1.0390000000000001e-10, 1.1200000000000001e-10, 1.284e-10, 1.5800000000000002e-10, 2.016e-10, 2.678e-10, 3.7580000000000004e-10}, {1.378e-10, 1.415e-10, 1.4960000000000003e-10, 1.6600000000000002e-10, 1.9570000000000003e-10, 2.404e-10, 3.09e-10, 4.2180000000000003e-10}}; +double lookTrAxis_AND2_X2_A2_ZN_fallingDelay(int iTr) {return trAxis_AND2_X2_A2_ZN_fallingDelay[iTr];} +double lookCapAxis_AND2_X2_A2_ZN_fallingDelay(int iCap) {return capAxis_AND2_X2_A2_ZN_fallingDelay[iCap];} +double lookTable_AND2_X2_A2_ZN_fallingDelay(int iTr, int iCap) {return table_AND2_X2_A2_ZN_fallingDelay[iCap][iTr];} + +double trAxis_AND2_X2_A2_ZN_risingTransition[8] = {7.5e-12, 1.5e-11, 3.0e-11, 6.0e-11, 1.2e-10, 2.4e-10, 4.8e-10, 9.6e-10}; +double capAxis_AND2_X2_A2_ZN_risingTransition[6] = {4.0e-16, 1.6e-15, 3.2e-15, 6.4e-15, 1.28e-14, 2.56e-14}; +double table_AND2_X2_A2_ZN_risingTransition[6][8] = {{9.900000000000001e-12, 1.0000000000000001e-11, 1.0000000000000001e-11, 1.0600000000000001e-11, 1.21e-11, 1.51e-11, 1.97e-11, 2.6900000000000002e-11}, {1.5800000000000003e-11, 1.5800000000000003e-11, 1.5800000000000003e-11, 1.6299999999999998e-11, 1.77e-11, 2.09e-11, 2.66e-11, 3.4900000000000004e-11}, {2.37e-11, 2.37e-11, 2.37e-11, 2.4100000000000003e-11, 2.5100000000000003e-11, 2.7900000000000002e-11, 3.41e-11, 4.41e-11}, {4.0300000000000006e-11, 4.0300000000000006e-11, 4.0300000000000006e-11, 4.0400000000000004e-11, 4.100000000000001e-11, 4.29e-11, 4.8e-11, 5.93e-11}, {7.46e-11, 7.46e-11, 7.46e-11, 7.46e-11, 7.480000000000002e-11, 7.55e-11, 7.86e-11, 8.720000000000001e-11}, {1.4360000000000003e-10, 1.4360000000000003e-10, 1.4360000000000003e-10, 1.4360000000000003e-10, 1.437e-10, 1.4390000000000001e-10, 1.4560000000000002e-10, 1.513e-10}}; +double lookTrAxis_AND2_X2_A2_ZN_risingTransition(int iTr) {return trAxis_AND2_X2_A2_ZN_risingTransition[iTr];} +double lookCapAxis_AND2_X2_A2_ZN_risingTransition(int iCap) {return capAxis_AND2_X2_A2_ZN_risingTransition[iCap];} +double lookTable_AND2_X2_A2_ZN_risingTransition(int iTr, int iCap) {return table_AND2_X2_A2_ZN_risingTransition[iCap][iTr];} + +double trAxis_AND2_X2_A2_ZN_fallingTransition[8] = {7.5e-12, 1.5e-11, 3.0e-11, 6.0e-11, 1.2e-10, 2.4e-10, 4.8e-10, 9.6e-10}; +double capAxis_AND2_X2_A2_ZN_fallingTransition[6] = {4.0e-16, 1.6e-15, 3.2e-15, 6.4e-15, 1.28e-14, 2.56e-14}; +double table_AND2_X2_A2_ZN_fallingTransition[6][8] = {{9.500000000000001e-12, 9.500000000000001e-12, 9.500000000000001e-12, 9.700000000000001e-12, 1.23e-11, 1.6000000000000003e-11, 2.13e-11, 2.9700000000000005e-11}, {1.2500000000000002e-11, 1.2500000000000002e-11, 1.2500000000000002e-11, 1.27e-11, 1.51e-11, 1.9000000000000002e-11, 2.4500000000000003e-11, 3.3200000000000006e-11}, {1.6299999999999998e-11, 1.6299999999999998e-11, 1.6299999999999998e-11, 1.65e-11, 1.86e-11, 2.25e-11, 2.82e-11, 3.73e-11}, {2.3500000000000003e-11, 2.3500000000000003e-11, 2.36e-11, 2.36e-11, 2.54e-11, 2.92e-11, 3.500000000000001e-11, 4.45e-11}, {3.7600000000000005e-11, 3.7600000000000005e-11, 3.7600000000000005e-11, 3.77e-11, 3.860000000000001e-11, 4.2000000000000004e-11, 4.74e-11, 5.7200000000000007e-11}, {6.740000000000001e-11, 6.740000000000001e-11, 6.740000000000001e-11, 6.740000000000001e-11, 6.77e-11, 6.95e-11, 7.32e-11, 8.160000000000001e-11}}; +double lookTrAxis_AND2_X2_A2_ZN_fallingTransition(int iTr) {return trAxis_AND2_X2_A2_ZN_fallingTransition[iTr];} +double lookCapAxis_AND2_X2_A2_ZN_fallingTransition(int iCap) {return capAxis_AND2_X2_A2_ZN_fallingTransition[iCap];} +double lookTable_AND2_X2_A2_ZN_fallingTransition(int iTr, int iCap) {return table_AND2_X2_A2_ZN_fallingTransition[iCap][iTr];} + +double trAxis_AND2_X4_A1_ZN_risingDelay[8] = {7.5e-12, 1.5e-11, 3.0e-11, 6.0e-11, 1.2e-10, 2.4e-10, 4.8e-10, 9.6e-10}; +double capAxis_AND2_X4_A1_ZN_risingDelay[6] = {4.0e-16, 3.2e-15, 6.4e-15, 1.28e-14, 2.56e-14, 5.12e-14}; +double table_AND2_X4_A1_ZN_risingDelay[6][8] = {{3.6800000000000005e-11, 3.99e-11, 4.62e-11, 5.5400000000000004e-11, 6.44e-11, 6.980000000000001e-11, 6.450000000000001e-11, 3.24e-11}, {4.730000000000001e-11, 5.04e-11, 5.6600000000000004e-11, 6.610000000000001e-11, 7.62e-11, 8.33e-11, 8.000000000000001e-11, 5.000000000000001e-11}, {5.750000000000001e-11, 6.06e-11, 6.68e-11, 7.630000000000001e-11, 8.670000000000001e-11, 9.54e-11, 9.420000000000001e-11, 6.68e-11}, {7.62e-11, 7.920000000000001e-11, 8.540000000000001e-11, 9.500000000000001e-11, 1.056e-10, 1.151e-10, 1.173e-10, 9.520000000000002e-11}, {1.122e-10, 1.152e-10, 1.212e-10, 1.3070000000000002e-10, 1.4120000000000001e-10, 1.508e-10, 1.548e-10, 1.394e-10}, {1.838e-10, 1.8680000000000002e-10, 1.9280000000000002e-10, 2.022e-10, 2.1260000000000002e-10, 2.218e-10, 2.258e-10, 2.1310000000000002e-10}}; +double lookTrAxis_AND2_X4_A1_ZN_risingDelay(int iTr) {return trAxis_AND2_X4_A1_ZN_risingDelay[iTr];} +double lookCapAxis_AND2_X4_A1_ZN_risingDelay(int iCap) {return capAxis_AND2_X4_A1_ZN_risingDelay[iCap];} +double lookTable_AND2_X4_A1_ZN_risingDelay(int iTr, int iCap) {return table_AND2_X4_A1_ZN_risingDelay[iCap][iTr];} + +double trAxis_AND2_X4_A1_ZN_fallingDelay[8] = {7.5e-12, 1.5e-11, 3.0e-11, 6.0e-11, 1.2e-10, 2.4e-10, 4.8e-10, 9.6e-10}; +double capAxis_AND2_X4_A1_ZN_fallingDelay[6] = {4.0e-16, 3.2e-15, 6.4e-15, 1.28e-14, 2.56e-14, 5.12e-14}; +double table_AND2_X4_A1_ZN_fallingDelay[6][8] = {{4.8200000000000005e-11, 5.19e-11, 5.98e-11, 7.600000000000001e-11, 1.0040000000000001e-10, 1.354e-10, 1.8950000000000002e-10, 2.7760000000000005e-10}, {5.6600000000000004e-11, 6.03e-11, 6.82e-11, 8.440000000000001e-11, 1.099e-10, 1.462e-10, 2.0200000000000003e-10, 2.9220000000000004e-10}, {6.41e-11, 6.77e-11, 7.570000000000001e-11, 9.180000000000001e-11, 1.1820000000000002e-10, 1.558e-10, 2.1310000000000002e-10, 3.053e-10}, {7.64e-11, 8.010000000000001e-11, 8.8e-11, 1.0420000000000001e-10, 1.315e-10, 1.7080000000000002e-10, 2.3080000000000002e-10, 3.267e-10}, {9.72e-11, 1.008e-10, 1.088e-10, 1.25e-10, 1.5320000000000002e-10, 1.9450000000000003e-10, 2.579e-10, 3.5970000000000006e-10}, {1.344e-10, 1.3810000000000002e-10, 1.462e-10, 1.6220000000000002e-10, 1.9070000000000002e-10, 2.336e-10, 3.006e-10, 4.1e-10}}; +double lookTrAxis_AND2_X4_A1_ZN_fallingDelay(int iTr) {return trAxis_AND2_X4_A1_ZN_fallingDelay[iTr];} +double lookCapAxis_AND2_X4_A1_ZN_fallingDelay(int iCap) {return capAxis_AND2_X4_A1_ZN_fallingDelay[iCap];} +double lookTable_AND2_X4_A1_ZN_fallingDelay(int iTr, int iCap) {return table_AND2_X4_A1_ZN_fallingDelay[iCap][iTr];} + +double trAxis_AND2_X4_A1_ZN_risingTransition[8] = {7.5e-12, 1.5e-11, 3.0e-11, 6.0e-11, 1.2e-10, 2.4e-10, 4.8e-10, 9.6e-10}; +double capAxis_AND2_X4_A1_ZN_risingTransition[6] = {4.0e-16, 3.2e-15, 6.4e-15, 1.28e-14, 2.56e-14, 5.12e-14}; +double table_AND2_X4_A1_ZN_risingTransition[6][8] = {{9.3e-12, 9.3e-12, 9.3e-12, 1.0400000000000001e-11, 1.27e-11, 1.6600000000000003e-11, 2.3300000000000003e-11, 3.54e-11}, {1.62e-11, 1.62e-11, 1.62e-11, 1.6899999999999998e-11, 1.89e-11, 2.3300000000000003e-11, 3.06e-11, 4.26e-11}, {2.3900000000000003e-11, 2.3900000000000003e-11, 2.3900000000000003e-11, 2.4500000000000003e-11, 2.5900000000000002e-11, 2.9700000000000005e-11, 3.8000000000000004e-11, 5.11e-11}, {3.99e-11, 4.0000000000000004e-11, 4.0000000000000004e-11, 4.02e-11, 4.100000000000001e-11, 4.3400000000000007e-11, 5.0500000000000007e-11, 6.57e-11}, {7.330000000000001e-11, 7.32e-11, 7.32e-11, 7.330000000000001e-11, 7.37e-11, 7.45e-11, 7.820000000000001e-11, 9.06e-11}, {1.411e-10, 1.411e-10, 1.411e-10, 1.411e-10, 1.4120000000000001e-10, 1.415e-10, 1.431e-10, 1.495e-10}}; +double lookTrAxis_AND2_X4_A1_ZN_risingTransition(int iTr) {return trAxis_AND2_X4_A1_ZN_risingTransition[iTr];} +double lookCapAxis_AND2_X4_A1_ZN_risingTransition(int iCap) {return capAxis_AND2_X4_A1_ZN_risingTransition[iCap];} +double lookTable_AND2_X4_A1_ZN_risingTransition(int iTr, int iCap) {return table_AND2_X4_A1_ZN_risingTransition[iCap][iTr];} + +double trAxis_AND2_X4_A1_ZN_fallingTransition[8] = {7.5e-12, 1.5e-11, 3.0e-11, 6.0e-11, 1.2e-10, 2.4e-10, 4.8e-10, 9.6e-10}; +double capAxis_AND2_X4_A1_ZN_fallingTransition[6] = {4.0e-16, 3.2e-15, 6.4e-15, 1.28e-14, 2.56e-14, 5.12e-14}; +double table_AND2_X4_A1_ZN_fallingTransition[6][8] = {{9.500000000000001e-12, 9.500000000000001e-12, 9.500000000000001e-12, 1.0200000000000001e-11, 1.35e-11, 1.8200000000000002e-11, 2.54e-11, 3.7600000000000005e-11}, {1.33e-11, 1.33e-11, 1.33e-11, 1.3700000000000002e-11, 1.7000000000000003e-11, 2.19e-11, 2.93e-11, 4.18e-11}, {1.71e-11, 1.7200000000000003e-11, 1.71e-11, 1.7500000000000004e-11, 2.0500000000000004e-11, 2.55e-11, 3.3200000000000006e-11, 4.6300000000000004e-11}, {2.43e-11, 2.43e-11, 2.43e-11, 2.46e-11, 2.72e-11, 3.2000000000000006e-11, 4.01e-11, 5.4100000000000006e-11}, {3.81e-11, 3.81e-11, 3.81e-11, 3.8300000000000006e-11, 3.99e-11, 4.44e-11, 5.240000000000001e-11, 6.740000000000001e-11}, {6.690000000000001e-11, 6.690000000000001e-11, 6.690000000000001e-11, 6.700000000000001e-11, 6.759999999999999e-11, 7.040000000000001e-11, 7.660000000000001e-11, 9.11e-11}}; +double lookTrAxis_AND2_X4_A1_ZN_fallingTransition(int iTr) {return trAxis_AND2_X4_A1_ZN_fallingTransition[iTr];} +double lookCapAxis_AND2_X4_A1_ZN_fallingTransition(int iCap) {return capAxis_AND2_X4_A1_ZN_fallingTransition[iCap];} +double lookTable_AND2_X4_A1_ZN_fallingTransition(int iTr, int iCap) {return table_AND2_X4_A1_ZN_fallingTransition[iCap][iTr];} + +double trAxis_AND2_X4_A2_ZN_risingDelay[8] = {7.5e-12, 1.5e-11, 3.0e-11, 6.0e-11, 1.2e-10, 2.4e-10, 4.8e-10, 9.6e-10}; +double capAxis_AND2_X4_A2_ZN_risingDelay[6] = {4.0e-16, 3.2e-15, 6.4e-15, 1.28e-14, 2.56e-14, 5.12e-14}; +double table_AND2_X4_A2_ZN_risingDelay[6][8] = {{4.370000000000001e-11, 4.65e-11, 5.1400000000000005e-11, 5.910000000000001e-11, 6.81e-11, 7.39e-11, 6.83e-11, 3.5300000000000003e-11}, {5.4200000000000004e-11, 5.7000000000000003e-11, 6.19e-11, 6.990000000000001e-11, 7.950000000000001e-11, 8.69e-11, 8.33e-11, 5.240000000000001e-11}, {6.44e-11, 6.73e-11, 7.21e-11, 8.010000000000001e-11, 9.01e-11, 9.86e-11, 9.740000000000001e-11, 6.850000000000001e-11}, {8.320000000000001e-11, 8.590000000000001e-11, 9.09e-11, 9.880000000000001e-11, 1.091e-10, 1.1840000000000003e-10, 1.197e-10, 9.6e-11}, {1.192e-10, 1.221e-10, 1.268e-10, 1.346e-10, 1.449e-10, 1.546e-10, 1.575e-10, 1.389e-10}, {1.908e-10, 1.9370000000000001e-10, 1.984e-10, 2.062e-10, 2.165e-10, 2.2590000000000002e-10, 2.2930000000000003e-10, 2.133e-10}}; +double lookTrAxis_AND2_X4_A2_ZN_risingDelay(int iTr) {return trAxis_AND2_X4_A2_ZN_risingDelay[iTr];} +double lookCapAxis_AND2_X4_A2_ZN_risingDelay(int iCap) {return capAxis_AND2_X4_A2_ZN_risingDelay[iCap];} +double lookTable_AND2_X4_A2_ZN_risingDelay(int iTr, int iCap) {return table_AND2_X4_A2_ZN_risingDelay[iCap][iTr];} + +double trAxis_AND2_X4_A2_ZN_fallingDelay[8] = {7.5e-12, 1.5e-11, 3.0e-11, 6.0e-11, 1.2e-10, 2.4e-10, 4.8e-10, 9.6e-10}; +double capAxis_AND2_X4_A2_ZN_fallingDelay[6] = {4.0e-16, 3.2e-15, 6.4e-15, 1.28e-14, 2.56e-14, 5.12e-14}; +double table_AND2_X4_A2_ZN_fallingDelay[6][8] = {{5.990000000000001e-11, 6.370000000000001e-11, 7.15e-11, 8.81e-11, 1.172e-10, 1.583e-10, 2.206e-10, 3.228e-10}, {6.87e-11, 7.25e-11, 8.03e-11, 9.68e-11, 1.267e-10, 1.6930000000000003e-10, 2.331e-10, 3.3720000000000003e-10}, {7.64e-11, 8.02e-11, 8.81e-11, 1.045e-10, 1.3480000000000002e-10, 1.7870000000000001e-10, 2.441e-10, 3.495e-10}, {8.910000000000001e-11, 9.28e-11, 1.007e-10, 1.173e-10, 1.481e-10, 1.934e-10, 2.6100000000000003e-10, 3.6980000000000006e-10}, {1.104e-10, 1.1400000000000001e-10, 1.22e-10, 1.385e-10, 1.6960000000000001e-10, 2.17e-10, 2.8730000000000003e-10, 4.002e-10}, {1.4820000000000002e-10, 1.518e-10, 1.598e-10, 1.7630000000000003e-10, 2.074e-10, 2.5600000000000005e-10, 3.2910000000000003e-10, 4.4710000000000004e-10}}; +double lookTrAxis_AND2_X4_A2_ZN_fallingDelay(int iTr) {return trAxis_AND2_X4_A2_ZN_fallingDelay[iTr];} +double lookCapAxis_AND2_X4_A2_ZN_fallingDelay(int iCap) {return capAxis_AND2_X4_A2_ZN_fallingDelay[iCap];} +double lookTable_AND2_X4_A2_ZN_fallingDelay(int iTr, int iCap) {return table_AND2_X4_A2_ZN_fallingDelay[iCap][iTr];} + +double trAxis_AND2_X4_A2_ZN_risingTransition[8] = {7.5e-12, 1.5e-11, 3.0e-11, 6.0e-11, 1.2e-10, 2.4e-10, 4.8e-10, 9.6e-10}; +double capAxis_AND2_X4_A2_ZN_risingTransition[6] = {4.0e-16, 3.2e-15, 6.4e-15, 1.28e-14, 2.56e-14, 5.12e-14}; +double table_AND2_X4_A2_ZN_risingTransition[6][8] = {{9.3e-12, 9.3e-12, 9.3e-12, 9.800000000000001e-12, 1.13e-11, 1.4200000000000002e-11, 1.9300000000000004e-11, 2.7700000000000002e-11}, {1.61e-11, 1.62e-11, 1.62e-11, 1.6600000000000003e-11, 1.8e-11, 2.13e-11, 2.72e-11, 3.6100000000000003e-11}, {2.3900000000000003e-11, 2.3900000000000003e-11, 2.3900000000000003e-11, 2.42e-11, 2.54e-11, 2.8300000000000002e-11, 3.470000000000001e-11, 4.5100000000000005e-11}, {3.99e-11, 3.99e-11, 3.99e-11, 4.0000000000000004e-11, 4.0700000000000006e-11, 4.2700000000000005e-11, 4.8200000000000005e-11, 6.0e-11}, {7.32e-11, 7.330000000000001e-11, 7.330000000000001e-11, 7.330000000000001e-11, 7.340000000000001e-11, 7.43e-11, 7.760000000000001e-11, 8.69e-11}, {1.411e-10, 1.411e-10, 1.411e-10, 1.411e-10, 1.411e-10, 1.4130000000000002e-10, 1.4290000000000002e-10, 1.4870000000000001e-10}}; +double lookTrAxis_AND2_X4_A2_ZN_risingTransition(int iTr) {return trAxis_AND2_X4_A2_ZN_risingTransition[iTr];} +double lookCapAxis_AND2_X4_A2_ZN_risingTransition(int iCap) {return capAxis_AND2_X4_A2_ZN_risingTransition[iCap];} +double lookTable_AND2_X4_A2_ZN_risingTransition(int iTr, int iCap) {return table_AND2_X4_A2_ZN_risingTransition[iCap][iTr];} + +double trAxis_AND2_X4_A2_ZN_fallingTransition[8] = {7.5e-12, 1.5e-11, 3.0e-11, 6.0e-11, 1.2e-10, 2.4e-10, 4.8e-10, 9.6e-10}; +double capAxis_AND2_X4_A2_ZN_fallingTransition[6] = {4.0e-16, 3.2e-15, 6.4e-15, 1.28e-14, 2.56e-14, 5.12e-14}; +double table_AND2_X4_A2_ZN_fallingTransition[6][8] = {{1.0700000000000001e-11, 1.0700000000000001e-11, 1.0700000000000001e-11, 1.0700000000000001e-11, 1.35e-11, 1.8200000000000002e-11, 2.4700000000000003e-11, 3.48e-11}, {1.4300000000000002e-11, 1.4300000000000002e-11, 1.4300000000000002e-11, 1.44e-11, 1.68e-11, 2.1600000000000002e-11, 2.8300000000000002e-11, 3.860000000000001e-11}, {1.8100000000000004e-11, 1.8100000000000004e-11, 1.8100000000000004e-11, 1.8200000000000002e-11, 2.03e-11, 2.5000000000000004e-11, 3.18e-11, 4.2400000000000004e-11}, {2.52e-11, 2.52e-11, 2.52e-11, 2.5300000000000002e-11, 2.6900000000000002e-11, 3.15e-11, 3.84e-11, 4.93e-11}, {3.9e-11, 3.9e-11, 3.9e-11, 3.9e-11, 3.980000000000001e-11, 4.38e-11, 5.0500000000000007e-11, 6.17e-11}, {6.759999999999999e-11, 6.759999999999999e-11, 6.759999999999999e-11, 6.759999999999999e-11, 6.800000000000001e-11, 7.03e-11, 7.51e-11, 8.490000000000001e-11}}; +double lookTrAxis_AND2_X4_A2_ZN_fallingTransition(int iTr) {return trAxis_AND2_X4_A2_ZN_fallingTransition[iTr];} +double lookCapAxis_AND2_X4_A2_ZN_fallingTransition(int iCap) {return capAxis_AND2_X4_A2_ZN_fallingTransition[iCap];} +double lookTable_AND2_X4_A2_ZN_fallingTransition(int iTr, int iCap) {return table_AND2_X4_A2_ZN_fallingTransition[iCap][iTr];} + +double trAxis_BUF_X1_A_Z_risingDelay[8] = {7.5e-12, 1.5e-11, 3.0e-11, 6.0e-11, 1.2e-10, 2.4e-10, 4.8e-10, 9.6e-10}; +double capAxis_BUF_X1_A_Z_risingDelay[6] = {4.0e-16, 8.0e-16, 1.6e-15, 3.2e-15, 6.4e-15, 1.28e-14}; +double table_BUF_X1_A_Z_risingDelay[6][8] = {{3.4400000000000005e-11, 3.77e-11, 4.3200000000000003e-11, 4.9500000000000004e-11, 5.5400000000000004e-11, 5.79e-11, 4.89e-11, 1.4200000000000002e-11}, {3.9200000000000004e-11, 4.250000000000001e-11, 4.8e-11, 5.43e-11, 6.05e-11, 6.38e-11, 5.64e-11, 2.3500000000000003e-11}, {4.89e-11, 5.2e-11, 5.750000000000001e-11, 6.38e-11, 7.01e-11, 7.420000000000001e-11, 6.940000000000001e-11, 3.97e-11}, {6.78e-11, 7.08e-11, 7.64e-11, 8.29e-11, 8.9e-11, 9.35e-11, 9.080000000000001e-11, 6.71e-11}, {1.056e-10, 1.086e-10, 1.139e-10, 1.204e-10, 1.267e-10, 1.3120000000000002e-10, 1.2950000000000002e-10, 1.1070000000000002e-10}, {1.81e-10, 1.84e-10, 1.893e-10, 1.9570000000000003e-10, 2.0190000000000002e-10, 2.0630000000000003e-10, 2.052e-10, 1.888e-10}}; +double lookTrAxis_BUF_X1_A_Z_risingDelay(int iTr) {return trAxis_BUF_X1_A_Z_risingDelay[iTr];} +double lookCapAxis_BUF_X1_A_Z_risingDelay(int iCap) {return capAxis_BUF_X1_A_Z_risingDelay[iCap];} +double lookTable_BUF_X1_A_Z_risingDelay(int iTr, int iCap) {return table_BUF_X1_A_Z_risingDelay[iCap][iTr];} + +double trAxis_BUF_X1_A_Z_fallingDelay[8] = {7.5e-12, 1.5e-11, 3.0e-11, 6.0e-11, 1.2e-10, 2.4e-10, 4.8e-10, 9.6e-10}; +double capAxis_BUF_X1_A_Z_fallingDelay[6] = {4.0e-16, 8.0e-16, 1.6e-15, 3.2e-15, 6.4e-15, 1.28e-14}; +double table_BUF_X1_A_Z_fallingDelay[6][8] = {{3.94e-11, 4.33e-11, 5.13e-11, 6.48e-11, 8.34e-11, 1.105e-10, 1.527e-10, 2.2230000000000002e-10}, {4.2700000000000005e-11, 4.6600000000000006e-11, 5.47e-11, 6.84e-11, 8.75e-11, 1.153e-10, 1.5850000000000002e-10, 2.2950000000000003e-10}, {4.8700000000000004e-11, 5.2600000000000004e-11, 6.07e-11, 7.470000000000001e-11, 9.450000000000001e-11, 1.234e-10, 1.685e-10, 2.42e-10}, {5.95e-11, 6.35e-11, 7.140000000000001e-11, 8.58e-11, 1.0650000000000001e-10, 1.3690000000000001e-10, 1.846e-10, 2.6240000000000005e-10}, {7.91e-11, 8.300000000000001e-11, 9.11e-11, 1.056e-10, 1.2730000000000002e-10, 1.593e-10, 2.103e-10, 2.945e-10}, {1.169e-10, 1.209e-10, 1.289e-10, 1.435e-10, 1.6550000000000002e-10, 1.984e-10, 2.526e-10, 3.445e-10}}; +double lookTrAxis_BUF_X1_A_Z_fallingDelay(int iTr) {return trAxis_BUF_X1_A_Z_fallingDelay[iTr];} +double lookCapAxis_BUF_X1_A_Z_fallingDelay(int iCap) {return capAxis_BUF_X1_A_Z_fallingDelay[iCap];} +double lookTable_BUF_X1_A_Z_fallingDelay(int iTr, int iCap) {return table_BUF_X1_A_Z_fallingDelay[iCap][iTr];} + +double trAxis_BUF_X1_A_Z_risingTransition[8] = {7.5e-12, 1.5e-11, 3.0e-11, 6.0e-11, 1.2e-10, 2.4e-10, 4.8e-10, 9.6e-10}; +double capAxis_BUF_X1_A_Z_risingTransition[6] = {4.0e-16, 8.0e-16, 1.6e-15, 3.2e-15, 6.4e-15, 1.28e-14}; +double table_BUF_X1_A_Z_risingTransition[6][8] = {{1.4000000000000002e-11, 1.4000000000000002e-11, 1.4200000000000002e-11, 1.49e-11, 1.6600000000000003e-11, 2.0500000000000004e-11, 2.7100000000000002e-11, 3.72e-11}, {1.83e-11, 1.83e-11, 1.8400000000000002e-11, 1.8800000000000002e-11, 2.01e-11, 2.37e-11, 3.0900000000000004e-11, 4.21e-11}, {2.7100000000000002e-11, 2.7100000000000002e-11, 2.7100000000000002e-11, 2.7400000000000004e-11, 2.8000000000000003e-11, 3.06e-11, 3.77e-11, 5.08e-11}, {4.5100000000000005e-11, 4.5e-11, 4.5e-11, 4.5100000000000005e-11, 4.5400000000000006e-11, 4.6700000000000004e-11, 5.16e-11, 6.519999999999999e-11}, {8.09e-11, 8.09e-11, 8.09e-11, 8.09e-11, 8.1e-11, 8.15e-11, 8.42e-11, 9.35e-11}, {1.5250000000000002e-10, 1.5250000000000002e-10, 1.5250000000000002e-10, 1.5250000000000002e-10, 1.5250000000000002e-10, 1.528e-10, 1.545e-10, 1.6020000000000003e-10}}; +double lookTrAxis_BUF_X1_A_Z_risingTransition(int iTr) {return trAxis_BUF_X1_A_Z_risingTransition[iTr];} +double lookCapAxis_BUF_X1_A_Z_risingTransition(int iCap) {return capAxis_BUF_X1_A_Z_risingTransition[iCap];} +double lookTable_BUF_X1_A_Z_risingTransition(int iTr, int iCap) {return table_BUF_X1_A_Z_risingTransition[iCap][iTr];} + +double trAxis_BUF_X1_A_Z_fallingTransition[8] = {7.5e-12, 1.5e-11, 3.0e-11, 6.0e-11, 1.2e-10, 2.4e-10, 4.8e-10, 9.6e-10}; +double capAxis_BUF_X1_A_Z_fallingTransition[6] = {4.0e-16, 8.0e-16, 1.6e-15, 3.2e-15, 6.4e-15, 1.28e-14}; +double table_BUF_X1_A_Z_fallingTransition[6][8] = {{9.800000000000001e-12, 9.800000000000001e-12, 9.900000000000001e-12, 1.12e-11, 1.36e-11, 1.71e-11, 2.2900000000000003e-11, 3.31e-11}, {1.17e-11, 1.17e-11, 1.18e-11, 1.3e-11, 1.53e-11, 1.9000000000000002e-11, 2.5100000000000003e-11, 3.58e-11}, {1.55e-11, 1.55e-11, 1.56e-11, 1.65e-11, 1.89e-11, 2.26e-11, 2.9100000000000002e-11, 4.06e-11}, {2.3e-11, 2.3e-11, 2.31e-11, 2.37e-11, 2.5900000000000002e-11, 2.94e-11, 3.63e-11, 4.9000000000000005e-11}, {3.8300000000000006e-11, 3.82e-11, 3.82e-11, 3.85e-11, 4.0000000000000004e-11, 4.29e-11, 4.93e-11, 6.320000000000001e-11}, {7.02e-11, 7.02e-11, 7.02e-11, 7.03e-11, 7.07e-11, 7.2e-11, 7.67e-11, 8.96e-11}}; +double lookTrAxis_BUF_X1_A_Z_fallingTransition(int iTr) {return trAxis_BUF_X1_A_Z_fallingTransition[iTr];} +double lookCapAxis_BUF_X1_A_Z_fallingTransition(int iCap) {return capAxis_BUF_X1_A_Z_fallingTransition[iCap];} +double lookTable_BUF_X1_A_Z_fallingTransition(int iTr, int iCap) {return table_BUF_X1_A_Z_fallingTransition[iCap][iTr];} + +double trAxis_BUF_X16_A_Z_risingDelay[8] = {7.5e-12, 1.5e-11, 3.0e-11, 6.0e-11, 1.2e-10, 2.4e-10, 4.8e-10, 9.6e-10}; +double capAxis_BUF_X16_A_Z_risingDelay[6] = {4.0e-16, 1.28e-14, 2.56e-14, 5.12e-14, 1.024e-13, 2.048e-13}; +double table_BUF_X16_A_Z_risingDelay[6][8] = {{5.95e-11, 6.29e-11, 6.97e-11, 8.350000000000001e-11, 1.038e-10, 1.2540000000000003e-10, 1.438e-10, 1.473e-10}, {7.240000000000002e-11, 7.580000000000001e-11, 8.260000000000002e-11, 9.62e-11, 1.173e-10, 1.4000000000000003e-10, 1.5950000000000002e-10, 1.6400000000000003e-10}, {8.33e-11, 8.670000000000001e-11, 9.36e-11, 1.0730000000000001e-10, 1.287e-10, 1.5250000000000002e-10, 1.735e-10, 1.797e-10}, {1.0290000000000001e-10, 1.061e-10, 1.1300000000000001e-10, 1.266e-10, 1.483e-10, 1.737e-10, 1.9760000000000002e-10, 2.075e-10}, {1.395e-10, 1.427e-10, 1.4940000000000002e-10, 1.63e-10, 1.8440000000000003e-10, 2.1010000000000003e-10, 2.3640000000000003e-10, 2.531e-10}, {2.113e-10, 2.145e-10, 2.2110000000000002e-10, 2.346e-10, 2.5560000000000003e-10, 2.8060000000000004e-10, 3.0640000000000005e-10, 3.2640000000000003e-10}}; +double lookTrAxis_BUF_X16_A_Z_risingDelay(int iTr) {return trAxis_BUF_X16_A_Z_risingDelay[iTr];} +double lookCapAxis_BUF_X16_A_Z_risingDelay(int iCap) {return capAxis_BUF_X16_A_Z_risingDelay[iCap];} +double lookTable_BUF_X16_A_Z_risingDelay(int iTr, int iCap) {return table_BUF_X16_A_Z_risingDelay[iCap][iTr];} + +double trAxis_BUF_X16_A_Z_fallingDelay[8] = {7.5e-12, 1.5e-11, 3.0e-11, 6.0e-11, 1.2e-10, 2.4e-10, 4.8e-10, 9.6e-10}; +double capAxis_BUF_X16_A_Z_fallingDelay[6] = {4.0e-16, 1.28e-14, 2.56e-14, 5.12e-14, 1.024e-13, 2.048e-13}; +double table_BUF_X16_A_Z_fallingDelay[6][8] = {{9.390000000000001e-11, 9.760000000000002e-11, 1.0520000000000001e-10, 1.212e-10, 1.5440000000000003e-10, 2.07e-10, 2.798e-10, 3.877e-10}, {1.051e-10, 1.088e-10, 1.1640000000000001e-10, 1.324e-10, 1.654e-10, 2.188e-10, 2.928e-10, 4.0200000000000006e-10}, {1.1430000000000001e-10, 1.181e-10, 1.258e-10, 1.4180000000000002e-10, 1.745e-10, 2.2880000000000003e-10, 3.0380000000000003e-10, 4.143e-10}, {1.298e-10, 1.334e-10, 1.4120000000000001e-10, 1.5740000000000002e-10, 1.901e-10, 2.4550000000000003e-10, 3.225e-10, 4.357e-10}, {1.5509999999999999e-10, 1.587e-10, 1.6640000000000001e-10, 1.827e-10, 2.1540000000000003e-10, 2.721e-10, 3.5270000000000003e-10, 4.703e-10}, {1.972e-10, 2.0080000000000002e-10, 2.086e-10, 2.2480000000000001e-10, 2.5750000000000004e-10, 3.1510000000000003e-10, 3.9960000000000005e-10, 5.241000000000001e-10}}; +double lookTrAxis_BUF_X16_A_Z_fallingDelay(int iTr) {return trAxis_BUF_X16_A_Z_fallingDelay[iTr];} +double lookCapAxis_BUF_X16_A_Z_fallingDelay(int iCap) {return capAxis_BUF_X16_A_Z_fallingDelay[iCap];} +double lookTable_BUF_X16_A_Z_fallingDelay(int iTr, int iCap) {return table_BUF_X16_A_Z_fallingDelay[iCap][iTr];} + +double trAxis_BUF_X16_A_Z_risingTransition[8] = {7.5e-12, 1.5e-11, 3.0e-11, 6.0e-11, 1.2e-10, 2.4e-10, 4.8e-10, 9.6e-10}; +double capAxis_BUF_X16_A_Z_risingTransition[6] = {4.0e-16, 1.28e-14, 2.56e-14, 5.12e-14, 1.024e-13, 2.048e-13}; +double table_BUF_X16_A_Z_risingTransition[6][8] = {{1.41e-11, 1.41e-11, 1.41e-11, 1.44e-11, 1.8200000000000002e-11, 2.4700000000000003e-11, 3.54e-11, 5.4e-11}, {2.1700000000000003e-11, 2.1700000000000003e-11, 2.1700000000000003e-11, 2.19e-11, 2.5000000000000004e-11, 3.11e-11, 4.1200000000000004e-11, 5.86e-11}, {2.93e-11, 2.93e-11, 2.93e-11, 2.95e-11, 3.18e-11, 3.77e-11, 4.81e-11, 6.53e-11}, {4.4600000000000006e-11, 4.4600000000000006e-11, 4.4600000000000006e-11, 4.47e-11, 4.5900000000000004e-11, 5.0500000000000007e-11, 6.06e-11, 7.920000000000001e-11}, {7.7e-11, 7.7e-11, 7.7e-11, 7.7e-11, 7.74e-11, 7.94e-11, 8.57e-11, 1.03e-10}, {1.4440000000000001e-10, 1.4440000000000001e-10, 1.4440000000000001e-10, 1.4440000000000001e-10, 1.445e-10, 1.4480000000000003e-10, 1.467e-10, 1.553e-10}}; +double lookTrAxis_BUF_X16_A_Z_risingTransition(int iTr) {return trAxis_BUF_X16_A_Z_risingTransition[iTr];} +double lookCapAxis_BUF_X16_A_Z_risingTransition(int iCap) {return capAxis_BUF_X16_A_Z_risingTransition[iCap];} +double lookTable_BUF_X16_A_Z_risingTransition(int iTr, int iCap) {return table_BUF_X16_A_Z_risingTransition[iCap][iTr];} + +double trAxis_BUF_X16_A_Z_fallingTransition[8] = {7.5e-12, 1.5e-11, 3.0e-11, 6.0e-11, 1.2e-10, 2.4e-10, 4.8e-10, 9.6e-10}; +double capAxis_BUF_X16_A_Z_fallingTransition[6] = {4.0e-16, 1.28e-14, 2.56e-14, 5.12e-14, 1.024e-13, 2.048e-13}; +double table_BUF_X16_A_Z_fallingTransition[6][8] = {{2.28e-11, 2.28e-11, 2.28e-11, 2.28e-11, 2.37e-11, 3.29e-11, 4.610000000000001e-11, 6.510000000000001e-11}, {2.66e-11, 2.66e-11, 2.66e-11, 2.66e-11, 2.7300000000000002e-11, 3.58e-11, 4.880000000000001e-11, 6.759999999999999e-11}, {3.05e-11, 3.05e-11, 3.05e-11, 3.05e-11, 3.12e-11, 3.9e-11, 5.19e-11, 7.090000000000001e-11}, {3.8000000000000004e-11, 3.8000000000000004e-11, 3.8000000000000004e-11, 3.8000000000000004e-11, 3.85e-11, 4.5400000000000006e-11, 5.8100000000000005e-11, 7.73e-11}, {5.2e-11, 5.2e-11, 5.19e-11, 5.19e-11, 5.23e-11, 5.750000000000001e-11, 6.980000000000001e-11, 8.94e-11}, {7.93e-11, 7.93e-11, 7.93e-11, 7.93e-11, 7.950000000000001e-11, 8.240000000000001e-11, 9.29e-11, 1.1140000000000001e-10}}; +double lookTrAxis_BUF_X16_A_Z_fallingTransition(int iTr) {return trAxis_BUF_X16_A_Z_fallingTransition[iTr];} +double lookCapAxis_BUF_X16_A_Z_fallingTransition(int iCap) {return capAxis_BUF_X16_A_Z_fallingTransition[iCap];} +double lookTable_BUF_X16_A_Z_fallingTransition(int iTr, int iCap) {return table_BUF_X16_A_Z_fallingTransition[iCap][iTr];} + +double trAxis_BUF_X2_A_Z_risingDelay[8] = {7.5e-12, 1.5e-11, 3.0e-11, 6.0e-11, 1.2e-10, 2.4e-10, 4.8e-10, 9.6e-10}; +double capAxis_BUF_X2_A_Z_risingDelay[6] = {4.0e-16, 1.6e-15, 3.2e-15, 6.4e-15, 1.28e-14, 2.56e-14}; +double table_BUF_X2_A_Z_risingDelay[6][8] = {{3.02e-11, 3.36e-11, 3.9600000000000004e-11, 4.6700000000000004e-11, 5.32e-11, 5.600000000000001e-11, 4.7900000000000004e-11, 1.4800000000000003e-11}, {3.77e-11, 4.11e-11, 4.7000000000000006e-11, 5.4500000000000006e-11, 6.2e-11, 6.65e-11, 6.05e-11, 2.98e-11}, {4.7000000000000006e-11, 5.04e-11, 5.630000000000001e-11, 6.390000000000001e-11, 7.170000000000001e-11, 7.770000000000001e-11, 7.44e-11, 4.6600000000000006e-11}, {6.54e-11, 6.86e-11, 7.45e-11, 8.22e-11, 9.01e-11, 9.67e-11, 9.640000000000001e-11, 7.46e-11}, {1.0180000000000001e-10, 1.05e-10, 1.1080000000000001e-10, 1.1830000000000002e-10, 1.2620000000000001e-10, 1.3280000000000002e-10, 1.3380000000000002e-10, 1.1820000000000002e-10}, {1.7460000000000002e-10, 1.7780000000000002e-10, 1.835e-10, 1.911e-10, 1.987e-10, 2.05e-10, 2.065e-10, 1.9330000000000002e-10}}; +double lookTrAxis_BUF_X2_A_Z_risingDelay(int iTr) {return trAxis_BUF_X2_A_Z_risingDelay[iTr];} +double lookCapAxis_BUF_X2_A_Z_risingDelay(int iCap) {return capAxis_BUF_X2_A_Z_risingDelay[iCap];} +double lookTable_BUF_X2_A_Z_risingDelay(int iTr, int iCap) {return table_BUF_X2_A_Z_risingDelay[iCap][iTr];} + +double trAxis_BUF_X2_A_Z_fallingDelay[8] = {7.5e-12, 1.5e-11, 3.0e-11, 6.0e-11, 1.2e-10, 2.4e-10, 4.8e-10, 9.6e-10}; +double capAxis_BUF_X2_A_Z_fallingDelay[6] = {4.0e-16, 1.6e-15, 3.2e-15, 6.4e-15, 1.28e-14, 2.56e-14}; +double table_BUF_X2_A_Z_fallingDelay[6][8] = {{3.860000000000001e-11, 4.2400000000000004e-11, 5.0500000000000007e-11, 6.48e-11, 8.45e-11, 1.127e-10, 1.5620000000000001e-10, 2.2760000000000002e-10}, {4.4600000000000006e-11, 4.84e-11, 5.6500000000000005e-11, 7.120000000000001e-11, 9.180000000000001e-11, 1.211e-10, 1.662e-10, 2.397e-10}, {5.11e-11, 5.5000000000000004e-11, 6.310000000000001e-11, 7.8e-11, 9.940000000000001e-11, 1.301e-10, 1.769e-10, 2.526e-10}, {6.22e-11, 6.610000000000001e-11, 7.420000000000001e-11, 8.94e-11, 1.1190000000000001e-10, 1.4410000000000002e-10, 1.9380000000000002e-10, 2.736e-10}, {8.18e-11, 8.57e-11, 9.38e-11, 1.091e-10, 1.326e-10, 1.668e-10, 2.198e-10, 3.0590000000000005e-10}, {1.186e-10, 1.2250000000000002e-10, 1.3050000000000001e-10, 1.4580000000000003e-10, 1.699e-10, 2.0510000000000002e-10, 2.6150000000000003e-10, 3.5540000000000003e-10}}; +double lookTrAxis_BUF_X2_A_Z_fallingDelay(int iTr) {return trAxis_BUF_X2_A_Z_fallingDelay[iTr];} +double lookCapAxis_BUF_X2_A_Z_fallingDelay(int iCap) {return capAxis_BUF_X2_A_Z_fallingDelay[iCap];} +double lookTable_BUF_X2_A_Z_fallingDelay(int iTr, int iCap) {return table_BUF_X2_A_Z_fallingDelay[iCap][iTr];} + +double trAxis_BUF_X2_A_Z_risingTransition[8] = {7.5e-12, 1.5e-11, 3.0e-11, 6.0e-11, 1.2e-10, 2.4e-10, 4.8e-10, 9.6e-10}; +double capAxis_BUF_X2_A_Z_risingTransition[6] = {4.0e-16, 1.6e-15, 3.2e-15, 6.4e-15, 1.28e-14, 2.56e-14}; +double table_BUF_X2_A_Z_risingTransition[6][8] = {{8.900000000000001e-12, 8.900000000000001e-12, 9.200000000000001e-12, 1.0500000000000001e-11, 1.2800000000000002e-11, 1.6400000000000003e-11, 2.22e-11, 3.22e-11}, {1.46e-11, 1.47e-11, 1.4800000000000003e-11, 1.56e-11, 1.7500000000000004e-11, 2.1700000000000003e-11, 2.8600000000000003e-11, 3.9500000000000006e-11}, {2.2900000000000003e-11, 2.2900000000000003e-11, 2.2900000000000003e-11, 2.34e-11, 2.46e-11, 2.8000000000000003e-11, 3.5700000000000003e-11, 4.84e-11}, {4.0000000000000004e-11, 4.0000000000000004e-11, 4.01e-11, 4.01e-11, 4.06e-11, 4.250000000000001e-11, 4.86e-11, 6.3e-11}, {7.46e-11, 7.46e-11, 7.470000000000001e-11, 7.470000000000001e-11, 7.480000000000002e-11, 7.54e-11, 7.85e-11, 8.920000000000001e-11}, {1.437e-10, 1.437e-10, 1.437e-10, 1.437e-10, 1.438e-10, 1.44e-10, 1.4560000000000002e-10, 1.515e-10}}; +double lookTrAxis_BUF_X2_A_Z_risingTransition(int iTr) {return trAxis_BUF_X2_A_Z_risingTransition[iTr];} +double lookCapAxis_BUF_X2_A_Z_risingTransition(int iCap) {return capAxis_BUF_X2_A_Z_risingTransition[iCap];} +double lookTable_BUF_X2_A_Z_risingTransition(int iTr, int iCap) {return table_BUF_X2_A_Z_risingTransition[iCap][iTr];} + +double trAxis_BUF_X2_A_Z_fallingTransition[8] = {7.5e-12, 1.5e-11, 3.0e-11, 6.0e-11, 1.2e-10, 2.4e-10, 4.8e-10, 9.6e-10}; +double capAxis_BUF_X2_A_Z_fallingTransition[6] = {4.0e-16, 1.6e-15, 3.2e-15, 6.4e-15, 1.28e-14, 2.56e-14}; +double table_BUF_X2_A_Z_fallingTransition[6][8] = {{8.000000000000001e-12, 8.1e-12, 8.1e-12, 9.500000000000001e-12, 1.21e-11, 1.5800000000000003e-11, 2.19e-11, 3.24e-11}, {1.11e-11, 1.11e-11, 1.11e-11, 1.2200000000000002e-11, 1.49e-11, 1.89e-11, 2.54e-11, 3.65e-11}, {1.4800000000000003e-11, 1.4800000000000003e-11, 1.4800000000000003e-11, 1.5699999999999998e-11, 1.8400000000000002e-11, 2.26e-11, 2.94e-11, 4.1200000000000004e-11}, {2.19e-11, 2.19e-11, 2.19e-11, 2.25e-11, 2.5100000000000003e-11, 2.9100000000000002e-11, 3.6400000000000005e-11, 4.93e-11}, {3.620000000000001e-11, 3.620000000000001e-11, 3.63e-11, 3.66e-11, 3.82e-11, 4.1600000000000004e-11, 4.880000000000001e-11, 6.3e-11}, {6.65e-11, 6.65e-11, 6.65e-11, 6.660000000000001e-11, 6.72e-11, 6.91e-11, 7.420000000000001e-11, 8.77e-11}}; +double lookTrAxis_BUF_X2_A_Z_fallingTransition(int iTr) {return trAxis_BUF_X2_A_Z_fallingTransition[iTr];} +double lookCapAxis_BUF_X2_A_Z_fallingTransition(int iCap) {return capAxis_BUF_X2_A_Z_fallingTransition[iCap];} +double lookTable_BUF_X2_A_Z_fallingTransition(int iTr, int iCap) {return table_BUF_X2_A_Z_fallingTransition[iCap][iTr];} + +double trAxis_BUF_X32_A_Z_risingDelay[8] = {7.5e-12, 1.5e-11, 3.0e-11, 6.0e-11, 1.2e-10, 2.4e-10, 4.8e-10, 9.6e-10}; +double capAxis_BUF_X32_A_Z_risingDelay[6] = {4.0e-16, 2.56e-14, 5.12e-14, 1.024e-13, 2.048e-13, 4.096e-13}; +double table_BUF_X32_A_Z_risingDelay[6][8] = {{9.700000000000001e-11, 1.003e-10, 1.069e-10, 1.206e-10, 1.485e-10, 1.8680000000000002e-10, 2.273e-10, 2.6040000000000005e-10}, {1.1190000000000001e-10, 1.152e-10, 1.2190000000000001e-10, 1.356e-10, 1.631e-10, 2.0200000000000003e-10, 2.43e-10, 2.7670000000000004e-10}, {1.248e-10, 1.281e-10, 1.3480000000000002e-10, 1.486e-10, 1.759e-10, 2.1560000000000004e-10, 2.5750000000000004e-10, 2.923e-10}, {1.4720000000000002e-10, 1.5040000000000002e-10, 1.571e-10, 1.709e-10, 1.982e-10, 2.39e-10, 2.833e-10, 3.2090000000000005e-10}, {1.8640000000000002e-10, 1.896e-10, 1.9620000000000003e-10, 2.0990000000000002e-10, 2.37e-10, 2.784e-10, 3.2560000000000004e-10, 3.695e-10}, {2.592e-10, 2.6240000000000005e-10, 2.6900000000000005e-10, 2.827e-10, 3.095e-10, 3.5020000000000004e-10, 3.979e-10, 4.467e-10}}; +double lookTrAxis_BUF_X32_A_Z_risingDelay(int iTr) {return trAxis_BUF_X32_A_Z_risingDelay[iTr];} +double lookCapAxis_BUF_X32_A_Z_risingDelay(int iCap) {return capAxis_BUF_X32_A_Z_risingDelay[iCap];} +double lookTable_BUF_X32_A_Z_risingDelay(int iTr, int iCap) {return table_BUF_X32_A_Z_risingDelay[iCap][iTr];} + +double trAxis_BUF_X32_A_Z_fallingDelay[8] = {7.5e-12, 1.5e-11, 3.0e-11, 6.0e-11, 1.2e-10, 2.4e-10, 4.8e-10, 9.6e-10}; +double capAxis_BUF_X32_A_Z_fallingDelay[6] = {4.0e-16, 2.56e-14, 5.12e-14, 1.024e-13, 2.048e-13, 4.096e-13}; +double table_BUF_X32_A_Z_fallingDelay[6][8] = {{1.6270000000000002e-10, 1.6640000000000001e-10, 1.74e-10, 1.896e-10, 2.219e-10, 2.886e-10, 3.9000000000000005e-10, 5.314e-10}, {1.757e-10, 1.7940000000000002e-10, 1.87e-10, 2.026e-10, 2.35e-10, 3.014e-10, 4.037e-10, 5.457e-10}, {1.8690000000000002e-10, 1.906e-10, 1.982e-10, 2.1370000000000002e-10, 2.461e-10, 3.12e-10, 4.152e-10, 5.588e-10}, {2.059e-10, 2.095e-10, 2.17e-10, 2.3280000000000001e-10, 2.652e-10, 3.3060000000000003e-10, 4.357e-10, 5.813e-10}, {2.37e-10, 2.405e-10, 2.481e-10, 2.638e-10, 2.962e-10, 3.614e-10, 4.692e-10, 6.192e-10}, {2.87e-10, 2.9060000000000006e-10, 2.982e-10, 3.139e-10, 3.4630000000000003e-10, 4.1120000000000004e-10, 5.221000000000001e-10, 6.789e-10}}; +double lookTrAxis_BUF_X32_A_Z_fallingDelay(int iTr) {return trAxis_BUF_X32_A_Z_fallingDelay[iTr];} +double lookCapAxis_BUF_X32_A_Z_fallingDelay(int iCap) {return capAxis_BUF_X32_A_Z_fallingDelay[iCap];} +double lookTable_BUF_X32_A_Z_fallingDelay(int iTr, int iCap) {return table_BUF_X32_A_Z_fallingDelay[iCap][iTr];} + +double trAxis_BUF_X32_A_Z_risingTransition[8] = {7.5e-12, 1.5e-11, 3.0e-11, 6.0e-11, 1.2e-10, 2.4e-10, 4.8e-10, 9.6e-10}; +double capAxis_BUF_X32_A_Z_risingTransition[6] = {4.0e-16, 2.56e-14, 5.12e-14, 1.024e-13, 2.048e-13, 4.096e-13}; +double table_BUF_X32_A_Z_risingTransition[6][8] = {{2.26e-11, 2.26e-11, 2.26e-11, 2.26e-11, 2.3800000000000004e-11, 3.2800000000000006e-11, 4.69e-11, 6.980000000000001e-11}, {3.0e-11, 3.0e-11, 3.0e-11, 3.0e-11, 3.07e-11, 3.8300000000000006e-11, 5.120000000000001e-11, 7.290000000000001e-11}, {3.7900000000000006e-11, 3.7900000000000006e-11, 3.7900000000000006e-11, 3.7900000000000006e-11, 3.85e-11, 4.53e-11, 5.7800000000000003e-11, 7.85e-11}, {5.3000000000000004e-11, 5.3000000000000004e-11, 5.3000000000000004e-11, 5.3000000000000004e-11, 5.3400000000000004e-11, 5.88e-11, 7.1e-11, 9.180000000000001e-11}, {8.350000000000001e-11, 8.350000000000001e-11, 8.350000000000001e-11, 8.350000000000001e-11, 8.380000000000001e-11, 8.66e-11, 9.580000000000001e-11, 1.165e-10}, {1.483e-10, 1.4840000000000003e-10, 1.483e-10, 1.483e-10, 1.4840000000000003e-10, 1.492e-10, 1.5300000000000001e-10, 1.6550000000000002e-10}}; +double lookTrAxis_BUF_X32_A_Z_risingTransition(int iTr) {return trAxis_BUF_X32_A_Z_risingTransition[iTr];} +double lookCapAxis_BUF_X32_A_Z_risingTransition(int iCap) {return capAxis_BUF_X32_A_Z_risingTransition[iCap];} +double lookTable_BUF_X32_A_Z_risingTransition(int iTr, int iCap) {return table_BUF_X32_A_Z_risingTransition[iCap][iTr];} + +double trAxis_BUF_X32_A_Z_fallingTransition[8] = {7.5e-12, 1.5e-11, 3.0e-11, 6.0e-11, 1.2e-10, 2.4e-10, 4.8e-10, 9.6e-10}; +double capAxis_BUF_X32_A_Z_fallingTransition[6] = {4.0e-16, 2.56e-14, 5.12e-14, 1.024e-13, 2.048e-13, 4.096e-13}; +double table_BUF_X32_A_Z_fallingTransition[6][8] = {{4.2700000000000005e-11, 4.2700000000000005e-11, 4.2700000000000005e-11, 4.2700000000000005e-11, 4.2700000000000005e-11, 4.57e-11, 6.49e-11, 9.17e-11}, {4.5900000000000004e-11, 4.5900000000000004e-11, 4.5900000000000004e-11, 4.5900000000000004e-11, 4.5900000000000004e-11, 4.850000000000001e-11, 6.700000000000001e-11, 9.340000000000001e-11}, {4.9700000000000007e-11, 4.96e-11, 4.96e-11, 4.9700000000000007e-11, 4.9700000000000007e-11, 5.19e-11, 6.990000000000001e-11, 9.59e-11}, {5.7400000000000003e-11, 5.7400000000000003e-11, 5.7400000000000003e-11, 5.7400000000000003e-11, 5.7400000000000003e-11, 5.920000000000001e-11, 7.600000000000001e-11, 1.019e-10}, {7.2e-11, 7.2e-11, 7.19e-11, 7.2e-11, 7.2e-11, 7.330000000000001e-11, 8.8e-11, 1.137e-10}, {9.97e-11, 9.97e-11, 9.97e-11, 9.97e-11, 9.96e-11, 1.0060000000000001e-10, 1.117e-10, 1.363e-10}}; +double lookTrAxis_BUF_X32_A_Z_fallingTransition(int iTr) {return trAxis_BUF_X32_A_Z_fallingTransition[iTr];} +double lookCapAxis_BUF_X32_A_Z_fallingTransition(int iCap) {return capAxis_BUF_X32_A_Z_fallingTransition[iCap];} +double lookTable_BUF_X32_A_Z_fallingTransition(int iTr, int iCap) {return table_BUF_X32_A_Z_fallingTransition[iCap][iTr];} + +double trAxis_BUF_X4_A_Z_risingDelay[8] = {7.5e-12, 1.5e-11, 3.0e-11, 6.0e-11, 1.2e-10, 2.4e-10, 4.8e-10, 9.6e-10}; +double capAxis_BUF_X4_A_Z_risingDelay[6] = {4.0e-16, 3.2e-15, 6.4e-15, 1.28e-14, 2.56e-14, 5.12e-14}; +double table_BUF_X4_A_Z_risingDelay[6][8] = {{3.05e-11, 3.39e-11, 4.0300000000000006e-11, 4.84e-11, 5.6200000000000004e-11, 6.09e-11, 5.61e-11, 2.8000000000000003e-11}, {3.97e-11, 4.3100000000000005e-11, 4.9500000000000004e-11, 5.8200000000000003e-11, 6.73e-11, 7.38e-11, 7.090000000000001e-11, 4.490000000000001e-11}, {4.9100000000000004e-11, 5.25e-11, 5.88e-11, 6.759999999999999e-11, 7.710000000000001e-11, 8.53e-11, 8.480000000000001e-11, 6.12e-11}, {6.71e-11, 7.040000000000001e-11, 7.67e-11, 8.550000000000001e-11, 9.520000000000002e-11, 1.0410000000000001e-10, 1.07e-10, 8.890000000000001e-11}, {1.03e-10, 1.0630000000000001e-10, 1.123e-10, 1.21e-10, 1.3039999999999998e-10, 1.3930000000000003e-10, 1.437e-10, 1.323e-10}, {1.745e-10, 1.7780000000000002e-10, 1.8390000000000003e-10, 1.925e-10, 2.016e-10, 2.1010000000000003e-10, 2.1440000000000003e-10, 2.0530000000000003e-10}}; +double lookTrAxis_BUF_X4_A_Z_risingDelay(int iTr) {return trAxis_BUF_X4_A_Z_risingDelay[iTr];} +double lookCapAxis_BUF_X4_A_Z_risingDelay(int iCap) {return capAxis_BUF_X4_A_Z_risingDelay[iCap];} +double lookTable_BUF_X4_A_Z_risingDelay(int iTr, int iCap) {return table_BUF_X4_A_Z_risingDelay[iCap][iTr];} + +double trAxis_BUF_X4_A_Z_fallingDelay[8] = {7.5e-12, 1.5e-11, 3.0e-11, 6.0e-11, 1.2e-10, 2.4e-10, 4.8e-10, 9.6e-10}; +double capAxis_BUF_X4_A_Z_fallingDelay[6] = {4.0e-16, 3.2e-15, 6.4e-15, 1.28e-14, 2.56e-14, 5.12e-14}; +double table_BUF_X4_A_Z_fallingDelay[6][8] = {{4.18e-11, 4.56e-11, 5.37e-11, 6.91e-11, 9.09e-11, 1.217e-10, 1.687e-10, 2.451e-10}, {4.96e-11, 5.3400000000000004e-11, 6.14e-11, 7.710000000000001e-11, 9.990000000000001e-11, 1.32e-10, 1.8060000000000003e-10, 2.5890000000000006e-10}, {5.6500000000000005e-11, 6.03e-11, 6.84e-11, 8.41e-11, 1.0780000000000002e-10, 1.411e-10, 1.9120000000000002e-10, 2.7150000000000004e-10}, {6.800000000000001e-11, 7.180000000000001e-11, 8.000000000000001e-11, 9.57e-11, 1.205e-10, 1.5540000000000003e-10, 2.081e-10, 2.9220000000000004e-10}, {8.790000000000001e-11, 9.17e-11, 9.980000000000001e-11, 1.157e-10, 1.414e-10, 1.781e-10, 2.3420000000000003e-10, 3.241e-10}, {1.245e-10, 1.283e-10, 1.3650000000000002e-10, 1.5210000000000002e-10, 1.7820000000000002e-10, 2.1620000000000001e-10, 2.756e-10, 3.729e-10}}; +double lookTrAxis_BUF_X4_A_Z_fallingDelay(int iTr) {return trAxis_BUF_X4_A_Z_fallingDelay[iTr];} +double lookCapAxis_BUF_X4_A_Z_fallingDelay(int iCap) {return capAxis_BUF_X4_A_Z_fallingDelay[iCap];} +double lookTable_BUF_X4_A_Z_fallingDelay(int iTr, int iCap) {return table_BUF_X4_A_Z_fallingDelay[iCap][iTr];} + +double trAxis_BUF_X4_A_Z_risingTransition[8] = {7.5e-12, 1.5e-11, 3.0e-11, 6.0e-11, 1.2e-10, 2.4e-10, 4.8e-10, 9.6e-10}; +double capAxis_BUF_X4_A_Z_risingTransition[6] = {4.0e-16, 3.2e-15, 6.4e-15, 1.28e-14, 2.56e-14, 5.12e-14}; +double table_BUF_X4_A_Z_risingTransition[6][8] = {{7.900000000000001e-12, 7.8e-12, 8.200000000000001e-12, 9.700000000000001e-12, 1.21e-11, 1.6000000000000003e-11, 2.2900000000000003e-11, 3.5300000000000003e-11}, {1.4300000000000002e-11, 1.4300000000000002e-11, 1.4500000000000002e-11, 1.55e-11, 1.79e-11, 2.25e-11, 2.99e-11, 4.21e-11}, {2.2300000000000003e-11, 2.2300000000000003e-11, 2.2300000000000003e-11, 2.2900000000000003e-11, 2.4400000000000004e-11, 2.8600000000000003e-11, 3.69e-11, 5.04e-11}, {3.89e-11, 3.89e-11, 3.89e-11, 3.9100000000000006e-11, 3.97e-11, 4.21e-11, 4.92e-11, 6.47e-11}, {7.280000000000001e-11, 7.290000000000001e-11, 7.280000000000001e-11, 7.280000000000001e-11, 7.3e-11, 7.37e-11, 7.720000000000002e-11, 8.95e-11}, {1.407e-10, 1.4080000000000002e-10, 1.407e-10, 1.407e-10, 1.4080000000000002e-10, 1.41e-10, 1.426e-10, 1.4870000000000001e-10}}; +double lookTrAxis_BUF_X4_A_Z_risingTransition(int iTr) {return trAxis_BUF_X4_A_Z_risingTransition[iTr];} +double lookCapAxis_BUF_X4_A_Z_risingTransition(int iCap) {return capAxis_BUF_X4_A_Z_risingTransition[iCap];} +double lookTable_BUF_X4_A_Z_risingTransition(int iTr, int iCap) {return table_BUF_X4_A_Z_risingTransition[iCap][iTr];} + +double trAxis_BUF_X4_A_Z_fallingTransition[8] = {7.5e-12, 1.5e-11, 3.0e-11, 6.0e-11, 1.2e-10, 2.4e-10, 4.8e-10, 9.6e-10}; +double capAxis_BUF_X4_A_Z_fallingTransition[6] = {4.0e-16, 3.2e-15, 6.4e-15, 1.28e-14, 2.56e-14, 5.12e-14}; +double table_BUF_X4_A_Z_fallingTransition[6][8] = {{8.7e-12, 8.7e-12, 8.7e-12, 9.900000000000001e-12, 1.32e-11, 1.79e-11, 2.52e-11, 3.7600000000000005e-11}, {1.2200000000000002e-11, 1.2200000000000002e-11, 1.2200000000000002e-11, 1.3100000000000002e-11, 1.6400000000000003e-11, 2.13e-11, 2.88e-11, 4.1500000000000005e-11}, {1.59e-11, 1.59e-11, 1.59e-11, 1.65e-11, 1.97e-11, 2.4700000000000003e-11, 3.2500000000000004e-11, 4.57e-11}, {2.2900000000000003e-11, 2.2900000000000003e-11, 2.2900000000000003e-11, 2.3300000000000003e-11, 2.6100000000000002e-11, 3.0900000000000004e-11, 3.9e-11, 5.31e-11}, {3.6800000000000005e-11, 3.6800000000000005e-11, 3.6800000000000005e-11, 3.7e-11, 3.8800000000000004e-11, 4.3e-11, 5.08e-11, 6.59e-11}, {6.610000000000001e-11, 6.62e-11, 6.610000000000001e-11, 6.62e-11, 6.68e-11, 6.930000000000001e-11, 7.49e-11, 8.920000000000001e-11}}; +double lookTrAxis_BUF_X4_A_Z_fallingTransition(int iTr) {return trAxis_BUF_X4_A_Z_fallingTransition[iTr];} +double lookCapAxis_BUF_X4_A_Z_fallingTransition(int iCap) {return capAxis_BUF_X4_A_Z_fallingTransition[iCap];} +double lookTable_BUF_X4_A_Z_fallingTransition(int iTr, int iCap) {return table_BUF_X4_A_Z_fallingTransition[iCap][iTr];} + +double trAxis_BUF_X8_A_Z_risingDelay[8] = {7.5e-12, 1.5e-11, 3.0e-11, 6.0e-11, 1.2e-10, 2.4e-10, 4.8e-10, 9.6e-10}; +double capAxis_BUF_X8_A_Z_risingDelay[6] = {4.0e-16, 6.4e-15, 1.28e-14, 2.56e-14, 5.12e-14, 1.024e-13}; +double table_BUF_X8_A_Z_risingDelay[6][8] = {{4.100000000000001e-11, 4.44e-11, 5.13e-11, 6.270000000000001e-11, 7.530000000000001e-11, 8.65e-11, 9.09e-11, 7.520000000000001e-11}, {5.1800000000000005e-11, 5.52e-11, 6.2e-11, 7.38e-11, 8.75e-11, 1.003e-10, 1.0630000000000001e-10, 9.220000000000002e-11}, {6.160000000000001e-11, 6.500000000000001e-11, 7.19e-11, 8.36e-11, 9.79e-11, 1.121e-10, 1.2e-10, 1.08e-10}, {7.99e-11, 8.33e-11, 9.01e-11, 1.0170000000000001e-10, 1.163e-10, 1.3170000000000002e-10, 1.4290000000000002e-10, 1.3550000000000002e-10}, {1.1590000000000001e-10, 1.192e-10, 1.2590000000000003e-10, 1.374e-10, 1.5160000000000002e-10, 1.6690000000000001e-10, 1.8e-10, 1.7940000000000002e-10}, {1.876e-10, 1.908e-10, 1.974e-10, 2.0880000000000002e-10, 2.2280000000000002e-10, 2.3740000000000003e-10, 2.5e-10, 2.5180000000000005e-10}}; +double lookTrAxis_BUF_X8_A_Z_risingDelay(int iTr) {return trAxis_BUF_X8_A_Z_risingDelay[iTr];} +double lookCapAxis_BUF_X8_A_Z_risingDelay(int iCap) {return capAxis_BUF_X8_A_Z_risingDelay[iCap];} +double lookTable_BUF_X8_A_Z_risingDelay(int iTr, int iCap) {return table_BUF_X8_A_Z_risingDelay[iCap][iTr];} + +double trAxis_BUF_X8_A_Z_fallingDelay[8] = {7.5e-12, 1.5e-11, 3.0e-11, 6.0e-11, 1.2e-10, 2.4e-10, 4.8e-10, 9.6e-10}; +double capAxis_BUF_X8_A_Z_fallingDelay[6] = {4.0e-16, 6.4e-15, 1.28e-14, 2.56e-14, 5.12e-14, 1.024e-13}; +double table_BUF_X8_A_Z_fallingDelay[6][8] = {{5.990000000000001e-11, 6.370000000000001e-11, 7.16e-11, 8.8e-11, 1.161e-10, 1.5490000000000003e-10, 2.1140000000000001e-10, 3.001e-10}, {6.92e-11, 7.3e-11, 8.080000000000001e-11, 9.72e-11, 1.2590000000000003e-10, 1.6600000000000002e-10, 2.239e-10, 3.1410000000000003e-10}, {7.7e-11, 8.07e-11, 8.860000000000001e-11, 1.051e-10, 1.3430000000000002e-10, 1.7530000000000003e-10, 2.345e-10, 3.2640000000000003e-10}, {9.0e-11, 9.370000000000001e-11, 1.0170000000000001e-10, 1.18e-10, 1.479e-10, 1.906e-10, 2.521e-10, 3.47e-10}, {1.118e-10, 1.1550000000000001e-10, 1.2350000000000001e-10, 1.3980000000000002e-10, 1.699e-10, 2.148e-10, 2.7960000000000005e-10, 3.797e-10}, {1.5e-10, 1.538e-10, 1.618e-10, 1.78e-10, 2.081e-10, 2.5460000000000003e-10, 3.228e-10, 4.2990000000000004e-10}}; +double lookTrAxis_BUF_X8_A_Z_fallingDelay(int iTr) {return trAxis_BUF_X8_A_Z_fallingDelay[iTr];} +double lookCapAxis_BUF_X8_A_Z_fallingDelay(int iCap) {return capAxis_BUF_X8_A_Z_fallingDelay[iCap];} +double lookTable_BUF_X8_A_Z_fallingDelay(int iTr, int iCap) {return table_BUF_X8_A_Z_fallingDelay[iCap][iTr];} + +double trAxis_BUF_X8_A_Z_risingTransition[8] = {7.5e-12, 1.5e-11, 3.0e-11, 6.0e-11, 1.2e-10, 2.4e-10, 4.8e-10, 9.6e-10}; +double capAxis_BUF_X8_A_Z_risingTransition[6] = {4.0e-16, 6.4e-15, 1.28e-14, 2.56e-14, 5.12e-14, 1.024e-13}; +double table_BUF_X8_A_Z_risingTransition[6][8] = {{1.0400000000000001e-11, 1.0400000000000001e-11, 1.0400000000000001e-11, 1.18e-11, 1.4800000000000003e-11, 1.9600000000000002e-11, 2.8100000000000002e-11, 4.3100000000000005e-11}, {1.74e-11, 1.74e-11, 1.74e-11, 1.83e-11, 2.1100000000000003e-11, 2.6300000000000002e-11, 3.48e-11, 4.92e-11}, {2.5000000000000004e-11, 2.5000000000000004e-11, 2.5100000000000003e-11, 2.5600000000000004e-11, 2.7700000000000002e-11, 3.2500000000000004e-11, 4.18e-11, 5.680000000000001e-11}, {4.11e-11, 4.1200000000000004e-11, 4.11e-11, 4.130000000000001e-11, 4.2400000000000004e-11, 4.5500000000000004e-11, 5.390000000000001e-11, 7.08e-11}, {7.480000000000002e-11, 7.470000000000001e-11, 7.480000000000002e-11, 7.480000000000002e-11, 7.5e-11, 7.600000000000001e-11, 8.04e-11, 9.48e-11}, {1.427e-10, 1.427e-10, 1.427e-10, 1.427e-10, 1.427e-10, 1.4290000000000002e-10, 1.4440000000000001e-10, 1.51e-10}}; +double lookTrAxis_BUF_X8_A_Z_risingTransition(int iTr) {return trAxis_BUF_X8_A_Z_risingTransition[iTr];} +double lookCapAxis_BUF_X8_A_Z_risingTransition(int iCap) {return capAxis_BUF_X8_A_Z_risingTransition[iCap];} +double lookTable_BUF_X8_A_Z_risingTransition(int iTr, int iCap) {return table_BUF_X8_A_Z_risingTransition[iCap][iTr];} + +double trAxis_BUF_X8_A_Z_fallingTransition[8] = {7.5e-12, 1.5e-11, 3.0e-11, 6.0e-11, 1.2e-10, 2.4e-10, 4.8e-10, 9.6e-10}; +double capAxis_BUF_X8_A_Z_fallingTransition[6] = {4.0e-16, 6.4e-15, 1.28e-14, 2.56e-14, 5.12e-14, 1.024e-13}; +double table_BUF_X8_A_Z_fallingTransition[6][8] = {{1.3400000000000002e-11, 1.3400000000000002e-11, 1.3400000000000002e-11, 1.36e-11, 1.7500000000000004e-11, 2.4e-11, 3.34e-11, 4.84e-11}, {1.7200000000000003e-11, 1.7200000000000003e-11, 1.73e-11, 1.74e-11, 2.07e-11, 2.72e-11, 3.66e-11, 5.1700000000000006e-11}, {2.1000000000000002e-11, 2.1100000000000003e-11, 2.1100000000000003e-11, 2.1200000000000002e-11, 2.4e-11, 3.05e-11, 4.01e-11, 5.5400000000000004e-11}, {2.82e-11, 2.82e-11, 2.8100000000000002e-11, 2.8300000000000002e-11, 3.04e-11, 3.6700000000000006e-11, 4.64e-11, 6.230000000000001e-11}, {4.1900000000000005e-11, 4.1900000000000005e-11, 4.1900000000000005e-11, 4.2000000000000004e-11, 4.3200000000000003e-11, 4.880000000000001e-11, 5.8000000000000007e-11, 7.46e-11}, {7.02e-11, 7.01e-11, 7.02e-11, 7.02e-11, 7.07e-11, 7.410000000000001e-11, 8.13e-11, 9.690000000000001e-11}}; +double lookTrAxis_BUF_X8_A_Z_fallingTransition(int iTr) {return trAxis_BUF_X8_A_Z_fallingTransition[iTr];} +double lookCapAxis_BUF_X8_A_Z_fallingTransition(int iCap) {return capAxis_BUF_X8_A_Z_fallingTransition[iCap];} +double lookTable_BUF_X8_A_Z_fallingTransition(int iTr, int iCap) {return table_BUF_X8_A_Z_fallingTransition[iCap][iTr];} + +double trAxis_FA_X1_A_CO_risingDelay[8] = {7.5e-12, 1.5e-11, 3.0e-11, 6.0e-11, 1.2e-10, 2.4e-10, 4.8e-10, 9.6e-10}; +double capAxis_FA_X1_A_CO_risingDelay[6] = {4.0e-16, 8.0e-16, 1.6e-15, 3.2e-15, 6.4e-15, 1.28e-14}; +double table_FA_X1_A_CO_risingDelay[6][8] = {{8.02e-11, 8.320000000000001e-11, 8.94e-11, 1.025e-10, 1.224e-10, 1.437e-10, 1.6020000000000003e-10, 1.587e-10}, {8.58e-11, 8.88e-11, 9.500000000000001e-11, 1.08e-10, 1.281e-10, 1.498e-10, 1.672e-10, 1.671e-10}, {9.65e-11, 9.95e-11, 1.0570000000000001e-10, 1.185e-10, 1.387e-10, 1.611e-10, 1.7990000000000002e-10, 1.822e-10}, {1.169e-10, 1.1990000000000002e-10, 1.261e-10, 1.385e-10, 1.5890000000000001e-10, 1.815e-10, 2.0180000000000002e-10, 2.0820000000000002e-10}, {1.558e-10, 1.587e-10, 1.6470000000000004e-10, 1.77e-10, 1.973e-10, 2.201e-10, 2.411e-10, 2.5080000000000005e-10}, {2.3200000000000003e-10, 2.3490000000000004e-10, 2.41e-10, 2.532e-10, 2.732e-10, 2.958e-10, 3.166e-10, 3.2740000000000003e-10}}; +double lookTrAxis_FA_X1_A_CO_risingDelay(int iTr) {return trAxis_FA_X1_A_CO_risingDelay[iTr];} +double lookCapAxis_FA_X1_A_CO_risingDelay(int iCap) {return capAxis_FA_X1_A_CO_risingDelay[iCap];} +double lookTable_FA_X1_A_CO_risingDelay(int iTr, int iCap) {return table_FA_X1_A_CO_risingDelay[iCap][iTr];} + +double trAxis_FA_X1_A_CO_fallingDelay[8] = {7.5e-12, 1.5e-11, 3.0e-11, 6.0e-11, 1.2e-10, 2.4e-10, 4.8e-10, 9.6e-10}; +double capAxis_FA_X1_A_CO_fallingDelay[6] = {4.0e-16, 8.0e-16, 1.6e-15, 3.2e-15, 6.4e-15, 1.28e-14}; +double table_FA_X1_A_CO_fallingDelay[6][8] = {{1.277e-10, 1.3050000000000001e-10, 1.368e-10, 1.5060000000000003e-10, 1.803e-10, 2.339e-10, 3.1230000000000005e-10, 4.3380000000000004e-10}, {1.3270000000000002e-10, 1.3550000000000002e-10, 1.4180000000000002e-10, 1.556e-10, 1.853e-10, 2.3930000000000004e-10, 3.1840000000000006e-10, 4.4090000000000005e-10}, {1.417e-10, 1.445e-10, 1.5060000000000003e-10, 1.644e-10, 1.9450000000000003e-10, 2.49e-10, 3.2900000000000005e-10, 4.5330000000000003e-10}, {1.5740000000000002e-10, 1.601e-10, 1.663e-10, 1.8e-10, 2.0990000000000002e-10, 2.653e-10, 3.4770000000000005e-10, 4.746000000000001e-10}, {1.8390000000000003e-10, 1.866e-10, 1.9270000000000002e-10, 2.065e-10, 2.36e-10, 2.923e-10, 3.772e-10, 5.085e-10}, {2.2910000000000002e-10, 2.317e-10, 2.3780000000000005e-10, 2.5140000000000003e-10, 2.809e-10, 3.3760000000000005e-10, 4.2520000000000004e-10, 5.613e-10}}; +double lookTrAxis_FA_X1_A_CO_fallingDelay(int iTr) {return trAxis_FA_X1_A_CO_fallingDelay[iTr];} +double lookCapAxis_FA_X1_A_CO_fallingDelay(int iCap) {return capAxis_FA_X1_A_CO_fallingDelay[iCap];} +double lookTable_FA_X1_A_CO_fallingDelay(int iTr, int iCap) {return table_FA_X1_A_CO_fallingDelay[iCap][iTr];} + +double trAxis_FA_X1_A_CO_risingTransition[8] = {7.5e-12, 1.5e-11, 3.0e-11, 6.0e-11, 1.2e-10, 2.4e-10, 4.8e-10, 9.6e-10}; +double capAxis_FA_X1_A_CO_risingTransition[6] = {4.0e-16, 8.0e-16, 1.6e-15, 3.2e-15, 6.4e-15, 1.28e-14}; +double table_FA_X1_A_CO_risingTransition[6][8] = {{2.5300000000000002e-11, 2.52e-11, 2.5100000000000003e-11, 2.52e-11, 2.66e-11, 2.8600000000000003e-11, 3.46e-11, 4.4e-11}, {2.93e-11, 2.92e-11, 2.9100000000000002e-11, 2.92e-11, 3.07e-11, 3.3e-11, 3.8300000000000006e-11, 4.84e-11}, {3.740000000000001e-11, 3.73e-11, 3.72e-11, 3.740000000000001e-11, 3.87e-11, 4.14e-11, 4.610000000000001e-11, 5.64e-11}, {5.4100000000000006e-11, 5.4100000000000006e-11, 5.4100000000000006e-11, 5.390000000000001e-11, 5.49e-11, 5.7400000000000003e-11, 6.270000000000001e-11, 7.240000000000002e-11}, {8.9e-11, 8.890000000000001e-11, 8.890000000000001e-11, 8.88e-11, 8.88e-11, 9.020000000000001e-11, 9.460000000000001e-11, 1.043e-10}, {1.601e-10, 1.6000000000000002e-10, 1.6000000000000002e-10, 1.6000000000000002e-10, 1.598e-10, 1.6000000000000002e-10, 1.6170000000000002e-10, 1.692e-10}}; +double lookTrAxis_FA_X1_A_CO_risingTransition(int iTr) {return trAxis_FA_X1_A_CO_risingTransition[iTr];} +double lookCapAxis_FA_X1_A_CO_risingTransition(int iCap) {return capAxis_FA_X1_A_CO_risingTransition[iCap];} +double lookTable_FA_X1_A_CO_risingTransition(int iTr, int iCap) {return table_FA_X1_A_CO_risingTransition[iCap][iTr];} + +double trAxis_FA_X1_A_CO_fallingTransition[8] = {7.5e-12, 1.5e-11, 3.0e-11, 6.0e-11, 1.2e-10, 2.4e-10, 4.8e-10, 9.6e-10}; +double capAxis_FA_X1_A_CO_fallingTransition[6] = {4.0e-16, 8.0e-16, 1.6e-15, 3.2e-15, 6.4e-15, 1.28e-14}; +double table_FA_X1_A_CO_fallingTransition[6][8] = {{2.3800000000000004e-11, 2.37e-11, 2.37e-11, 2.36e-11, 2.37e-11, 2.7300000000000002e-11, 3.39e-11, 4.3200000000000003e-11}, {2.6300000000000002e-11, 2.6300000000000002e-11, 2.6200000000000004e-11, 2.5900000000000002e-11, 2.6100000000000002e-11, 2.95e-11, 3.6100000000000003e-11, 4.57e-11}, {3.19e-11, 3.19e-11, 3.18e-11, 3.1399999999999996e-11, 3.1300000000000004e-11, 3.36e-11, 4.0400000000000004e-11, 5.0200000000000005e-11}, {4.1900000000000005e-11, 4.18e-11, 4.1600000000000004e-11, 4.11e-11, 4.0800000000000004e-11, 4.250000000000001e-11, 4.81e-11, 5.8200000000000003e-11}, {5.85e-11, 5.85e-11, 5.83e-11, 5.7800000000000003e-11, 5.750000000000001e-11, 6.04e-11, 6.38e-11, 7.25e-11}, {8.830000000000001e-11, 8.830000000000001e-11, 8.81e-11, 8.790000000000001e-11, 8.76e-11, 9.09e-11, 9.660000000000001e-11, 1.05e-10}}; +double lookTrAxis_FA_X1_A_CO_fallingTransition(int iTr) {return trAxis_FA_X1_A_CO_fallingTransition[iTr];} +double lookCapAxis_FA_X1_A_CO_fallingTransition(int iCap) {return capAxis_FA_X1_A_CO_fallingTransition[iCap];} +double lookTable_FA_X1_A_CO_fallingTransition(int iTr, int iCap) {return table_FA_X1_A_CO_fallingTransition[iCap][iTr];} + +double trAxis_FA_X1_A_S_risingDelay[8] = {7.5e-12, 1.5e-11, 3.0e-11, 6.0e-11, 1.2e-10, 2.4e-10, 4.8e-10, 9.6e-10}; +double capAxis_FA_X1_A_S_risingDelay[6] = {4.0e-16, 8.0e-16, 1.6e-15, 3.2e-15, 6.4e-15, 1.28e-14}; +double table_FA_X1_A_S_risingDelay[6][8] = {{1.8850000000000002e-10, 1.9120000000000002e-10, 1.982e-10, 2.11e-10, 2.405e-10, 2.966e-10, 3.811e-10, 5.113e-10}, {1.9620000000000003e-10, 1.989e-10, 2.0510000000000002e-10, 2.1870000000000003e-10, 2.4820000000000003e-10, 3.043e-10, 3.8910000000000003e-10, 5.195999999999999e-10}, {2.09e-10, 2.117e-10, 2.1780000000000001e-10, 2.3150000000000003e-10, 2.613e-10, 3.171e-10, 4.018e-10, 5.33e-10}, {2.309e-10, 2.336e-10, 2.397e-10, 2.534e-10, 2.8310000000000004e-10, 3.3920000000000003e-10, 4.2400000000000004e-10, 5.55e-10}, {2.7000000000000005e-10, 2.727e-10, 2.788e-10, 2.9260000000000005e-10, 3.221e-10, 3.782e-10, 4.629e-10, 5.942e-10}, {3.4530000000000004e-10, 3.48e-10, 3.5410000000000005e-10, 3.6780000000000006e-10, 3.975e-10, 4.5330000000000003e-10, 5.379000000000001e-10, 6.689000000000001e-10}}; +double lookTrAxis_FA_X1_A_S_risingDelay(int iTr) {return trAxis_FA_X1_A_S_risingDelay[iTr];} +double lookCapAxis_FA_X1_A_S_risingDelay(int iCap) {return capAxis_FA_X1_A_S_risingDelay[iCap];} +double lookTable_FA_X1_A_S_risingDelay(int iTr, int iCap) {return table_FA_X1_A_S_risingDelay[iCap][iTr];} + +double trAxis_FA_X1_A_S_fallingDelay[8] = {7.5e-12, 1.5e-11, 3.0e-11, 6.0e-11, 1.2e-10, 2.4e-10, 4.8e-10, 9.6e-10}; +double capAxis_FA_X1_A_S_fallingDelay[6] = {4.0e-16, 8.0e-16, 1.6e-15, 3.2e-15, 6.4e-15, 1.28e-14}; +double table_FA_X1_A_S_fallingDelay[6][8] = {{1.812e-10, 1.8490000000000003e-10, 1.914e-10, 2.027e-10, 2.22e-10, 2.542e-10, 3.177e-10, 4.3840000000000006e-10}, {1.8800000000000002e-10, 1.9160000000000002e-10, 1.9810000000000002e-10, 2.095e-10, 2.2880000000000003e-10, 2.611e-10, 3.25e-10, 4.4650000000000006e-10}, {1.9950000000000003e-10, 2.0310000000000003e-10, 2.097e-10, 2.2110000000000002e-10, 2.404e-10, 2.726e-10, 3.37e-10, 4.604e-10}, {2.182e-10, 2.218e-10, 2.285e-10, 2.399e-10, 2.592e-10, 2.919e-10, 3.566e-10, 4.821e-10}, {2.488e-10, 2.5230000000000005e-10, 2.5890000000000006e-10, 2.7039999999999997e-10, 2.898e-10, 3.2290000000000004e-10, 3.877e-10, 5.166e-10}, {2.9880000000000004e-10, 3.0230000000000003e-10, 3.0890000000000004e-10, 3.2040000000000005e-10, 3.398e-10, 3.7310000000000004e-10, 4.3780000000000003e-10, 5.708e-10}}; +double lookTrAxis_FA_X1_A_S_fallingDelay(int iTr) {return trAxis_FA_X1_A_S_fallingDelay[iTr];} +double lookCapAxis_FA_X1_A_S_fallingDelay(int iCap) {return capAxis_FA_X1_A_S_fallingDelay[iCap];} +double lookTable_FA_X1_A_S_fallingDelay(int iTr, int iCap) {return table_FA_X1_A_S_fallingDelay[iCap][iTr];} + +double trAxis_FA_X1_A_S_risingTransition[8] = {7.5e-12, 1.5e-11, 3.0e-11, 6.0e-11, 1.2e-10, 2.4e-10, 4.8e-10, 9.6e-10}; +double capAxis_FA_X1_A_S_risingTransition[6] = {4.0e-16, 8.0e-16, 1.6e-15, 3.2e-15, 6.4e-15, 1.28e-14}; +double table_FA_X1_A_S_risingTransition[6][8] = {{2.25e-11, 2.25e-11, 2.25e-11, 2.24e-11, 2.24e-11, 2.28e-11, 2.4700000000000003e-11, 3.11e-11}, {2.6200000000000004e-11, 2.6200000000000004e-11, 2.6100000000000002e-11, 2.6100000000000002e-11, 2.6100000000000002e-11, 2.6500000000000002e-11, 2.94e-11, 3.65e-11}, {3.3200000000000006e-11, 3.3200000000000006e-11, 3.3200000000000006e-11, 3.3200000000000006e-11, 3.3200000000000006e-11, 3.34e-11, 3.7600000000000005e-11, 4.5800000000000006e-11}, {4.84e-11, 4.84e-11, 4.84e-11, 4.84e-11, 4.8300000000000004e-11, 4.96e-11, 5.2900000000000006e-11, 6.14e-11}, {8.21e-11, 8.21e-11, 8.21e-11, 8.21e-11, 8.22e-11, 8.29e-11, 8.490000000000001e-11, 9.100000000000001e-11}, {1.522e-10, 1.522e-10, 1.523e-10, 1.522e-10, 1.522e-10, 1.5250000000000002e-10, 1.534e-10, 1.57e-10}}; +double lookTrAxis_FA_X1_A_S_risingTransition(int iTr) {return trAxis_FA_X1_A_S_risingTransition[iTr];} +double lookCapAxis_FA_X1_A_S_risingTransition(int iCap) {return capAxis_FA_X1_A_S_risingTransition[iCap];} +double lookTable_FA_X1_A_S_risingTransition(int iTr, int iCap) {return table_FA_X1_A_S_risingTransition[iCap][iTr];} + +double trAxis_FA_X1_A_S_fallingTransition[8] = {7.5e-12, 1.5e-11, 3.0e-11, 6.0e-11, 1.2e-10, 2.4e-10, 4.8e-10, 9.6e-10}; +double capAxis_FA_X1_A_S_fallingTransition[6] = {4.0e-16, 8.0e-16, 1.6e-15, 3.2e-15, 6.4e-15, 1.28e-14}; +double table_FA_X1_A_S_fallingTransition[6][8] = {{2.25e-11, 2.25e-11, 2.25e-11, 2.25e-11, 2.25e-11, 2.3800000000000004e-11, 2.72e-11, 3.3e-11}, {2.52e-11, 2.52e-11, 2.52e-11, 2.52e-11, 2.52e-11, 2.66e-11, 3.01e-11, 3.6e-11}, {3.05e-11, 3.05e-11, 3.05e-11, 3.05e-11, 3.05e-11, 3.17e-11, 3.5300000000000003e-11, 4.14e-11}, {4.29e-11, 4.29e-11, 4.29e-11, 4.29e-11, 4.2800000000000003e-11, 4.2800000000000003e-11, 4.48e-11, 5.120000000000001e-11}, {6.25e-11, 6.25e-11, 6.25e-11, 6.25e-11, 6.25e-11, 6.25e-11, 6.270000000000001e-11, 6.86e-11}, {9.17e-11, 9.17e-11, 9.17e-11, 9.17e-11, 9.17e-11, 9.17e-11, 9.180000000000001e-11, 9.92e-11}}; +double lookTrAxis_FA_X1_A_S_fallingTransition(int iTr) {return trAxis_FA_X1_A_S_fallingTransition[iTr];} +double lookCapAxis_FA_X1_A_S_fallingTransition(int iCap) {return capAxis_FA_X1_A_S_fallingTransition[iCap];} +double lookTable_FA_X1_A_S_fallingTransition(int iTr, int iCap) {return table_FA_X1_A_S_fallingTransition[iCap][iTr];} + +double trAxis_FA_X1_B_CO_risingDelay[8] = {7.5e-12, 1.5e-11, 3.0e-11, 6.0e-11, 1.2e-10, 2.4e-10, 4.8e-10, 9.6e-10}; +double capAxis_FA_X1_B_CO_risingDelay[6] = {4.0e-16, 8.0e-16, 1.6e-15, 3.2e-15, 6.4e-15, 1.28e-14}; +double table_FA_X1_B_CO_risingDelay[6][8] = {{8.540000000000001e-11, 8.860000000000001e-11, 9.400000000000001e-11, 1.038e-10, 1.1890000000000002e-10, 1.364e-10, 1.497e-10, 1.4680000000000003e-10}, {9.100000000000001e-11, 9.420000000000001e-11, 9.96e-11, 1.093e-10, 1.2460000000000001e-10, 1.4240000000000002e-10, 1.563e-10, 1.546e-10}, {1.0150000000000001e-10, 1.0480000000000002e-10, 1.1020000000000002e-10, 1.1990000000000002e-10, 1.3530000000000001e-10, 1.536e-10, 1.684e-10, 1.685e-10}, {1.217e-10, 1.248e-10, 1.3050000000000001e-10, 1.399e-10, 1.555e-10, 1.7410000000000002e-10, 1.9000000000000002e-10, 1.93e-10}, {1.601e-10, 1.6330000000000002e-10, 1.69e-10, 1.783e-10, 1.939e-10, 2.129e-10, 2.2960000000000001e-10, 2.343e-10}, {2.3610000000000004e-10, 2.3930000000000004e-10, 2.4500000000000003e-10, 2.5430000000000004e-10, 2.698e-10, 2.8870000000000005e-10, 3.0550000000000003e-10, 3.111e-10}}; +double lookTrAxis_FA_X1_B_CO_risingDelay(int iTr) {return trAxis_FA_X1_B_CO_risingDelay[iTr];} +double lookCapAxis_FA_X1_B_CO_risingDelay(int iCap) {return capAxis_FA_X1_B_CO_risingDelay[iCap];} +double lookTable_FA_X1_B_CO_risingDelay(int iTr, int iCap) {return table_FA_X1_B_CO_risingDelay[iCap][iTr];} + +double trAxis_FA_X1_B_CO_fallingDelay[8] = {7.5e-12, 1.5e-11, 3.0e-11, 6.0e-11, 1.2e-10, 2.4e-10, 4.8e-10, 9.6e-10}; +double capAxis_FA_X1_B_CO_fallingDelay[6] = {4.0e-16, 8.0e-16, 1.6e-15, 3.2e-15, 6.4e-15, 1.28e-14}; +double table_FA_X1_B_CO_fallingDelay[6][8] = {{1.3800000000000001e-10, 1.417e-10, 1.483e-10, 1.603e-10, 1.838e-10, 2.2600000000000002e-10, 2.9440000000000004e-10, 4.0630000000000003e-10}, {1.43e-10, 1.467e-10, 1.533e-10, 1.6530000000000001e-10, 1.8870000000000003e-10, 2.3130000000000002e-10, 3.0020000000000006e-10, 4.128e-10}, {1.5200000000000002e-10, 1.556e-10, 1.623e-10, 1.7430000000000003e-10, 1.9800000000000001e-10, 2.409e-10, 3.1030000000000006e-10, 4.239e-10}, {1.6760000000000002e-10, 1.711e-10, 1.779e-10, 1.8990000000000004e-10, 2.134e-10, 2.571e-10, 3.2810000000000004e-10, 4.44e-10}, {1.941e-10, 1.9760000000000002e-10, 2.0430000000000003e-10, 2.1640000000000002e-10, 2.397e-10, 2.8410000000000003e-10, 3.5690000000000003e-10, 4.759e-10}, {2.3930000000000004e-10, 2.427e-10, 2.4940000000000004e-10, 2.6150000000000003e-10, 2.8480000000000004e-10, 3.2960000000000003e-10, 4.0460000000000003e-10, 5.275e-10}}; +double lookTrAxis_FA_X1_B_CO_fallingDelay(int iTr) {return trAxis_FA_X1_B_CO_fallingDelay[iTr];} +double lookCapAxis_FA_X1_B_CO_fallingDelay(int iCap) {return capAxis_FA_X1_B_CO_fallingDelay[iCap];} +double lookTable_FA_X1_B_CO_fallingDelay(int iTr, int iCap) {return table_FA_X1_B_CO_fallingDelay[iCap][iTr];} + +double trAxis_FA_X1_B_CO_risingTransition[8] = {7.5e-12, 1.5e-11, 3.0e-11, 6.0e-11, 1.2e-10, 2.4e-10, 4.8e-10, 9.6e-10}; +double capAxis_FA_X1_B_CO_risingTransition[6] = {4.0e-16, 8.0e-16, 1.6e-15, 3.2e-15, 6.4e-15, 1.28e-14}; +double table_FA_X1_B_CO_risingTransition[6][8] = {{2.46e-11, 2.46e-11, 2.46e-11, 2.4500000000000003e-11, 2.52e-11, 2.7500000000000002e-11, 3.27e-11, 4.0800000000000004e-11}, {2.8700000000000002e-11, 2.8700000000000002e-11, 2.8600000000000003e-11, 2.8600000000000003e-11, 2.92e-11, 3.1399999999999996e-11, 3.65e-11, 4.53e-11}, {3.7100000000000006e-11, 3.7e-11, 3.7e-11, 3.69e-11, 3.73e-11, 3.9100000000000006e-11, 4.3900000000000005e-11, 5.3400000000000004e-11}, {5.4100000000000006e-11, 5.4100000000000006e-11, 5.4e-11, 5.4e-11, 5.4e-11, 5.52e-11, 5.89e-11, 6.81e-11}, {8.890000000000001e-11, 8.890000000000001e-11, 8.890000000000001e-11, 8.890000000000001e-11, 8.88e-11, 8.920000000000001e-11, 9.12e-11, 9.750000000000001e-11}, {1.6000000000000002e-10, 1.6000000000000002e-10, 1.601e-10, 1.601e-10, 1.6000000000000002e-10, 1.5989999999999999e-10, 1.606e-10, 1.6370000000000001e-10}}; +double lookTrAxis_FA_X1_B_CO_risingTransition(int iTr) {return trAxis_FA_X1_B_CO_risingTransition[iTr];} +double lookCapAxis_FA_X1_B_CO_risingTransition(int iCap) {return capAxis_FA_X1_B_CO_risingTransition[iCap];} +double lookTable_FA_X1_B_CO_risingTransition(int iTr, int iCap) {return table_FA_X1_B_CO_risingTransition[iCap][iTr];} + +double trAxis_FA_X1_B_CO_fallingTransition[8] = {7.5e-12, 1.5e-11, 3.0e-11, 6.0e-11, 1.2e-10, 2.4e-10, 4.8e-10, 9.6e-10}; +double capAxis_FA_X1_B_CO_fallingTransition[6] = {4.0e-16, 8.0e-16, 1.6e-15, 3.2e-15, 6.4e-15, 1.28e-14}; +double table_FA_X1_B_CO_fallingTransition[6][8] = {{2.37e-11, 2.37e-11, 2.37e-11, 2.37e-11, 2.37e-11, 2.6200000000000004e-11, 3.04e-11, 3.72e-11}, {2.6100000000000002e-11, 2.6e-11, 2.6e-11, 2.6e-11, 2.6e-11, 2.8500000000000002e-11, 3.2800000000000006e-11, 3.97e-11}, {3.06e-11, 3.05e-11, 3.05e-11, 3.05e-11, 3.05e-11, 3.27e-11, 3.72e-11, 4.45e-11}, {3.9e-11, 3.89e-11, 3.89e-11, 3.89e-11, 3.8800000000000004e-11, 4.09e-11, 4.56e-11, 5.3400000000000004e-11}, {5.4200000000000004e-11, 5.4200000000000004e-11, 5.4200000000000004e-11, 5.4100000000000006e-11, 5.4e-11, 5.5800000000000004e-11, 6.1e-11, 6.95e-11}, {8.39e-11, 8.39e-11, 8.39e-11, 8.39e-11, 8.380000000000001e-11, 8.480000000000001e-11, 8.96e-11, 9.810000000000002e-11}}; +double lookTrAxis_FA_X1_B_CO_fallingTransition(int iTr) {return trAxis_FA_X1_B_CO_fallingTransition[iTr];} +double lookCapAxis_FA_X1_B_CO_fallingTransition(int iCap) {return capAxis_FA_X1_B_CO_fallingTransition[iCap];} +double lookTable_FA_X1_B_CO_fallingTransition(int iTr, int iCap) {return table_FA_X1_B_CO_fallingTransition[iCap][iTr];} + +double trAxis_FA_X1_B_S_risingDelay[8] = {7.5e-12, 1.5e-11, 3.0e-11, 6.0e-11, 1.2e-10, 2.4e-10, 4.8e-10, 9.6e-10}; +double capAxis_FA_X1_B_S_risingDelay[6] = {4.0e-16, 8.0e-16, 1.6e-15, 3.2e-15, 6.4e-15, 1.28e-14}; +double table_FA_X1_B_S_risingDelay[6][8] = {{2.128e-10, 2.167e-10, 2.2370000000000001e-10, 2.3590000000000003e-10, 2.583e-10, 2.991e-10, 3.671e-10, 4.816e-10}, {2.196e-10, 2.234e-10, 2.3050000000000003e-10, 2.426e-10, 2.65e-10, 3.058e-10, 3.7380000000000004e-10, 4.884e-10}, {2.314e-10, 2.353e-10, 2.424e-10, 2.545e-10, 2.769e-10, 3.1780000000000003e-10, 3.857e-10, 4.998000000000001e-10}, {2.5290000000000003e-10, 2.566e-10, 2.6370000000000003e-10, 2.7600000000000003e-10, 2.9830000000000005e-10, 3.389e-10, 4.069e-10, 5.219e-10}, {2.9220000000000004e-10, 2.9590000000000003e-10, 3.0280000000000003e-10, 3.154e-10, 3.378e-10, 3.781e-10, 4.458e-10, 5.610000000000001e-10}, {3.6830000000000006e-10, 3.721e-10, 3.7900000000000004e-10, 3.9150000000000004e-10, 4.1390000000000004e-10, 4.5420000000000004e-10, 5.217000000000001e-10, 6.363000000000001e-10}}; +double lookTrAxis_FA_X1_B_S_risingDelay(int iTr) {return trAxis_FA_X1_B_S_risingDelay[iTr];} +double lookCapAxis_FA_X1_B_S_risingDelay(int iCap) {return capAxis_FA_X1_B_S_risingDelay[iCap];} +double lookTable_FA_X1_B_S_risingDelay(int iTr, int iCap) {return table_FA_X1_B_S_risingDelay[iCap][iTr];} + +double trAxis_FA_X1_B_S_fallingDelay[8] = {7.5e-12, 1.5e-11, 3.0e-11, 6.0e-11, 1.2e-10, 2.4e-10, 4.8e-10, 9.6e-10}; +double capAxis_FA_X1_B_S_fallingDelay[6] = {4.0e-16, 8.0e-16, 1.6e-15, 3.2e-15, 6.4e-15, 1.28e-14}; +double table_FA_X1_B_S_fallingDelay[6][8] = {{1.79e-10, 1.822e-10, 1.8740000000000002e-10, 1.963e-10, 2.1260000000000002e-10, 2.5530000000000004e-10, 3.277e-10, 4.4910000000000003e-10}, {1.853e-10, 1.8850000000000002e-10, 1.9370000000000001e-10, 2.0250000000000002e-10, 2.194e-10, 2.622e-10, 3.353e-10, 4.5770000000000003e-10}, {1.958e-10, 1.9910000000000002e-10, 2.044e-10, 2.1320000000000002e-10, 2.306e-10, 2.742e-10, 3.485e-10, 4.711000000000001e-10}, {2.133e-10, 2.165e-10, 2.219e-10, 2.3050000000000003e-10, 2.491e-10, 2.9320000000000003e-10, 3.6890000000000004e-10, 4.943e-10}, {2.416e-10, 2.447e-10, 2.5019999999999997e-10, 2.587e-10, 2.7920000000000003e-10, 3.236e-10, 4.0110000000000004e-10, 5.308000000000001e-10}, {2.8830000000000003e-10, 2.914e-10, 2.97e-10, 3.0590000000000005e-10, 3.283e-10, 3.73e-10, 4.5290000000000006e-10, 5.866e-10}}; +double lookTrAxis_FA_X1_B_S_fallingDelay(int iTr) {return trAxis_FA_X1_B_S_fallingDelay[iTr];} +double lookCapAxis_FA_X1_B_S_fallingDelay(int iCap) {return capAxis_FA_X1_B_S_fallingDelay[iCap];} +double lookTable_FA_X1_B_S_fallingDelay(int iTr, int iCap) {return table_FA_X1_B_S_fallingDelay[iCap][iTr];} + +double trAxis_FA_X1_B_S_risingTransition[8] = {7.5e-12, 1.5e-11, 3.0e-11, 6.0e-11, 1.2e-10, 2.4e-10, 4.8e-10, 9.6e-10}; +double capAxis_FA_X1_B_S_risingTransition[6] = {4.0e-16, 8.0e-16, 1.6e-15, 3.2e-15, 6.4e-15, 1.28e-14}; +double table_FA_X1_B_S_risingTransition[6][8] = {{2.22e-11, 2.22e-11, 2.2100000000000003e-11, 2.2100000000000003e-11, 2.2100000000000003e-11, 2.25e-11, 2.55e-11, 3.19e-11}, {2.5900000000000002e-11, 2.5900000000000002e-11, 2.58e-11, 2.58e-11, 2.58e-11, 2.6100000000000002e-11, 3.0e-11, 3.7100000000000006e-11}, {3.3e-11, 3.3e-11, 3.3e-11, 3.3e-11, 3.3e-11, 3.34e-11, 3.7900000000000006e-11, 4.62e-11}, {4.86e-11, 4.86e-11, 4.86e-11, 4.850000000000001e-11, 4.84e-11, 4.9400000000000005e-11, 5.2900000000000006e-11, 6.2e-11}, {8.240000000000001e-11, 8.240000000000001e-11, 8.240000000000001e-11, 8.240000000000001e-11, 8.22e-11, 8.250000000000001e-11, 8.440000000000001e-11, 9.09e-11}, {1.523e-10, 1.524e-10, 1.524e-10, 1.524e-10, 1.523e-10, 1.523e-10, 1.529e-10, 1.5570000000000002e-10}}; +double lookTrAxis_FA_X1_B_S_risingTransition(int iTr) {return trAxis_FA_X1_B_S_risingTransition[iTr];} +double lookCapAxis_FA_X1_B_S_risingTransition(int iCap) {return capAxis_FA_X1_B_S_risingTransition[iCap];} +double lookTable_FA_X1_B_S_risingTransition(int iTr, int iCap) {return table_FA_X1_B_S_risingTransition[iCap][iTr];} + +double trAxis_FA_X1_B_S_fallingTransition[8] = {7.5e-12, 1.5e-11, 3.0e-11, 6.0e-11, 1.2e-10, 2.4e-10, 4.8e-10, 9.6e-10}; +double capAxis_FA_X1_B_S_fallingTransition[6] = {4.0e-16, 8.0e-16, 1.6e-15, 3.2e-15, 6.4e-15, 1.28e-14}; +double table_FA_X1_B_S_fallingTransition[6][8] = {{2.22e-11, 2.22e-11, 2.22e-11, 2.22e-11, 2.22e-11, 2.4e-11, 2.8400000000000003e-11, 3.5200000000000005e-11}, {2.49e-11, 2.49e-11, 2.49e-11, 2.49e-11, 2.49e-11, 2.6700000000000002e-11, 3.12e-11, 3.82e-11}, {3.0e-11, 3.0e-11, 3.0e-11, 3.0e-11, 3.0e-11, 3.1600000000000006e-11, 3.620000000000001e-11, 4.3400000000000007e-11}, {4.23e-11, 4.23e-11, 4.23e-11, 4.23e-11, 4.23e-11, 4.23e-11, 4.52e-11, 5.2600000000000004e-11}, {6.17e-11, 6.17e-11, 6.160000000000001e-11, 6.160000000000001e-11, 6.17e-11, 6.160000000000001e-11, 6.2e-11, 6.87e-11}, {9.11e-11, 9.11e-11, 9.100000000000001e-11, 9.100000000000001e-11, 9.11e-11, 9.09e-11, 9.12e-11, 9.740000000000001e-11}}; +double lookTrAxis_FA_X1_B_S_fallingTransition(int iTr) {return trAxis_FA_X1_B_S_fallingTransition[iTr];} +double lookCapAxis_FA_X1_B_S_fallingTransition(int iCap) {return capAxis_FA_X1_B_S_fallingTransition[iCap];} +double lookTable_FA_X1_B_S_fallingTransition(int iTr, int iCap) {return table_FA_X1_B_S_fallingTransition[iCap][iTr];} + +double trAxis_FA_X1_CI_CO_risingDelay[8] = {7.5e-12, 1.5e-11, 3.0e-11, 6.0e-11, 1.2e-10, 2.4e-10, 4.8e-10, 9.6e-10}; +double capAxis_FA_X1_CI_CO_risingDelay[6] = {4.0e-16, 8.0e-16, 1.6e-15, 3.2e-15, 6.4e-15, 1.28e-14}; +double table_FA_X1_CI_CO_risingDelay[6][8] = {{7.46e-11, 7.770000000000001e-11, 8.400000000000001e-11, 9.660000000000001e-11, 1.139e-10, 1.316e-10, 1.4230000000000002e-10, 1.287e-10}, {8.010000000000001e-11, 8.33e-11, 8.95e-11, 1.021e-10, 1.196e-10, 1.377e-10, 1.495e-10, 1.374e-10}, {9.070000000000001e-11, 9.38e-11, 1.002e-10, 1.1260000000000002e-10, 1.303e-10, 1.4890000000000002e-10, 1.6220000000000002e-10, 1.5300000000000001e-10}, {1.1070000000000002e-10, 1.1380000000000001e-10, 1.202e-10, 1.325e-10, 1.505e-10, 1.694e-10, 1.8440000000000003e-10, 1.8e-10}, {1.492e-10, 1.522e-10, 1.5840000000000002e-10, 1.7080000000000002e-10, 1.888e-10, 2.0790000000000003e-10, 2.2400000000000003e-10, 2.242e-10}, {2.2520000000000003e-10, 2.2830000000000003e-10, 2.344e-10, 2.4670000000000004e-10, 2.646e-10, 2.835e-10, 2.999e-10, 3.024e-10}}; +double lookTrAxis_FA_X1_CI_CO_risingDelay(int iTr) {return trAxis_FA_X1_CI_CO_risingDelay[iTr];} +double lookCapAxis_FA_X1_CI_CO_risingDelay(int iCap) {return capAxis_FA_X1_CI_CO_risingDelay[iCap];} +double lookTable_FA_X1_CI_CO_risingDelay(int iTr, int iCap) {return table_FA_X1_CI_CO_risingDelay[iCap][iTr];} + +double trAxis_FA_X1_CI_CO_fallingDelay[8] = {7.5e-12, 1.5e-11, 3.0e-11, 6.0e-11, 1.2e-10, 2.4e-10, 4.8e-10, 9.6e-10}; +double capAxis_FA_X1_CI_CO_fallingDelay[6] = {4.0e-16, 8.0e-16, 1.6e-15, 3.2e-15, 6.4e-15, 1.28e-14}; +double table_FA_X1_CI_CO_fallingDelay[6][8] = {{1.08e-10, 1.1110000000000001e-10, 1.1770000000000002e-10, 1.318e-10, 1.6170000000000002e-10, 2.098e-10, 2.798e-10, 3.884e-10}, {1.129e-10, 1.1600000000000001e-10, 1.2250000000000002e-10, 1.367e-10, 1.6650000000000002e-10, 2.1520000000000002e-10, 2.8580000000000004e-10, 3.956e-10}, {1.216e-10, 1.2470000000000002e-10, 1.313e-10, 1.454e-10, 1.7530000000000003e-10, 2.2480000000000001e-10, 2.966e-10, 4.0820000000000005e-10}, {1.3690000000000001e-10, 1.399e-10, 1.4660000000000002e-10, 1.608e-10, 1.9050000000000001e-10, 2.409e-10, 3.149e-10, 4.302000000000001e-10}, {1.63e-10, 1.6600000000000002e-10, 1.726e-10, 1.8690000000000002e-10, 2.166e-10, 2.6810000000000004e-10, 3.4480000000000004e-10, 4.6510000000000003e-10}, {2.0770000000000002e-10, 2.107e-10, 2.1740000000000002e-10, 2.317e-10, 2.6140000000000005e-10, 3.1380000000000004e-10, 3.932e-10, 5.197000000000001e-10}}; +double lookTrAxis_FA_X1_CI_CO_fallingDelay(int iTr) {return trAxis_FA_X1_CI_CO_fallingDelay[iTr];} +double lookCapAxis_FA_X1_CI_CO_fallingDelay(int iCap) {return capAxis_FA_X1_CI_CO_fallingDelay[iCap];} +double lookTable_FA_X1_CI_CO_fallingDelay(int iTr, int iCap) {return table_FA_X1_CI_CO_fallingDelay[iCap][iTr];} + +double trAxis_FA_X1_CI_CO_risingTransition[8] = {7.5e-12, 1.5e-11, 3.0e-11, 6.0e-11, 1.2e-10, 2.4e-10, 4.8e-10, 9.6e-10}; +double capAxis_FA_X1_CI_CO_risingTransition[6] = {4.0e-16, 8.0e-16, 1.6e-15, 3.2e-15, 6.4e-15, 1.28e-14}; +double table_FA_X1_CI_CO_risingTransition[6][8] = {{2.5900000000000002e-11, 2.6e-11, 2.6e-11, 2.64e-11, 2.8600000000000003e-11, 3.39e-11, 4.3e-11, 5.64e-11}, {2.98e-11, 2.98e-11, 2.98e-11, 3.02e-11, 3.21e-11, 3.7e-11, 4.6300000000000004e-11, 6.01e-11}, {3.78e-11, 3.78e-11, 3.78e-11, 3.8000000000000004e-11, 3.9600000000000004e-11, 4.35e-11, 5.27e-11, 6.77e-11}, {5.4100000000000006e-11, 5.4100000000000006e-11, 5.4100000000000006e-11, 5.44e-11, 5.5400000000000004e-11, 5.8100000000000005e-11, 6.560000000000001e-11, 8.160000000000001e-11}, {8.840000000000001e-11, 8.85e-11, 8.840000000000001e-11, 8.85e-11, 8.890000000000001e-11, 9.020000000000001e-11, 9.450000000000001e-11, 1.075e-10}, {1.5970000000000003e-10, 1.5970000000000003e-10, 1.5970000000000003e-10, 1.5970000000000003e-10, 1.5970000000000003e-10, 1.6000000000000002e-10, 1.613e-10, 1.6810000000000002e-10}}; +double lookTrAxis_FA_X1_CI_CO_risingTransition(int iTr) {return trAxis_FA_X1_CI_CO_risingTransition[iTr];} +double lookCapAxis_FA_X1_CI_CO_risingTransition(int iCap) {return capAxis_FA_X1_CI_CO_risingTransition[iCap];} +double lookTable_FA_X1_CI_CO_risingTransition(int iTr, int iCap) {return table_FA_X1_CI_CO_risingTransition[iCap][iTr];} + +double trAxis_FA_X1_CI_CO_fallingTransition[8] = {7.5e-12, 1.5e-11, 3.0e-11, 6.0e-11, 1.2e-10, 2.4e-10, 4.8e-10, 9.6e-10}; +double capAxis_FA_X1_CI_CO_fallingTransition[6] = {4.0e-16, 8.0e-16, 1.6e-15, 3.2e-15, 6.4e-15, 1.28e-14}; +double table_FA_X1_CI_CO_fallingTransition[6][8] = {{2.43e-11, 2.43e-11, 2.43e-11, 2.43e-11, 2.5300000000000002e-11, 3.03e-11, 3.78e-11, 5.01e-11}, {2.76e-11, 2.76e-11, 2.76e-11, 2.7500000000000002e-11, 2.8400000000000003e-11, 3.350000000000001e-11, 4.14e-11, 5.44e-11}, {3.3799999999999996e-11, 3.3799999999999996e-11, 3.3799999999999996e-11, 3.3700000000000004e-11, 3.4400000000000005e-11, 3.97e-11, 4.8300000000000004e-11, 6.260000000000001e-11}, {4.45e-11, 4.4600000000000006e-11, 4.45e-11, 4.45e-11, 4.5100000000000005e-11, 5.0500000000000007e-11, 6.02e-11, 7.660000000000001e-11}, {6.14e-11, 6.14e-11, 6.14e-11, 6.150000000000001e-11, 6.2e-11, 6.67e-11, 7.720000000000002e-11, 9.610000000000001e-11}, {9.020000000000001e-11, 9.01e-11, 9.020000000000001e-11, 9.020000000000001e-11, 9.04e-11, 9.35e-11, 1.021e-10, 1.1980000000000002e-10}}; +double lookTrAxis_FA_X1_CI_CO_fallingTransition(int iTr) {return trAxis_FA_X1_CI_CO_fallingTransition[iTr];} +double lookCapAxis_FA_X1_CI_CO_fallingTransition(int iCap) {return capAxis_FA_X1_CI_CO_fallingTransition[iCap];} +double lookTable_FA_X1_CI_CO_fallingTransition(int iTr, int iCap) {return table_FA_X1_CI_CO_fallingTransition[iCap][iTr];} + +double trAxis_FA_X1_CI_S_risingDelay[8] = {7.5e-12, 1.5e-11, 3.0e-11, 6.0e-11, 1.2e-10, 2.4e-10, 4.8e-10, 9.6e-10}; +double capAxis_FA_X1_CI_S_risingDelay[6] = {4.0e-16, 8.0e-16, 1.6e-15, 3.2e-15, 6.4e-15, 1.28e-14}; +double table_FA_X1_CI_S_risingDelay[6][8] = {{1.853e-10, 1.8850000000000002e-10, 1.951e-10, 2.0930000000000002e-10, 2.39e-10, 2.89e-10, 3.6180000000000003e-10, 4.788e-10}, {1.9210000000000001e-10, 1.9520000000000003e-10, 2.0180000000000002e-10, 2.161e-10, 2.4570000000000004e-10, 2.958e-10, 3.685e-10, 4.857000000000001e-10}, {2.0390000000000001e-10, 2.0710000000000001e-10, 2.1370000000000002e-10, 2.2800000000000001e-10, 2.577e-10, 3.0790000000000004e-10, 3.8000000000000003e-10, 4.976e-10}, {2.2530000000000001e-10, 2.284e-10, 2.351e-10, 2.493e-10, 2.79e-10, 3.293e-10, 4.014e-10, 5.185999999999999e-10}, {2.6470000000000003e-10, 2.678e-10, 2.7450000000000003e-10, 2.889e-10, 3.1850000000000004e-10, 3.6880000000000006e-10, 4.4080000000000007e-10, 5.577e-10}, {3.408e-10, 3.439e-10, 3.5060000000000006e-10, 3.6500000000000003e-10, 3.946e-10, 4.4490000000000004e-10, 5.173000000000001e-10, 6.341e-10}}; +double lookTrAxis_FA_X1_CI_S_risingDelay(int iTr) {return trAxis_FA_X1_CI_S_risingDelay[iTr];} +double lookCapAxis_FA_X1_CI_S_risingDelay(int iCap) {return capAxis_FA_X1_CI_S_risingDelay[iCap];} +double lookTable_FA_X1_CI_S_risingDelay(int iTr, int iCap) {return table_FA_X1_CI_S_risingDelay[iCap][iTr];} + +double trAxis_FA_X1_CI_S_fallingDelay[8] = {7.5e-12, 1.5e-11, 3.0e-11, 6.0e-11, 1.2e-10, 2.4e-10, 4.8e-10, 9.6e-10}; +double capAxis_FA_X1_CI_S_fallingDelay[6] = {4.0e-16, 8.0e-16, 1.6e-15, 3.2e-15, 6.4e-15, 1.28e-14}; +double table_FA_X1_CI_S_fallingDelay[6][8] = {{1.587e-10, 1.624e-10, 1.6980000000000002e-10, 1.8370000000000002e-10, 2.0190000000000002e-10, 2.428e-10, 3.2590000000000003e-10, 4.5290000000000006e-10}, {1.649e-10, 1.687e-10, 1.76e-10, 1.8990000000000004e-10, 2.081e-10, 2.4970000000000003e-10, 3.3380000000000003e-10, 4.6190000000000003e-10}, {1.755e-10, 1.792e-10, 1.866e-10, 2.004e-10, 2.1890000000000001e-10, 2.618e-10, 3.4720000000000005e-10, 4.766000000000001e-10}, {1.931e-10, 1.966e-10, 2.0390000000000001e-10, 2.177e-10, 2.363e-10, 2.8060000000000004e-10, 3.6780000000000006e-10, 5.009e-10}, {2.213e-10, 2.2500000000000002e-10, 2.3190000000000002e-10, 2.458e-10, 2.6470000000000003e-10, 3.1069999999999997e-10, 4.003e-10, 5.372000000000001e-10}, {2.6810000000000004e-10, 2.717e-10, 2.7860000000000005e-10, 2.9260000000000005e-10, 3.1140000000000003e-10, 3.6020000000000006e-10, 4.5190000000000006e-10, 5.929e-10}}; +double lookTrAxis_FA_X1_CI_S_fallingDelay(int iTr) {return trAxis_FA_X1_CI_S_fallingDelay[iTr];} +double lookCapAxis_FA_X1_CI_S_fallingDelay(int iCap) {return capAxis_FA_X1_CI_S_fallingDelay[iCap];} +double lookTable_FA_X1_CI_S_fallingDelay(int iTr, int iCap) {return table_FA_X1_CI_S_fallingDelay[iCap][iTr];} + +double trAxis_FA_X1_CI_S_risingTransition[8] = {7.5e-12, 1.5e-11, 3.0e-11, 6.0e-11, 1.2e-10, 2.4e-10, 4.8e-10, 9.6e-10}; +double capAxis_FA_X1_CI_S_risingTransition[6] = {4.0e-16, 8.0e-16, 1.6e-15, 3.2e-15, 6.4e-15, 1.28e-14}; +double table_FA_X1_CI_S_risingTransition[6][8] = {{1.92e-11, 1.92e-11, 1.89e-11, 1.8800000000000002e-11, 1.91e-11, 2.2e-11, 2.7100000000000002e-11, 3.4900000000000004e-11}, {2.3300000000000003e-11, 2.32e-11, 2.31e-11, 2.3e-11, 2.3900000000000003e-11, 2.6e-11, 3.1600000000000006e-11, 4.01e-11}, {3.19e-11, 3.18e-11, 3.17e-11, 3.1300000000000004e-11, 3.2500000000000004e-11, 3.470000000000001e-11, 3.93e-11, 4.92e-11}, {4.8700000000000004e-11, 4.86e-11, 4.850000000000001e-11, 4.81e-11, 4.84e-11, 5.1400000000000005e-11, 5.6500000000000005e-11, 6.58e-11}, {8.240000000000001e-11, 8.240000000000001e-11, 8.23e-11, 8.21e-11, 8.17e-11, 8.300000000000001e-11, 8.87e-11, 9.87e-11}, {1.523e-10, 1.523e-10, 1.523e-10, 1.523e-10, 1.5190000000000001e-10, 1.5200000000000002e-10, 1.5370000000000002e-10, 1.6280000000000002e-10}}; +double lookTrAxis_FA_X1_CI_S_risingTransition(int iTr) {return trAxis_FA_X1_CI_S_risingTransition[iTr];} +double lookCapAxis_FA_X1_CI_S_risingTransition(int iCap) {return capAxis_FA_X1_CI_S_risingTransition[iCap];} +double lookTable_FA_X1_CI_S_risingTransition(int iTr, int iCap) {return table_FA_X1_CI_S_risingTransition[iCap][iTr];} + +double trAxis_FA_X1_CI_S_fallingTransition[8] = {7.5e-12, 1.5e-11, 3.0e-11, 6.0e-11, 1.2e-10, 2.4e-10, 4.8e-10, 9.6e-10}; +double capAxis_FA_X1_CI_S_fallingTransition[6] = {4.0e-16, 8.0e-16, 1.6e-15, 3.2e-15, 6.4e-15, 1.28e-14}; +double table_FA_X1_CI_S_fallingTransition[6][8] = {{2.28e-11, 2.2700000000000003e-11, 2.26e-11, 2.24e-11, 2.2100000000000003e-11, 2.4400000000000004e-11, 3.07e-11, 3.9200000000000004e-11}, {2.5600000000000004e-11, 2.55e-11, 2.54e-11, 2.52e-11, 2.49e-11, 2.6900000000000002e-11, 3.34e-11, 4.220000000000001e-11}, {3.0900000000000004e-11, 3.0800000000000006e-11, 3.07e-11, 3.05e-11, 3.01e-11, 3.17e-11, 3.8000000000000004e-11, 4.730000000000001e-11}, {4.0300000000000006e-11, 4.02e-11, 4.01e-11, 3.980000000000001e-11, 3.94e-11, 4.05e-11, 4.64e-11, 5.59e-11}, {5.79e-11, 5.7800000000000003e-11, 5.76e-11, 5.71e-11, 5.630000000000001e-11, 5.86e-11, 6.160000000000001e-11, 7.08e-11}, {8.830000000000001e-11, 8.830000000000001e-11, 8.81e-11, 8.780000000000001e-11, 8.730000000000001e-11, 9.04e-11, 9.59e-11, 1.031e-10}}; +double lookTrAxis_FA_X1_CI_S_fallingTransition(int iTr) {return trAxis_FA_X1_CI_S_fallingTransition[iTr];} +double lookCapAxis_FA_X1_CI_S_fallingTransition(int iCap) {return capAxis_FA_X1_CI_S_fallingTransition[iCap];} +double lookTable_FA_X1_CI_S_fallingTransition(int iTr, int iCap) {return table_FA_X1_CI_S_fallingTransition[iCap][iTr];} + +double trAxis_HA_X1_A_CO_risingDelay[8] = {7.5e-12, 1.5e-11, 3.0e-11, 6.0e-11, 1.2e-10, 2.4e-10, 4.8e-10, 9.6e-10}; +double capAxis_HA_X1_A_CO_risingDelay[6] = {4.0e-16, 8.0e-16, 1.6e-15, 3.2e-15, 6.4e-15, 1.28e-14}; +double table_HA_X1_A_CO_risingDelay[6][8] = {{4.23e-11, 4.5400000000000006e-11, 5.1400000000000005e-11, 5.970000000000001e-11, 6.78e-11, 7.2e-11, 6.400000000000001e-11, 2.7100000000000002e-11}, {4.77e-11, 5.08e-11, 5.680000000000001e-11, 6.519999999999999e-11, 7.37e-11, 7.890000000000001e-11, 7.240000000000002e-11, 3.72e-11}, {5.79e-11, 6.1e-11, 6.690000000000001e-11, 7.54e-11, 8.42e-11, 9.06e-11, 8.66e-11, 5.47e-11}, {7.74e-11, 8.05e-11, 8.6e-11, 9.48e-11, 1.037e-10, 1.1070000000000002e-10, 1.097e-10, 8.36e-11}, {1.151e-10, 1.1820000000000002e-10, 1.2370000000000002e-10, 1.324e-10, 1.415e-10, 1.486e-10, 1.4890000000000002e-10, 1.288e-10}, {1.9040000000000004e-10, 1.9350000000000003e-10, 1.99e-10, 2.0770000000000002e-10, 2.165e-10, 2.2350000000000003e-10, 2.244e-10, 2.07e-10}}; +double lookTrAxis_HA_X1_A_CO_risingDelay(int iTr) {return trAxis_HA_X1_A_CO_risingDelay[iTr];} +double lookCapAxis_HA_X1_A_CO_risingDelay(int iCap) {return capAxis_HA_X1_A_CO_risingDelay[iCap];} +double lookTable_HA_X1_A_CO_risingDelay(int iTr, int iCap) {return table_HA_X1_A_CO_risingDelay[iCap][iTr];} + +double trAxis_HA_X1_A_CO_fallingDelay[8] = {7.5e-12, 1.5e-11, 3.0e-11, 6.0e-11, 1.2e-10, 2.4e-10, 4.8e-10, 9.6e-10}; +double capAxis_HA_X1_A_CO_fallingDelay[6] = {4.0e-16, 8.0e-16, 1.6e-15, 3.2e-15, 6.4e-15, 1.28e-14}; +double table_HA_X1_A_CO_fallingDelay[6][8] = {{4.7800000000000006e-11, 5.16e-11, 5.96e-11, 7.51e-11, 9.78e-11, 1.3070000000000002e-10, 1.819e-10, 2.653e-10}, {5.19e-11, 5.5700000000000005e-11, 6.370000000000001e-11, 7.93e-11, 1.026e-10, 1.363e-10, 1.886e-10, 2.7350000000000004e-10}, {5.89e-11, 6.270000000000001e-11, 7.08e-11, 8.65e-11, 1.1070000000000002e-10, 1.457e-10, 1.997e-10, 2.871e-10}, {7.11e-11, 7.49e-11, 8.300000000000001e-11, 9.87e-11, 1.24e-10, 1.608e-10, 2.177e-10, 3.091e-10}, {9.210000000000001e-11, 9.580000000000001e-11, 1.04e-10, 1.1980000000000002e-10, 1.4630000000000003e-10, 1.8490000000000003e-10, 2.4550000000000003e-10, 3.434e-10}, {1.3070000000000002e-10, 1.346e-10, 1.426e-10, 1.5840000000000002e-10, 1.853e-10, 2.2550000000000002e-10, 2.8970000000000004e-10, 3.958e-10}}; +double lookTrAxis_HA_X1_A_CO_fallingDelay(int iTr) {return trAxis_HA_X1_A_CO_fallingDelay[iTr];} +double lookCapAxis_HA_X1_A_CO_fallingDelay(int iCap) {return capAxis_HA_X1_A_CO_fallingDelay[iCap];} +double lookTable_HA_X1_A_CO_fallingDelay(int iTr, int iCap) {return table_HA_X1_A_CO_fallingDelay[iCap][iTr];} + +double trAxis_HA_X1_A_CO_risingTransition[8] = {7.5e-12, 1.5e-11, 3.0e-11, 6.0e-11, 1.2e-10, 2.4e-10, 4.8e-10, 9.6e-10}; +double capAxis_HA_X1_A_CO_risingTransition[6] = {4.0e-16, 8.0e-16, 1.6e-15, 3.2e-15, 6.4e-15, 1.28e-14}; +double table_HA_X1_A_CO_risingTransition[6][8] = {{1.36e-11, 1.36e-11, 1.3700000000000002e-11, 1.44e-11, 1.62e-11, 2.0000000000000002e-11, 2.5900000000000002e-11, 3.5300000000000003e-11}, {1.7600000000000003e-11, 1.7600000000000003e-11, 1.7600000000000003e-11, 1.83e-11, 1.9800000000000002e-11, 2.3500000000000003e-11, 3.03e-11, 4.06e-11}, {2.58e-11, 2.58e-11, 2.5900000000000002e-11, 2.6300000000000002e-11, 2.7300000000000002e-11, 3.03e-11, 3.7600000000000005e-11, 4.9900000000000003e-11}, {4.3e-11, 4.3e-11, 4.3e-11, 4.3200000000000003e-11, 4.38e-11, 4.56e-11, 5.120000000000001e-11, 6.500000000000001e-11}, {7.85e-11, 7.85e-11, 7.85e-11, 7.85e-11, 7.870000000000001e-11, 7.94e-11, 8.240000000000001e-11, 9.24e-11}, {1.5010000000000003e-10, 1.5010000000000003e-10, 1.5010000000000003e-10, 1.5010000000000003e-10, 1.5010000000000003e-10, 1.5040000000000002e-10, 1.5190000000000001e-10, 1.577e-10}}; +double lookTrAxis_HA_X1_A_CO_risingTransition(int iTr) {return trAxis_HA_X1_A_CO_risingTransition[iTr];} +double lookCapAxis_HA_X1_A_CO_risingTransition(int iCap) {return capAxis_HA_X1_A_CO_risingTransition[iCap];} +double lookTable_HA_X1_A_CO_risingTransition(int iTr, int iCap) {return table_HA_X1_A_CO_risingTransition[iCap][iTr];} + +double trAxis_HA_X1_A_CO_fallingTransition[8] = {7.5e-12, 1.5e-11, 3.0e-11, 6.0e-11, 1.2e-10, 2.4e-10, 4.8e-10, 9.6e-10}; +double capAxis_HA_X1_A_CO_fallingTransition[6] = {4.0e-16, 8.0e-16, 1.6e-15, 3.2e-15, 6.4e-15, 1.28e-14}; +double table_HA_X1_A_CO_fallingTransition[6][8] = {{1.0400000000000001e-11, 1.0400000000000001e-11, 1.0500000000000001e-11, 1.13e-11, 1.38e-11, 1.7500000000000004e-11, 2.32e-11, 3.3e-11}, {1.2500000000000002e-11, 1.2500000000000002e-11, 1.26e-11, 1.33e-11, 1.59e-11, 1.97e-11, 2.58e-11, 3.6100000000000003e-11}, {1.6600000000000003e-11, 1.65e-11, 1.6600000000000003e-11, 1.71e-11, 1.97e-11, 2.37e-11, 3.02e-11, 4.130000000000001e-11}, {2.42e-11, 2.42e-11, 2.42e-11, 2.46e-11, 2.6900000000000002e-11, 3.0900000000000004e-11, 3.7900000000000006e-11, 5.0300000000000003e-11}, {3.89e-11, 3.89e-11, 3.89e-11, 3.9100000000000006e-11, 4.0700000000000006e-11, 4.44e-11, 5.1400000000000005e-11, 6.510000000000001e-11}, {6.980000000000001e-11, 6.990000000000001e-11, 6.990000000000001e-11, 7.000000000000002e-11, 7.05e-11, 7.26e-11, 7.79e-11, 9.14e-11}}; +double lookTrAxis_HA_X1_A_CO_fallingTransition(int iTr) {return trAxis_HA_X1_A_CO_fallingTransition[iTr];} +double lookCapAxis_HA_X1_A_CO_fallingTransition(int iCap) {return capAxis_HA_X1_A_CO_fallingTransition[iCap];} +double lookTable_HA_X1_A_CO_fallingTransition(int iTr, int iCap) {return table_HA_X1_A_CO_fallingTransition[iCap][iTr];} + +double trAxis_HA_X1_A_S_risingDelay[8] = {7.5e-12, 1.5e-11, 3.0e-11, 6.0e-11, 1.2e-10, 2.4e-10, 4.8e-10, 9.6e-10}; +double capAxis_HA_X1_A_S_risingDelay[6] = {4.0e-16, 8.0e-16, 1.6e-15, 3.2e-15, 6.4e-15, 1.28e-14}; +double table_HA_X1_A_S_risingDelay[6][8] = {{1.134e-10, 1.167e-10, 1.229e-10, 1.319e-10, 1.415e-10, 1.4770000000000002e-10, 1.8920000000000003e-10, 2.835e-10}, {1.2e-10, 1.234e-10, 1.296e-10, 1.387e-10, 1.485e-10, 1.548e-10, 2.0230000000000001e-10, 2.996e-10}, {1.3330000000000002e-10, 1.367e-10, 1.4290000000000002e-10, 1.522e-10, 1.623e-10, 1.6880000000000003e-10, 2.2600000000000002e-10, 3.298e-10}, {1.5989999999999999e-10, 1.6320000000000002e-10, 1.692e-10, 1.7890000000000002e-10, 1.893e-10, 1.9670000000000003e-10, 2.697e-10, 3.841e-10}, {2.128e-10, 2.1620000000000001e-10, 2.219e-10, 2.3190000000000002e-10, 2.424e-10, 2.569e-10, 3.464e-10, 4.794e-10}, {3.181e-10, 3.218e-10, 3.2760000000000004e-10, 3.3770000000000003e-10, 3.4830000000000003e-10, 3.605e-10, 4.753e-10, 6.423e-10}}; +double lookTrAxis_HA_X1_A_S_risingDelay(int iTr) {return trAxis_HA_X1_A_S_risingDelay[iTr];} +double lookCapAxis_HA_X1_A_S_risingDelay(int iCap) {return capAxis_HA_X1_A_S_risingDelay[iCap];} +double lookTable_HA_X1_A_S_risingDelay(int iTr, int iCap) {return table_HA_X1_A_S_risingDelay[iCap][iTr];} + +double trAxis_HA_X1_A_S_fallingDelay[8] = {7.5e-12, 1.5e-11, 3.0e-11, 6.0e-11, 1.2e-10, 2.4e-10, 4.8e-10, 9.6e-10}; +double capAxis_HA_X1_A_S_fallingDelay[6] = {4.0e-16, 8.0e-16, 1.6e-15, 3.2e-15, 6.4e-15, 1.28e-14}; +double table_HA_X1_A_S_fallingDelay[6][8] = {{9.71e-11, 1.001e-10, 1.07e-10, 1.215e-10, 1.47e-10, 1.835e-10, 2.402e-10, 3.311e-10}, {1.002e-10, 1.0330000000000001e-10, 1.1010000000000001e-10, 1.2460000000000001e-10, 1.503e-10, 1.871e-10, 2.442e-10, 3.359e-10}, {1.0630000000000001e-10, 1.094e-10, 1.1620000000000001e-10, 1.3070000000000002e-10, 1.567e-10, 1.9400000000000003e-10, 2.5180000000000005e-10, 3.4480000000000004e-10}, {1.1770000000000002e-10, 1.208e-10, 1.2780000000000001e-10, 1.4230000000000002e-10, 1.684e-10, 2.064e-10, 2.655e-10, 3.6120000000000006e-10}, {1.3910000000000002e-10, 1.422e-10, 1.492e-10, 1.636e-10, 1.8990000000000004e-10, 2.289e-10, 2.8960000000000006e-10, 3.892e-10}, {1.788e-10, 1.819e-10, 1.8890000000000001e-10, 2.033e-10, 2.297e-10, 2.697e-10, 3.319e-10, 4.3630000000000003e-10}}; +double lookTrAxis_HA_X1_A_S_fallingDelay(int iTr) {return trAxis_HA_X1_A_S_fallingDelay[iTr];} +double lookCapAxis_HA_X1_A_S_fallingDelay(int iCap) {return capAxis_HA_X1_A_S_fallingDelay[iCap];} +double lookTable_HA_X1_A_S_fallingDelay(int iTr, int iCap) {return table_HA_X1_A_S_fallingDelay[iCap][iTr];} + +double trAxis_HA_X1_A_S_risingTransition[8] = {7.5e-12, 1.5e-11, 3.0e-11, 6.0e-11, 1.2e-10, 2.4e-10, 4.8e-10, 9.6e-10}; +double capAxis_HA_X1_A_S_risingTransition[6] = {4.0e-16, 8.0e-16, 1.6e-15, 3.2e-15, 6.4e-15, 1.28e-14}; +double table_HA_X1_A_S_risingTransition[6][8] = {{5.43e-11, 5.43e-11, 5.43e-11, 5.43e-11, 5.6900000000000005e-11, 7.64e-11, 1.0900000000000001e-10, 1.6750000000000002e-10}, {6.05e-11, 6.05e-11, 6.05e-11, 6.05e-11, 6.180000000000001e-11, 8.260000000000002e-11, 1.1590000000000001e-10, 1.7510000000000002e-10}, {7.280000000000001e-11, 7.280000000000001e-11, 7.280000000000001e-11, 7.280000000000001e-11, 7.230000000000001e-11, 9.41e-11, 1.294e-10, 1.9050000000000001e-10}, {9.740000000000001e-11, 9.740000000000001e-11, 9.740000000000001e-11, 9.740000000000001e-11, 9.72e-11, 1.1500000000000002e-10, 1.5470000000000002e-10, 2.196e-10}, {1.464e-10, 1.464e-10, 1.4630000000000003e-10, 1.4630000000000003e-10, 1.464e-10, 1.518e-10, 1.999e-10, 2.734e-10}, {2.4380000000000003e-10, 2.4380000000000003e-10, 2.439e-10, 2.439e-10, 2.439e-10, 2.431e-10, 2.759e-10, 3.685e-10}}; +double lookTrAxis_HA_X1_A_S_risingTransition(int iTr) {return trAxis_HA_X1_A_S_risingTransition[iTr];} +double lookCapAxis_HA_X1_A_S_risingTransition(int iCap) {return capAxis_HA_X1_A_S_risingTransition[iCap];} +double lookTable_HA_X1_A_S_risingTransition(int iTr, int iCap) {return table_HA_X1_A_S_risingTransition[iCap][iTr];} + +double trAxis_HA_X1_A_S_fallingTransition[8] = {7.5e-12, 1.5e-11, 3.0e-11, 6.0e-11, 1.2e-10, 2.4e-10, 4.8e-10, 9.6e-10}; +double capAxis_HA_X1_A_S_fallingTransition[6] = {4.0e-16, 8.0e-16, 1.6e-15, 3.2e-15, 6.4e-15, 1.28e-14}; +double table_HA_X1_A_S_fallingTransition[6][8] = {{2.7900000000000002e-11, 2.7900000000000002e-11, 2.7900000000000002e-11, 2.8000000000000003e-11, 3.75e-11, 5.85e-11, 9.520000000000002e-11, 1.6000000000000002e-10}, {3.0e-11, 2.99e-11, 2.99e-11, 3.0e-11, 3.99e-11, 6.160000000000001e-11, 9.91e-11, 1.654e-10}, {3.4000000000000005e-11, 3.4000000000000005e-11, 3.4000000000000005e-11, 3.4000000000000005e-11, 4.44e-11, 6.73e-11, 1.0650000000000001e-10, 1.754e-10}, {4.2000000000000004e-11, 4.1900000000000005e-11, 4.1900000000000005e-11, 4.1900000000000005e-11, 5.240000000000001e-11, 7.710000000000001e-11, 1.1940000000000002e-10, 1.929e-10}, {5.71e-11, 5.71e-11, 5.71e-11, 5.71e-11, 6.63e-11, 9.44e-11, 1.4130000000000002e-10, 2.2210000000000001e-10}, {8.87e-11, 8.87e-11, 8.87e-11, 8.87e-11, 9.340000000000001e-11, 1.234e-10, 1.779e-10, 2.6900000000000005e-10}}; +double lookTrAxis_HA_X1_A_S_fallingTransition(int iTr) {return trAxis_HA_X1_A_S_fallingTransition[iTr];} +double lookCapAxis_HA_X1_A_S_fallingTransition(int iCap) {return capAxis_HA_X1_A_S_fallingTransition[iCap];} +double lookTable_HA_X1_A_S_fallingTransition(int iTr, int iCap) {return table_HA_X1_A_S_fallingTransition[iCap][iTr];} + +double trAxis_HA_X1_B_CO_risingDelay[8] = {7.5e-12, 1.5e-11, 3.0e-11, 6.0e-11, 1.2e-10, 2.4e-10, 4.8e-10, 9.6e-10}; +double capAxis_HA_X1_B_CO_risingDelay[6] = {4.0e-16, 8.0e-16, 1.6e-15, 3.2e-15, 6.4e-15, 1.28e-14}; +double table_HA_X1_B_CO_risingDelay[6][8] = {{4.74e-11, 5.0300000000000003e-11, 5.5300000000000005e-11, 6.310000000000001e-11, 7.2e-11, 7.770000000000001e-11, 7.15e-11, 3.5700000000000003e-11}, {5.2900000000000006e-11, 5.5700000000000005e-11, 6.07e-11, 6.86e-11, 7.78e-11, 8.430000000000001e-11, 7.94e-11, 4.52e-11}, {6.3e-11, 6.59e-11, 7.08e-11, 7.890000000000001e-11, 8.830000000000001e-11, 9.580000000000001e-11, 9.310000000000001e-11, 6.17e-11}, {8.250000000000001e-11, 8.53e-11, 9.01e-11, 9.820000000000001e-11, 1.079e-10, 1.1590000000000001e-10, 1.1540000000000001e-10, 8.920000000000001e-11}, {1.202e-10, 1.2300000000000001e-10, 1.277e-10, 1.357e-10, 1.457e-10, 1.54e-10, 1.548e-10, 1.329e-10}, {1.9550000000000002e-10, 1.984e-10, 2.0310000000000003e-10, 2.11e-10, 2.2090000000000003e-10, 2.2910000000000002e-10, 2.306e-10, 2.1140000000000001e-10}}; +double lookTrAxis_HA_X1_B_CO_risingDelay(int iTr) {return trAxis_HA_X1_B_CO_risingDelay[iTr];} +double lookCapAxis_HA_X1_B_CO_risingDelay(int iCap) {return capAxis_HA_X1_B_CO_risingDelay[iCap];} +double lookTable_HA_X1_B_CO_risingDelay(int iTr, int iCap) {return table_HA_X1_B_CO_risingDelay[iCap][iTr];} + +double trAxis_HA_X1_B_CO_fallingDelay[8] = {7.5e-12, 1.5e-11, 3.0e-11, 6.0e-11, 1.2e-10, 2.4e-10, 4.8e-10, 9.6e-10}; +double capAxis_HA_X1_B_CO_fallingDelay[6] = {4.0e-16, 8.0e-16, 1.6e-15, 3.2e-15, 6.4e-15, 1.28e-14}; +double table_HA_X1_B_CO_fallingDelay[6][8] = {{6.01e-11, 6.38e-11, 7.170000000000001e-11, 8.82e-11, 1.1560000000000001e-10, 1.545e-10, 2.14e-10, 3.1230000000000005e-10}, {6.450000000000001e-11, 6.82e-11, 7.61e-11, 9.25e-11, 1.204e-10, 1.601e-10, 2.2050000000000001e-10, 3.201e-10}, {7.2e-11, 7.570000000000001e-11, 8.36e-11, 1.0000000000000002e-10, 1.286e-10, 1.694e-10, 2.3150000000000003e-10, 3.327e-10}, {8.46e-11, 8.82e-11, 9.63e-11, 1.127e-10, 1.42e-10, 1.8440000000000003e-10, 2.488e-10, 3.535e-10}, {1.064e-10, 1.1010000000000001e-10, 1.18e-10, 1.3450000000000003e-10, 1.6430000000000002e-10, 2.086e-10, 2.758e-10, 3.852e-10}, {1.457e-10, 1.4940000000000002e-10, 1.5740000000000002e-10, 1.738e-10, 2.038e-10, 2.495e-10, 3.1929999999999997e-10, 4.3410000000000003e-10}}; +double lookTrAxis_HA_X1_B_CO_fallingDelay(int iTr) {return trAxis_HA_X1_B_CO_fallingDelay[iTr];} +double lookCapAxis_HA_X1_B_CO_fallingDelay(int iCap) {return capAxis_HA_X1_B_CO_fallingDelay[iCap];} +double lookTable_HA_X1_B_CO_fallingDelay(int iTr, int iCap) {return table_HA_X1_B_CO_fallingDelay[iCap][iTr];} + +double trAxis_HA_X1_B_CO_risingTransition[8] = {7.5e-12, 1.5e-11, 3.0e-11, 6.0e-11, 1.2e-10, 2.4e-10, 4.8e-10, 9.6e-10}; +double capAxis_HA_X1_B_CO_risingTransition[6] = {4.0e-16, 8.0e-16, 1.6e-15, 3.2e-15, 6.4e-15, 1.28e-14}; +double table_HA_X1_B_CO_risingTransition[6][8] = {{1.36e-11, 1.36e-11, 1.36e-11, 1.4200000000000002e-11, 1.55e-11, 1.85e-11, 2.34e-11, 3.05e-11}, {1.7600000000000003e-11, 1.7600000000000003e-11, 1.7600000000000003e-11, 1.8e-11, 1.9300000000000004e-11, 2.22e-11, 2.7700000000000002e-11, 3.58e-11}, {2.58e-11, 2.58e-11, 2.58e-11, 2.6100000000000002e-11, 2.7e-11, 2.95e-11, 3.5200000000000005e-11, 4.5e-11}, {4.3e-11, 4.3e-11, 4.3e-11, 4.3200000000000003e-11, 4.370000000000001e-11, 4.5100000000000005e-11, 4.9700000000000007e-11, 6.02e-11}, {7.840000000000001e-11, 7.840000000000001e-11, 7.85e-11, 7.85e-11, 7.870000000000001e-11, 7.93e-11, 8.200000000000001e-11, 8.970000000000001e-11}, {1.5010000000000003e-10, 1.5010000000000003e-10, 1.5e-10, 1.5010000000000003e-10, 1.5010000000000003e-10, 1.503e-10, 1.517e-10, 1.571e-10}}; +double lookTrAxis_HA_X1_B_CO_risingTransition(int iTr) {return trAxis_HA_X1_B_CO_risingTransition[iTr];} +double lookCapAxis_HA_X1_B_CO_risingTransition(int iCap) {return capAxis_HA_X1_B_CO_risingTransition[iCap];} +double lookTable_HA_X1_B_CO_risingTransition(int iTr, int iCap) {return table_HA_X1_B_CO_risingTransition[iCap][iTr];} + +double trAxis_HA_X1_B_CO_fallingTransition[8] = {7.5e-12, 1.5e-11, 3.0e-11, 6.0e-11, 1.2e-10, 2.4e-10, 4.8e-10, 9.6e-10}; +double capAxis_HA_X1_B_CO_fallingTransition[6] = {4.0e-16, 8.0e-16, 1.6e-15, 3.2e-15, 6.4e-15, 1.28e-14}; +double table_HA_X1_B_CO_fallingTransition[6][8] = {{1.15e-11, 1.15e-11, 1.16e-11, 1.17e-11, 1.4000000000000002e-11, 1.7600000000000003e-11, 2.2700000000000003e-11, 3.0800000000000006e-11}, {1.3700000000000002e-11, 1.3700000000000002e-11, 1.3700000000000002e-11, 1.38e-11, 1.6000000000000003e-11, 1.97e-11, 2.5100000000000003e-11, 3.350000000000001e-11}, {1.77e-11, 1.77e-11, 1.77e-11, 1.7800000000000003e-11, 1.9800000000000002e-11, 2.37e-11, 2.92e-11, 3.81e-11}, {2.55e-11, 2.55e-11, 2.54e-11, 2.55e-11, 2.7e-11, 3.0800000000000006e-11, 3.6700000000000006e-11, 4.610000000000001e-11}, {4.01e-11, 4.01e-11, 4.01e-11, 4.02e-11, 4.1200000000000004e-11, 4.45e-11, 5.01e-11, 6.0e-11}, {7.08e-11, 7.08e-11, 7.08e-11, 7.08e-11, 7.120000000000001e-11, 7.31e-11, 7.7e-11, 8.560000000000001e-11}}; +double lookTrAxis_HA_X1_B_CO_fallingTransition(int iTr) {return trAxis_HA_X1_B_CO_fallingTransition[iTr];} +double lookCapAxis_HA_X1_B_CO_fallingTransition(int iCap) {return capAxis_HA_X1_B_CO_fallingTransition[iCap];} +double lookTable_HA_X1_B_CO_fallingTransition(int iTr, int iCap) {return table_HA_X1_B_CO_fallingTransition[iCap][iTr];} + +double trAxis_HA_X1_B_S_risingDelay[8] = {7.5e-12, 1.5e-11, 3.0e-11, 6.0e-11, 1.2e-10, 2.4e-10, 4.8e-10, 9.6e-10}; +double capAxis_HA_X1_B_S_risingDelay[6] = {4.0e-16, 8.0e-16, 1.6e-15, 3.2e-15, 6.4e-15, 1.28e-14}; +double table_HA_X1_B_S_risingDelay[6][8] = {{1.0480000000000002e-10, 1.0810000000000001e-10, 1.1480000000000001e-10, 1.2620000000000001e-10, 1.397e-10, 1.5970000000000003e-10, 2.2550000000000002e-10, 3.344e-10}, {1.1160000000000001e-10, 1.1490000000000001e-10, 1.216e-10, 1.33e-10, 1.465e-10, 1.6880000000000003e-10, 2.3730000000000005e-10, 3.4880000000000003e-10}, {1.25e-10, 1.284e-10, 1.351e-10, 1.465e-10, 1.6000000000000002e-10, 1.865e-10, 2.5900000000000004e-10, 3.7630000000000003e-10}, {1.5200000000000002e-10, 1.555e-10, 1.6170000000000002e-10, 1.732e-10, 1.87e-10, 2.1890000000000001e-10, 3.0e-10, 4.266e-10}, {2.0510000000000002e-10, 2.0830000000000002e-10, 2.1460000000000001e-10, 2.261e-10, 2.4e-10, 2.759e-10, 3.7280000000000005e-10, 5.167000000000001e-10}, {3.11e-10, 3.142e-10, 3.206e-10, 3.321e-10, 3.461e-10, 3.7830000000000003e-10, 4.968000000000001e-10, 6.734000000000001e-10}}; +double lookTrAxis_HA_X1_B_S_risingDelay(int iTr) {return trAxis_HA_X1_B_S_risingDelay[iTr];} +double lookCapAxis_HA_X1_B_S_risingDelay(int iCap) {return capAxis_HA_X1_B_S_risingDelay[iCap];} +double lookTable_HA_X1_B_S_risingDelay(int iTr, int iCap) {return table_HA_X1_B_S_risingDelay[iCap][iTr];} + +double trAxis_HA_X1_B_S_fallingDelay[8] = {7.5e-12, 1.5e-11, 3.0e-11, 6.0e-11, 1.2e-10, 2.4e-10, 4.8e-10, 9.6e-10}; +double capAxis_HA_X1_B_S_fallingDelay[6] = {4.0e-16, 8.0e-16, 1.6e-15, 3.2e-15, 6.4e-15, 1.28e-14}; +double table_HA_X1_B_S_fallingDelay[6][8] = {{1.112e-10, 1.1500000000000002e-10, 1.217e-10, 1.3380000000000002e-10, 1.548e-10, 1.8640000000000002e-10, 2.385e-10, 3.2340000000000004e-10}, {1.1440000000000001e-10, 1.181e-10, 1.248e-10, 1.3690000000000001e-10, 1.581e-10, 1.9000000000000002e-10, 2.424e-10, 3.279e-10}, {1.204e-10, 1.2410000000000002e-10, 1.309e-10, 1.43e-10, 1.644e-10, 1.9670000000000003e-10, 2.5019999999999997e-10, 3.3670000000000004e-10}, {1.318e-10, 1.354e-10, 1.4230000000000002e-10, 1.5470000000000002e-10, 1.76e-10, 2.0930000000000002e-10, 2.638e-10, 3.525e-10}, {1.5320000000000002e-10, 1.5680000000000002e-10, 1.6370000000000001e-10, 1.7610000000000002e-10, 1.9750000000000002e-10, 2.3190000000000002e-10, 2.881e-10, 3.8000000000000003e-10}, {1.9280000000000002e-10, 1.9640000000000001e-10, 2.033e-10, 2.1570000000000002e-10, 2.3730000000000005e-10, 2.729e-10, 3.3100000000000005e-10, 4.2740000000000004e-10}}; +double lookTrAxis_HA_X1_B_S_fallingDelay(int iTr) {return trAxis_HA_X1_B_S_fallingDelay[iTr];} +double lookCapAxis_HA_X1_B_S_fallingDelay(int iCap) {return capAxis_HA_X1_B_S_fallingDelay[iCap];} +double lookTable_HA_X1_B_S_fallingDelay(int iTr, int iCap) {return table_HA_X1_B_S_fallingDelay[iCap][iTr];} + +double trAxis_HA_X1_B_S_risingTransition[8] = {7.5e-12, 1.5e-11, 3.0e-11, 6.0e-11, 1.2e-10, 2.4e-10, 4.8e-10, 9.6e-10}; +double capAxis_HA_X1_B_S_risingTransition[6] = {4.0e-16, 8.0e-16, 1.6e-15, 3.2e-15, 6.4e-15, 1.28e-14}; +double table_HA_X1_B_S_risingTransition[6][8] = {{5.4200000000000004e-11, 5.4200000000000004e-11, 5.4e-11, 5.35e-11, 6.29e-11, 8.28e-11, 1.128e-10, 1.6160000000000002e-10}, {6.05e-11, 6.05e-11, 6.03e-11, 5.96e-11, 6.759999999999999e-11, 8.910000000000001e-11, 1.205e-10, 1.7050000000000003e-10}, {7.290000000000001e-11, 7.290000000000001e-11, 7.290000000000001e-11, 7.21e-11, 7.770000000000001e-11, 1.0040000000000001e-10, 1.3480000000000002e-10, 1.882e-10}, {9.740000000000001e-11, 9.750000000000001e-11, 9.740000000000001e-11, 9.73e-11, 9.900000000000001e-11, 1.209e-10, 1.608e-10, 2.2000000000000002e-10}, {1.4630000000000003e-10, 1.464e-10, 1.4630000000000003e-10, 1.4630000000000003e-10, 1.459e-10, 1.586e-10, 2.06e-10, 2.77e-10}, {2.4380000000000003e-10, 2.439e-10, 2.439e-10, 2.439e-10, 2.439e-10, 2.447e-10, 2.819e-10, 3.7380000000000004e-10}}; +double lookTrAxis_HA_X1_B_S_risingTransition(int iTr) {return trAxis_HA_X1_B_S_risingTransition[iTr];} +double lookCapAxis_HA_X1_B_S_risingTransition(int iCap) {return capAxis_HA_X1_B_S_risingTransition[iCap];} +double lookTable_HA_X1_B_S_risingTransition(int iTr, int iCap) {return table_HA_X1_B_S_risingTransition[iCap][iTr];} + +double trAxis_HA_X1_B_S_fallingTransition[8] = {7.5e-12, 1.5e-11, 3.0e-11, 6.0e-11, 1.2e-10, 2.4e-10, 4.8e-10, 9.6e-10}; +double capAxis_HA_X1_B_S_fallingTransition[6] = {4.0e-16, 8.0e-16, 1.6e-15, 3.2e-15, 6.4e-15, 1.28e-14}; +double table_HA_X1_B_S_fallingTransition[6][8] = {{2.78e-11, 2.78e-11, 2.78e-11, 2.78e-11, 2.95e-11, 4.5500000000000004e-11, 7.340000000000001e-11, 1.196e-10}, {2.98e-11, 2.98e-11, 2.98e-11, 2.99e-11, 3.15e-11, 4.7900000000000004e-11, 7.62e-11, 1.238e-10}, {3.39e-11, 3.39e-11, 3.3799999999999996e-11, 3.39e-11, 3.5700000000000003e-11, 5.240000000000001e-11, 8.200000000000001e-11, 1.316e-10}, {4.18e-11, 4.18e-11, 4.18e-11, 4.18e-11, 4.3100000000000005e-11, 6.06e-11, 9.2e-11, 1.454e-10}, {5.71e-11, 5.71e-11, 5.7000000000000003e-11, 5.7000000000000003e-11, 5.84e-11, 7.570000000000001e-11, 1.0960000000000001e-10, 1.6880000000000003e-10}, {8.87e-11, 8.87e-11, 8.87e-11, 8.860000000000001e-11, 9.09e-11, 1.0570000000000001e-10, 1.407e-10, 2.069e-10}}; +double lookTrAxis_HA_X1_B_S_fallingTransition(int iTr) {return trAxis_HA_X1_B_S_fallingTransition[iTr];} +double lookCapAxis_HA_X1_B_S_fallingTransition(int iCap) {return capAxis_HA_X1_B_S_fallingTransition[iCap];} +double lookTable_HA_X1_B_S_fallingTransition(int iTr, int iCap) {return table_HA_X1_B_S_fallingTransition[iCap][iTr];} + +double trAxis_INV_X1_A_ZN_risingDelay[8] = {7.5e-12, 1.5e-11, 3.0e-11, 6.0e-11, 1.2e-10, 2.4e-10, 4.8e-10, 9.6e-10}; +double capAxis_INV_X1_A_ZN_risingDelay[6] = {4.0e-16, 8.0e-16, 1.6e-15, 3.2e-15, 6.4e-15, 1.28e-14}; +double table_INV_X1_A_ZN_risingDelay[6][8] = {{1.6899999999999998e-11, 2.1000000000000002e-11, 2.8000000000000003e-11, 3.75e-11, 5.1400000000000005e-11, 7.32e-11, 1.0960000000000001e-10, 1.742e-10}, {2.1700000000000003e-11, 2.5600000000000004e-11, 3.3700000000000004e-11, 4.5100000000000005e-11, 6.12e-11, 8.57e-11, 1.253e-10, 1.9320000000000002e-10}, {3.1300000000000004e-11, 3.500000000000001e-11, 4.3100000000000005e-11, 5.8000000000000007e-11, 7.83e-11, 1.074e-10, 1.527e-10, 2.273e-10}, {5.01e-11, 5.37e-11, 6.160000000000001e-11, 7.820000000000001e-11, 1.0580000000000001e-10, 1.435e-10, 1.9860000000000002e-10, 2.854e-10}, {8.790000000000001e-11, 9.14e-11, 9.91e-11, 1.151e-10, 1.483e-10, 2.011e-10, 2.737e-10, 3.807e-10}, {1.6320000000000002e-10, 1.668e-10, 1.7430000000000003e-10, 1.898e-10, 2.219e-10, 2.8820000000000005e-10, 3.9150000000000004e-10, 5.338000000000001e-10}}; +double lookTrAxis_INV_X1_A_ZN_risingDelay(int iTr) {return trAxis_INV_X1_A_ZN_risingDelay[iTr];} +double lookCapAxis_INV_X1_A_ZN_risingDelay(int iCap) {return capAxis_INV_X1_A_ZN_risingDelay[iCap];} +double lookTable_INV_X1_A_ZN_risingDelay(int iTr, int iCap) {return table_INV_X1_A_ZN_risingDelay[iCap][iTr];} + +double trAxis_INV_X1_A_ZN_fallingDelay[8] = {7.5e-12, 1.5e-11, 3.0e-11, 6.0e-11, 1.2e-10, 2.4e-10, 4.8e-10, 9.6e-10}; +double capAxis_INV_X1_A_ZN_fallingDelay[6] = {4.0e-16, 8.0e-16, 1.6e-15, 3.2e-15, 6.4e-15, 1.28e-14}; +double table_INV_X1_A_ZN_fallingDelay[6][8] = {{1.0200000000000001e-11, 1.2800000000000002e-11, 1.53e-11, 1.6899999999999998e-11, 1.5800000000000003e-11, 8.000000000000001e-12, 1.51e-11, 6.96e-11}, {1.26e-11, 1.5699999999999998e-11, 1.9300000000000004e-11, 2.24e-11, 2.3300000000000003e-11, 1.8e-11, 1.9e-12, 5.2900000000000006e-11}, {1.73e-11, 2.07e-11, 2.6e-11, 3.17e-11, 3.58e-11, 3.4900000000000004e-11, 2.07e-11, 2.36e-11}, {2.6800000000000004e-11, 3.01e-11, 3.69e-11, 4.65e-11, 5.6200000000000004e-11, 6.230000000000001e-11, 5.7400000000000003e-11, 2.5000000000000004e-11}, {4.57e-11, 4.9000000000000005e-11, 5.5700000000000005e-11, 6.92e-11, 8.740000000000002e-11, 1.0470000000000001e-10, 1.147e-10, 1.0170000000000001e-10}, {8.33e-11, 8.66e-11, 9.320000000000001e-11, 1.0680000000000001e-10, 1.3400000000000003e-10, 1.6880000000000003e-10, 2.016e-10, 2.1900000000000002e-10}}; +double lookTrAxis_INV_X1_A_ZN_fallingDelay(int iTr) {return trAxis_INV_X1_A_ZN_fallingDelay[iTr];} +double lookCapAxis_INV_X1_A_ZN_fallingDelay(int iCap) {return capAxis_INV_X1_A_ZN_fallingDelay[iCap];} +double lookTable_INV_X1_A_ZN_fallingDelay(int iTr, int iCap) {return table_INV_X1_A_ZN_fallingDelay[iCap][iTr];} + +double trAxis_INV_X1_A_ZN_risingTransition[8] = {7.5e-12, 1.5e-11, 3.0e-11, 6.0e-11, 1.2e-10, 2.4e-10, 4.8e-10, 9.6e-10}; +double capAxis_INV_X1_A_ZN_risingTransition[6] = {4.0e-16, 8.0e-16, 1.6e-15, 3.2e-15, 6.4e-15, 1.28e-14}; +double table_INV_X1_A_ZN_risingTransition[6][8] = {{1.11e-11, 1.16e-11, 1.55e-11, 2.1700000000000003e-11, 3.1e-11, 4.6600000000000006e-11, 7.580000000000001e-11, 1.3370000000000001e-10}, {1.5699999999999998e-11, 1.5699999999999998e-11, 1.85e-11, 2.58e-11, 3.6400000000000005e-11, 5.31e-11, 8.300000000000001e-11, 1.407e-10}, {2.46e-11, 2.49e-11, 2.5700000000000002e-11, 3.2599999999999996e-11, 4.5900000000000004e-11, 6.500000000000001e-11, 9.67e-11, 1.5540000000000003e-10}, {4.2700000000000005e-11, 4.2700000000000005e-11, 4.2700000000000005e-11, 4.53e-11, 6.01e-11, 8.45e-11, 1.211e-10, 1.834e-10}, {7.840000000000001e-11, 7.840000000000001e-11, 7.83e-11, 7.840000000000001e-11, 8.490000000000001e-11, 1.147e-10, 1.619e-10, 2.333e-10}, {1.5e-10, 1.5e-10, 1.5e-10, 1.5e-10, 1.5e-10, 1.6430000000000002e-10, 2.2400000000000003e-10, 3.1650000000000004e-10}}; +double lookTrAxis_INV_X1_A_ZN_risingTransition(int iTr) {return trAxis_INV_X1_A_ZN_risingTransition[iTr];} +double lookCapAxis_INV_X1_A_ZN_risingTransition(int iCap) {return capAxis_INV_X1_A_ZN_risingTransition[iCap];} +double lookTable_INV_X1_A_ZN_risingTransition(int iTr, int iCap) {return table_INV_X1_A_ZN_risingTransition[iCap][iTr];} + +double trAxis_INV_X1_A_ZN_fallingTransition[8] = {7.5e-12, 1.5e-11, 3.0e-11, 6.0e-11, 1.2e-10, 2.4e-10, 4.8e-10, 9.6e-10}; +double capAxis_INV_X1_A_ZN_fallingTransition[6] = {4.0e-16, 8.0e-16, 1.6e-15, 3.2e-15, 6.4e-15, 1.28e-14}; +double table_INV_X1_A_ZN_fallingTransition[6][8] = {{5.3000000000000004e-12, 7.400000000000002e-12, 1.0700000000000001e-11, 1.62e-11, 2.5700000000000002e-11, 4.26e-11, 7.38e-11, 1.336e-10}, {7.2e-12, 8.7e-12, 1.26e-11, 1.86e-11, 2.8700000000000002e-11, 4.6600000000000006e-11, 7.890000000000001e-11, 1.3960000000000001e-10}, {1.13e-11, 1.17e-11, 1.62e-11, 2.3e-11, 3.42e-11, 5.3400000000000004e-11, 8.790000000000001e-11, 1.508e-10}, {1.95e-11, 1.9400000000000002e-11, 2.1400000000000002e-11, 2.95e-11, 4.2700000000000005e-11, 6.450000000000001e-11, 1.0230000000000001e-10, 1.6980000000000002e-10}, {3.5900000000000007e-11, 3.5900000000000007e-11, 3.6e-11, 4.02e-11, 5.6200000000000004e-11, 8.22e-11, 1.2520000000000002e-10, 1.999e-10}, {6.87e-11, 6.87e-11, 6.87e-11, 6.880000000000001e-11, 7.79e-11, 1.1010000000000001e-10, 1.615e-10, 2.4670000000000004e-10}}; +double lookTrAxis_INV_X1_A_ZN_fallingTransition(int iTr) {return trAxis_INV_X1_A_ZN_fallingTransition[iTr];} +double lookCapAxis_INV_X1_A_ZN_fallingTransition(int iCap) {return capAxis_INV_X1_A_ZN_fallingTransition[iCap];} +double lookTable_INV_X1_A_ZN_fallingTransition(int iTr, int iCap) {return table_INV_X1_A_ZN_fallingTransition[iCap][iTr];} + +double trAxis_INV_X16_A_ZN_risingDelay[8] = {7.5e-12, 1.5e-11, 3.0e-11, 6.0e-11, 1.2e-10, 2.4e-10, 4.8e-10, 9.6e-10}; +double capAxis_INV_X16_A_ZN_risingDelay[6] = {4.0e-16, 1.28e-14, 2.56e-14, 5.12e-14, 1.024e-13, 2.048e-13}; +double table_INV_X16_A_ZN_risingDelay[6][8] = {{1.15e-11, 1.49e-11, 1.95e-11, 2.64e-11, 3.740000000000001e-11, 5.5800000000000004e-11, 8.85e-11, 1.507e-10}, {2.0200000000000002e-11, 2.42e-11, 3.19e-11, 4.26e-11, 5.7800000000000003e-11, 8.15e-11, 1.204e-10, 1.8800000000000002e-10}, {2.93e-11, 3.31e-11, 4.130000000000001e-11, 5.5300000000000005e-11, 7.46e-11, 1.0280000000000001e-10, 1.4720000000000002e-10, 2.213e-10}, {4.74e-11, 5.11e-11, 5.89e-11, 7.54e-11, 1.0180000000000001e-10, 1.3810000000000002e-10, 1.92e-10, 2.7770000000000003e-10}, {8.33e-11, 8.69e-11, 9.460000000000001e-11, 1.105e-10, 1.435e-10, 1.9430000000000002e-10, 2.648e-10, 3.7e-10}, {1.5490000000000003e-10, 1.586e-10, 1.661e-10, 1.815e-10, 2.1360000000000002e-10, 2.7950000000000007e-10, 3.793e-10, 5.180000000000001e-10}}; +double lookTrAxis_INV_X16_A_ZN_risingDelay(int iTr) {return trAxis_INV_X16_A_ZN_risingDelay[iTr];} +double lookCapAxis_INV_X16_A_ZN_risingDelay(int iCap) {return capAxis_INV_X16_A_ZN_risingDelay[iCap];} +double lookTable_INV_X16_A_ZN_risingDelay(int iTr, int iCap) {return table_INV_X16_A_ZN_risingDelay[iCap][iTr];} + +double trAxis_INV_X16_A_ZN_fallingDelay[8] = {7.5e-12, 1.5e-11, 3.0e-11, 6.0e-11, 1.2e-10, 2.4e-10, 4.8e-10, 9.6e-10}; +double capAxis_INV_X16_A_ZN_fallingDelay[6] = {4.0e-16, 1.28e-14, 2.56e-14, 5.12e-14, 1.024e-13, 2.048e-13}; +double table_INV_X16_A_ZN_fallingDelay[6][8] = {{7.400000000000002e-12, 8.600000000000001e-12, 9.3e-12, 8.7e-12, 4.5e-12, 7.400000000000002e-12, 3.5300000000000003e-11, 9.510000000000001e-11}, {1.2200000000000002e-11, 1.51e-11, 1.8200000000000002e-11, 2.07e-11, 2.0600000000000002e-11, 1.4000000000000002e-11, 7.8e-12, 6.150000000000001e-11}, {1.67e-11, 2.01e-11, 2.5100000000000003e-11, 3.0e-11, 3.31e-11, 3.0800000000000006e-11, 1.46e-11, 3.27e-11}, {2.5600000000000004e-11, 2.9000000000000003e-11, 3.5700000000000003e-11, 4.4600000000000006e-11, 5.3000000000000004e-11, 5.76e-11, 5.0600000000000005e-11, 1.49e-11}, {4.3600000000000003e-11, 4.69e-11, 5.360000000000001e-11, 6.68e-11, 8.36e-11, 9.91e-11, 1.0650000000000001e-10, 8.970000000000001e-11}, {7.93e-11, 8.250000000000001e-11, 8.910000000000001e-11, 1.026e-10, 1.2920000000000003e-10, 1.6160000000000002e-10, 1.911e-10, 2.0390000000000001e-10}}; +double lookTrAxis_INV_X16_A_ZN_fallingDelay(int iTr) {return trAxis_INV_X16_A_ZN_fallingDelay[iTr];} +double lookCapAxis_INV_X16_A_ZN_fallingDelay(int iCap) {return capAxis_INV_X16_A_ZN_fallingDelay[iCap];} +double lookTable_INV_X16_A_ZN_fallingDelay(int iTr, int iCap) {return table_INV_X16_A_ZN_fallingDelay[iCap][iTr];} + +double trAxis_INV_X16_A_ZN_risingTransition[8] = {7.5e-12, 1.5e-11, 3.0e-11, 6.0e-11, 1.2e-10, 2.4e-10, 4.8e-10, 9.6e-10}; +double capAxis_INV_X16_A_ZN_risingTransition[6] = {4.0e-16, 1.28e-14, 2.56e-14, 5.12e-14, 1.024e-13, 2.048e-13}; +double table_INV_X16_A_ZN_risingTransition[6][8] = {{5.6e-12, 7.700000000000002e-12, 1.0800000000000001e-11, 1.5400000000000003e-11, 2.32e-11, 3.7900000000000006e-11, 6.690000000000001e-11, 1.267e-10}, {1.36e-11, 1.39e-11, 1.71e-11, 2.4100000000000003e-11, 3.41e-11, 5.0300000000000003e-11, 8.000000000000001e-11, 1.377e-10}, {2.22e-11, 2.22e-11, 2.3300000000000003e-11, 3.07e-11, 4.3200000000000003e-11, 6.19e-11, 9.310000000000001e-11, 1.5140000000000001e-10}, {3.94e-11, 3.94e-11, 3.93e-11, 4.250000000000001e-11, 5.76e-11, 8.110000000000001e-11, 1.166e-10, 1.7820000000000002e-10}, {7.340000000000001e-11, 7.340000000000001e-11, 7.340000000000001e-11, 7.340000000000001e-11, 8.1e-11, 1.109e-10, 1.563e-10, 2.2620000000000003e-10}, {1.414e-10, 1.414e-10, 1.414e-10, 1.414e-10, 1.414e-10, 1.5790000000000002e-10, 2.1730000000000001e-10, 3.068e-10}}; +double lookTrAxis_INV_X16_A_ZN_risingTransition(int iTr) {return trAxis_INV_X16_A_ZN_risingTransition[iTr];} +double lookCapAxis_INV_X16_A_ZN_risingTransition(int iCap) {return capAxis_INV_X16_A_ZN_risingTransition[iCap];} +double lookTable_INV_X16_A_ZN_risingTransition(int iTr, int iCap) {return table_INV_X16_A_ZN_risingTransition[iCap][iTr];} + +double trAxis_INV_X16_A_ZN_fallingTransition[8] = {7.5e-12, 1.5e-11, 3.0e-11, 6.0e-11, 1.2e-10, 2.4e-10, 4.8e-10, 9.6e-10}; +double capAxis_INV_X16_A_ZN_fallingTransition[6] = {4.0e-16, 1.28e-14, 2.56e-14, 5.12e-14, 1.024e-13, 2.048e-13}; +double table_INV_X16_A_ZN_fallingTransition[6][8] = {{3.6e-12, 5.2000000000000005e-12, 7.900000000000001e-12, 1.27e-11, 2.1200000000000002e-11, 3.6700000000000006e-11, 6.65e-11, 1.267e-10}, {6.3e-12, 8.1e-12, 1.17e-11, 1.7600000000000003e-11, 2.76e-11, 4.5100000000000005e-11, 7.7e-11, 1.373e-10}, {1.0100000000000001e-11, 1.0800000000000001e-11, 1.47e-11, 2.1600000000000002e-11, 3.29e-11, 5.1800000000000005e-11, 8.590000000000001e-11, 1.4820000000000002e-10}, {1.79e-11, 1.79e-11, 2.0000000000000002e-11, 2.8100000000000002e-11, 4.130000000000001e-11, 6.270000000000001e-11, 1.0000000000000002e-10, 1.667e-10}, {3.350000000000001e-11, 3.350000000000001e-11, 3.350000000000001e-11, 3.85e-11, 5.44e-11, 7.99e-11, 1.223e-10, 1.961e-10}, {6.47e-11, 6.47e-11, 6.47e-11, 6.500000000000001e-11, 7.520000000000001e-11, 1.0710000000000001e-10, 1.5740000000000002e-10, 2.415e-10}}; +double lookTrAxis_INV_X16_A_ZN_fallingTransition(int iTr) {return trAxis_INV_X16_A_ZN_fallingTransition[iTr];} +double lookCapAxis_INV_X16_A_ZN_fallingTransition(int iCap) {return capAxis_INV_X16_A_ZN_fallingTransition[iCap];} +double lookTable_INV_X16_A_ZN_fallingTransition(int iTr, int iCap) {return table_INV_X16_A_ZN_fallingTransition[iCap][iTr];} + +double trAxis_INV_X2_A_ZN_risingDelay[8] = {7.5e-12, 1.5e-11, 3.0e-11, 6.0e-11, 1.2e-10, 2.4e-10, 4.8e-10, 9.6e-10}; +double capAxis_INV_X2_A_ZN_risingDelay[6] = {4.0e-16, 1.6e-15, 3.2e-15, 6.4e-15, 1.28e-14, 2.56e-14}; +double table_INV_X2_A_ZN_risingDelay[6][8] = {{1.26e-11, 1.65e-11, 2.1800000000000002e-11, 2.94e-11, 4.1200000000000004e-11, 6.06e-11, 9.43e-11, 1.5690000000000002e-10}, {1.95e-11, 2.3500000000000003e-11, 3.12e-11, 4.17e-11, 5.6900000000000005e-11, 8.03e-11, 1.1880000000000002e-10, 1.86e-10}, {2.8600000000000003e-11, 3.2500000000000004e-11, 4.0800000000000004e-11, 5.480000000000001e-11, 7.4e-11, 1.021e-10, 1.4630000000000003e-10, 2.2000000000000002e-10}, {4.7000000000000006e-11, 5.0700000000000003e-11, 5.86e-11, 7.520000000000001e-11, 1.016e-10, 1.3800000000000001e-10, 1.918e-10, 2.774e-10}, {8.34e-11, 8.71e-11, 9.47e-11, 1.1070000000000002e-10, 1.438e-10, 1.9500000000000002e-10, 2.657e-10, 3.711e-10}, {1.5620000000000001e-10, 1.598e-10, 1.673e-10, 1.827e-10, 2.1490000000000003e-10, 2.8100000000000006e-10, 3.816e-10, 5.211e-10}}; +double lookTrAxis_INV_X2_A_ZN_risingDelay(int iTr) {return trAxis_INV_X2_A_ZN_risingDelay[iTr];} +double lookCapAxis_INV_X2_A_ZN_risingDelay(int iCap) {return capAxis_INV_X2_A_ZN_risingDelay[iCap];} +double lookTable_INV_X2_A_ZN_risingDelay(int iTr, int iCap) {return table_INV_X2_A_ZN_risingDelay[iCap][iTr];} + +double trAxis_INV_X2_A_ZN_fallingDelay[8] = {7.5e-12, 1.5e-11, 3.0e-11, 6.0e-11, 1.2e-10, 2.4e-10, 4.8e-10, 9.6e-10}; +double capAxis_INV_X2_A_ZN_fallingDelay[6] = {4.0e-16, 1.6e-15, 3.2e-15, 6.4e-15, 1.28e-14, 2.56e-14}; +double table_INV_X2_A_ZN_fallingDelay[6][8] = {{7.900000000000001e-12, 9.400000000000001e-12, 1.0700000000000001e-11, 1.0700000000000001e-11, 7.400000000000002e-12, 3.4e-12, 3.0e-11, 8.85e-11}, {1.15e-11, 1.4300000000000002e-11, 1.74e-11, 1.9800000000000002e-11, 1.9600000000000002e-11, 1.29e-11, 9.0e-12, 6.260000000000001e-11}, {1.6000000000000003e-11, 1.95e-11, 2.4400000000000004e-11, 2.92e-11, 3.24e-11, 3.0e-11, 1.38e-11, 3.3200000000000006e-11}, {2.52e-11, 2.8500000000000002e-11, 3.5200000000000005e-11, 4.41e-11, 5.2600000000000004e-11, 5.73e-11, 5.04e-11, 1.51e-11}, {4.33e-11, 4.6600000000000006e-11, 5.3300000000000006e-11, 6.660000000000001e-11, 8.36e-11, 9.930000000000001e-11, 1.07e-10, 9.080000000000001e-11}, {7.950000000000001e-11, 8.27e-11, 8.93e-11, 1.0280000000000001e-10, 1.2950000000000002e-10, 1.624e-10, 1.925e-10, 2.062e-10}}; +double lookTrAxis_INV_X2_A_ZN_fallingDelay(int iTr) {return trAxis_INV_X2_A_ZN_fallingDelay[iTr];} +double lookCapAxis_INV_X2_A_ZN_fallingDelay(int iCap) {return capAxis_INV_X2_A_ZN_fallingDelay[iCap];} +double lookTable_INV_X2_A_ZN_fallingDelay(int iTr, int iCap) {return table_INV_X2_A_ZN_fallingDelay[iCap][iTr];} + +double trAxis_INV_X2_A_ZN_risingTransition[8] = {7.5e-12, 1.5e-11, 3.0e-11, 6.0e-11, 1.2e-10, 2.4e-10, 4.8e-10, 9.6e-10}; +double capAxis_INV_X2_A_ZN_risingTransition[6] = {4.0e-16, 1.6e-15, 3.2e-15, 6.4e-15, 1.28e-14, 2.56e-14}; +double table_INV_X2_A_ZN_risingTransition[6][8] = {{7.000000000000001e-12, 8.7e-12, 1.23e-11, 1.73e-11, 2.55e-11, 4.0300000000000006e-11, 6.91e-11, 1.281e-10}, {1.36e-11, 1.38e-11, 1.71e-11, 2.4e-11, 3.39e-11, 5.01e-11, 7.960000000000001e-11, 1.372e-10}, {2.25e-11, 2.22e-11, 2.34e-11, 3.0900000000000004e-11, 4.3400000000000007e-11, 6.180000000000001e-11, 9.3e-11, 1.513e-10}, {3.9500000000000006e-11, 3.9600000000000004e-11, 3.9600000000000004e-11, 4.29e-11, 5.8000000000000007e-11, 8.13e-11, 1.17e-10, 1.785e-10}, {7.420000000000001e-11, 7.420000000000001e-11, 7.420000000000001e-11, 7.420000000000001e-11, 8.15e-11, 1.115e-10, 1.572e-10, 2.273e-10}, {1.432e-10, 1.432e-10, 1.432e-10, 1.432e-10, 1.432e-10, 1.5920000000000003e-10, 2.1870000000000003e-10, 3.09e-10}}; +double lookTrAxis_INV_X2_A_ZN_risingTransition(int iTr) {return trAxis_INV_X2_A_ZN_risingTransition[iTr];} +double lookCapAxis_INV_X2_A_ZN_risingTransition(int iCap) {return capAxis_INV_X2_A_ZN_risingTransition[iCap];} +double lookTable_INV_X2_A_ZN_risingTransition(int iTr, int iCap) {return table_INV_X2_A_ZN_risingTransition[iCap][iTr];} + +double trAxis_INV_X2_A_ZN_fallingTransition[8] = {7.5e-12, 1.5e-11, 3.0e-11, 6.0e-11, 1.2e-10, 2.4e-10, 4.8e-10, 9.6e-10}; +double capAxis_INV_X2_A_ZN_fallingTransition[6] = {4.0e-16, 1.6e-15, 3.2e-15, 6.4e-15, 1.28e-14, 2.56e-14}; +double table_INV_X2_A_ZN_fallingTransition[6][8] = {{4.000000000000001e-12, 5.8e-12, 8.7e-12, 1.3700000000000002e-11, 2.25e-11, 3.84e-11, 6.850000000000001e-11, 1.283e-10}, {6.3e-12, 8.300000000000001e-12, 1.17e-11, 1.7500000000000004e-11, 2.7400000000000004e-11, 4.48e-11, 7.660000000000001e-11, 1.3690000000000001e-10}, {1.0100000000000001e-11, 1.0900000000000001e-11, 1.49e-11, 2.19e-11, 3.27e-11, 5.1700000000000006e-11, 8.560000000000001e-11, 1.479e-10}, {1.8e-11, 1.8e-11, 2.01e-11, 2.8300000000000002e-11, 4.130000000000001e-11, 6.270000000000001e-11, 1.0000000000000002e-10, 1.667e-10}, {3.3799999999999996e-11, 3.3799999999999996e-11, 3.3799999999999996e-11, 3.87e-11, 5.4600000000000004e-11, 8.010000000000001e-11, 1.2250000000000002e-10, 1.9650000000000002e-10}, {6.53e-11, 6.53e-11, 6.53e-11, 6.55e-11, 7.56e-11, 1.075e-10, 1.581e-10, 2.423e-10}}; +double lookTrAxis_INV_X2_A_ZN_fallingTransition(int iTr) {return trAxis_INV_X2_A_ZN_fallingTransition[iTr];} +double lookCapAxis_INV_X2_A_ZN_fallingTransition(int iCap) {return capAxis_INV_X2_A_ZN_fallingTransition[iCap];} +double lookTable_INV_X2_A_ZN_fallingTransition(int iTr, int iCap) {return table_INV_X2_A_ZN_fallingTransition[iCap][iTr];} + +double trAxis_INV_X32_A_ZN_risingDelay[8] = {7.5e-12, 1.5e-11, 3.0e-11, 6.0e-11, 1.2e-10, 2.4e-10, 4.8e-10, 9.6e-10}; +double capAxis_INV_X32_A_ZN_risingDelay[6] = {4.0e-16, 2.56e-14, 5.12e-14, 1.024e-13, 2.048e-13, 4.096e-13}; +double table_INV_X32_A_ZN_risingDelay[6][8] = {{1.2e-11, 1.5400000000000003e-11, 1.9900000000000004e-11, 2.6800000000000004e-11, 3.77e-11, 5.6200000000000004e-11, 8.9e-11, 1.512e-10}, {2.1100000000000003e-11, 2.5000000000000004e-11, 3.2599999999999996e-11, 4.3200000000000003e-11, 5.86e-11, 8.23e-11, 1.213e-10, 1.8900000000000002e-10}, {3.02e-11, 3.39e-11, 4.2000000000000004e-11, 5.600000000000001e-11, 7.530000000000001e-11, 1.0360000000000001e-10, 1.481e-10, 2.2220000000000002e-10}, {4.8200000000000005e-11, 5.2e-11, 5.970000000000001e-11, 7.62e-11, 1.025e-10, 1.389e-10, 1.9280000000000002e-10, 2.7860000000000005e-10}, {8.430000000000001e-11, 8.790000000000001e-11, 9.54e-11, 1.113e-10, 1.443e-10, 1.951e-10, 2.655e-10, 3.7080000000000005e-10}, {1.56e-10, 1.596e-10, 1.671e-10, 1.8250000000000002e-10, 2.145e-10, 2.803e-10, 3.801e-10, 5.188000000000001e-10}}; +double lookTrAxis_INV_X32_A_ZN_risingDelay(int iTr) {return trAxis_INV_X32_A_ZN_risingDelay[iTr];} +double lookCapAxis_INV_X32_A_ZN_risingDelay(int iCap) {return capAxis_INV_X32_A_ZN_risingDelay[iCap];} +double lookTable_INV_X32_A_ZN_risingDelay(int iTr, int iCap) {return table_INV_X32_A_ZN_risingDelay[iCap][iTr];} + +double trAxis_INV_X32_A_ZN_fallingDelay[8] = {7.5e-12, 1.5e-11, 3.0e-11, 6.0e-11, 1.2e-10, 2.4e-10, 4.8e-10, 9.6e-10}; +double capAxis_INV_X32_A_ZN_fallingDelay[6] = {4.0e-16, 2.56e-14, 5.12e-14, 1.024e-13, 2.048e-13, 4.096e-13}; +double table_INV_X32_A_ZN_fallingDelay[6][8] = {{8.1e-12, 9.3e-12, 1.0100000000000001e-11, 9.400000000000001e-12, 5.3000000000000004e-12, 6.6e-12, 3.4500000000000004e-11, 9.420000000000001e-11}, {1.3100000000000002e-11, 1.6000000000000003e-11, 1.92e-11, 2.1700000000000003e-11, 2.1800000000000002e-11, 1.52e-11, 6.400000000000001e-12, 6.0e-11}, {1.77e-11, 2.1000000000000002e-11, 2.6e-11, 3.1e-11, 3.42e-11, 3.21e-11, 1.59e-11, 3.12e-11}, {2.6700000000000002e-11, 3.0e-11, 3.6700000000000006e-11, 4.57e-11, 5.4200000000000004e-11, 5.89e-11, 5.2e-11, 1.65e-11}, {4.47e-11, 4.7900000000000004e-11, 5.47e-11, 6.79e-11, 8.490000000000001e-11, 1.0050000000000001e-10, 1.08e-10, 9.150000000000001e-11}, {8.080000000000001e-11, 8.400000000000001e-11, 9.05e-11, 1.0390000000000001e-10, 1.3050000000000001e-10, 1.6320000000000002e-10, 1.929e-10, 2.059e-10}}; +double lookTrAxis_INV_X32_A_ZN_fallingDelay(int iTr) {return trAxis_INV_X32_A_ZN_fallingDelay[iTr];} +double lookCapAxis_INV_X32_A_ZN_fallingDelay(int iCap) {return capAxis_INV_X32_A_ZN_fallingDelay[iCap];} +double lookTable_INV_X32_A_ZN_fallingDelay(int iTr, int iCap) {return table_INV_X32_A_ZN_fallingDelay[iCap][iTr];} + +double trAxis_INV_X32_A_ZN_risingTransition[8] = {7.5e-12, 1.5e-11, 3.0e-11, 6.0e-11, 1.2e-10, 2.4e-10, 4.8e-10, 9.6e-10}; +double capAxis_INV_X32_A_ZN_risingTransition[6] = {4.0e-16, 2.56e-14, 5.12e-14, 1.024e-13, 2.048e-13, 4.096e-13}; +double table_INV_X32_A_ZN_risingTransition[6][8] = {{5.5e-12, 7.6e-12, 1.0600000000000001e-11, 1.51e-11, 2.3e-11, 3.78e-11, 6.690000000000001e-11, 1.268e-10}, {1.36e-11, 1.38e-11, 1.7000000000000003e-11, 2.4e-11, 3.4000000000000005e-11, 5.0300000000000003e-11, 8.000000000000001e-11, 1.379e-10}, {2.2100000000000003e-11, 2.22e-11, 2.32e-11, 3.07e-11, 4.3100000000000005e-11, 6.17e-11, 9.310000000000001e-11, 1.5160000000000002e-10}, {3.93e-11, 3.93e-11, 3.93e-11, 4.2700000000000005e-11, 5.750000000000001e-11, 8.1e-11, 1.167e-10, 1.783e-10}, {7.340000000000001e-11, 7.340000000000001e-11, 7.340000000000001e-11, 7.340000000000001e-11, 8.110000000000001e-11, 1.109e-10, 1.563e-10, 2.263e-10}, {1.416e-10, 1.416e-10, 1.416e-10, 1.415e-10, 1.416e-10, 1.5800000000000002e-10, 2.1740000000000002e-10, 3.0690000000000005e-10}}; +double lookTrAxis_INV_X32_A_ZN_risingTransition(int iTr) {return trAxis_INV_X32_A_ZN_risingTransition[iTr];} +double lookCapAxis_INV_X32_A_ZN_risingTransition(int iCap) {return capAxis_INV_X32_A_ZN_risingTransition[iCap];} +double lookTable_INV_X32_A_ZN_risingTransition(int iTr, int iCap) {return table_INV_X32_A_ZN_risingTransition[iCap][iTr];} + +double trAxis_INV_X32_A_ZN_fallingTransition[8] = {7.5e-12, 1.5e-11, 3.0e-11, 6.0e-11, 1.2e-10, 2.4e-10, 4.8e-10, 9.6e-10}; +double capAxis_INV_X32_A_ZN_fallingTransition[6] = {4.0e-16, 2.56e-14, 5.12e-14, 1.024e-13, 2.048e-13, 4.096e-13}; +double table_INV_X32_A_ZN_fallingTransition[6][8] = {{3.5000000000000004e-12, 5.2000000000000005e-12, 8.000000000000001e-12, 1.2800000000000002e-11, 2.13e-11, 3.6800000000000005e-11, 6.660000000000001e-11, 1.267e-10}, {6.400000000000001e-12, 8.000000000000001e-12, 1.18e-11, 1.77e-11, 2.7700000000000002e-11, 4.53e-11, 7.720000000000002e-11, 1.3760000000000002e-10}, {1.0200000000000001e-11, 1.0900000000000001e-11, 1.4800000000000003e-11, 2.1600000000000002e-11, 3.3e-11, 5.2e-11, 8.61e-11, 1.485e-10}, {1.8100000000000004e-11, 1.8100000000000004e-11, 2.01e-11, 2.82e-11, 4.130000000000001e-11, 6.279999999999999e-11, 1.003e-10, 1.671e-10}, {3.3799999999999996e-11, 3.3799999999999996e-11, 3.3799999999999996e-11, 3.87e-11, 5.4600000000000004e-11, 8.010000000000001e-11, 1.226e-10, 1.966e-10}, {6.53e-11, 6.53e-11, 6.54e-11, 6.560000000000001e-11, 7.570000000000001e-11, 1.074e-10, 1.5790000000000002e-10, 2.421e-10}}; +double lookTrAxis_INV_X32_A_ZN_fallingTransition(int iTr) {return trAxis_INV_X32_A_ZN_fallingTransition[iTr];} +double lookCapAxis_INV_X32_A_ZN_fallingTransition(int iCap) {return capAxis_INV_X32_A_ZN_fallingTransition[iCap];} +double lookTable_INV_X32_A_ZN_fallingTransition(int iTr, int iCap) {return table_INV_X32_A_ZN_fallingTransition[iCap][iTr];} + +double trAxis_INV_X4_A_ZN_risingDelay[8] = {7.5e-12, 1.5e-11, 3.0e-11, 6.0e-11, 1.2e-10, 2.4e-10, 4.8e-10, 9.6e-10}; +double capAxis_INV_X4_A_ZN_risingDelay[6] = {4.0e-16, 3.2e-15, 6.4e-15, 1.28e-14, 2.56e-14, 5.12e-14}; +double table_INV_X4_A_ZN_risingDelay[6][8] = {{1.0800000000000001e-11, 1.41e-11, 1.86e-11, 2.52e-11, 3.5900000000000007e-11, 5.4e-11, 8.66e-11, 1.4870000000000001e-10}, {1.8700000000000004e-11, 2.26e-11, 3.01e-11, 4.02e-11, 5.49e-11, 7.79e-11, 1.1600000000000001e-10, 1.828e-10}, {2.76e-11, 3.15e-11, 3.97e-11, 5.3400000000000004e-11, 7.21e-11, 9.97e-11, 1.4340000000000002e-10, 2.166e-10}, {4.57e-11, 4.9400000000000005e-11, 5.7200000000000007e-11, 7.38e-11, 9.97e-11, 1.3550000000000002e-10, 1.888e-10, 2.7380000000000003e-10}, {8.15e-11, 8.52e-11, 9.28e-11, 1.088e-10, 1.417e-10, 1.9210000000000001e-10, 2.621e-10, 3.6670000000000004e-10}, {1.5300000000000001e-10, 1.567e-10, 1.641e-10, 1.7960000000000003e-10, 2.117e-10, 2.7760000000000005e-10, 3.7700000000000004e-10, 5.151e-10}}; +double lookTrAxis_INV_X4_A_ZN_risingDelay(int iTr) {return trAxis_INV_X4_A_ZN_risingDelay[iTr];} +double lookCapAxis_INV_X4_A_ZN_risingDelay(int iCap) {return capAxis_INV_X4_A_ZN_risingDelay[iCap];} +double lookTable_INV_X4_A_ZN_risingDelay(int iTr, int iCap) {return table_INV_X4_A_ZN_risingDelay[iCap][iTr];} + +double trAxis_INV_X4_A_ZN_fallingDelay[8] = {7.5e-12, 1.5e-11, 3.0e-11, 6.0e-11, 1.2e-10, 2.4e-10, 4.8e-10, 9.6e-10}; +double capAxis_INV_X4_A_ZN_fallingDelay[6] = {4.0e-16, 3.2e-15, 6.4e-15, 1.28e-14, 2.56e-14, 5.12e-14}; +double table_INV_X4_A_ZN_fallingDelay[6][8] = {{6.6e-12, 7.700000000000002e-12, 8.200000000000001e-12, 7.400000000000002e-12, 3.0e-12, 9.200000000000001e-12, 3.7600000000000005e-11, 9.760000000000002e-11}, {1.11e-11, 1.38e-11, 1.65e-11, 1.86e-11, 1.8e-11, 1.0600000000000001e-11, 1.21e-11, 6.690000000000001e-11}, {1.56e-11, 1.89e-11, 2.36e-11, 2.8100000000000002e-11, 3.0800000000000006e-11, 2.78e-11, 1.0800000000000001e-11, 3.75e-11}, {2.4500000000000003e-11, 2.78e-11, 3.4500000000000004e-11, 4.3100000000000005e-11, 5.1e-11, 5.52e-11, 4.730000000000001e-11, 1.0600000000000001e-11}, {4.220000000000001e-11, 4.56e-11, 5.23e-11, 6.55e-11, 8.190000000000001e-11, 9.690000000000001e-11, 1.0360000000000001e-10, 8.6e-11}, {7.78e-11, 8.110000000000001e-11, 8.76e-11, 1.011e-10, 1.276e-10, 1.596e-10, 1.8840000000000002e-10, 2.004e-10}}; +double lookTrAxis_INV_X4_A_ZN_fallingDelay(int iTr) {return trAxis_INV_X4_A_ZN_fallingDelay[iTr];} +double lookCapAxis_INV_X4_A_ZN_fallingDelay(int iCap) {return capAxis_INV_X4_A_ZN_fallingDelay[iCap];} +double lookTable_INV_X4_A_ZN_fallingDelay(int iTr, int iCap) {return table_INV_X4_A_ZN_fallingDelay[iCap][iTr];} + +double trAxis_INV_X4_A_ZN_risingTransition[8] = {7.5e-12, 1.5e-11, 3.0e-11, 6.0e-11, 1.2e-10, 2.4e-10, 4.8e-10, 9.6e-10}; +double capAxis_INV_X4_A_ZN_risingTransition[6] = {4.0e-16, 3.2e-15, 6.4e-15, 1.28e-14, 2.56e-14, 5.12e-14}; +double table_INV_X4_A_ZN_risingTransition[6][8] = {{5.5e-12, 7.6e-12, 1.0500000000000001e-11, 1.5e-11, 2.2700000000000003e-11, 3.73e-11, 6.63e-11, 1.2620000000000001e-10}, {1.26e-11, 1.3e-11, 1.6600000000000003e-11, 2.32e-11, 3.2800000000000006e-11, 4.8700000000000004e-11, 7.810000000000001e-11, 1.358e-10}, {2.1100000000000003e-11, 2.1200000000000002e-11, 2.25e-11, 3.01e-11, 4.23e-11, 6.04e-11, 9.14e-11, 1.495e-10}, {3.81e-11, 3.82e-11, 3.82e-11, 4.17e-11, 5.680000000000001e-11, 7.99e-11, 1.151e-10, 1.764e-10}, {7.21e-11, 7.220000000000001e-11, 7.220000000000001e-11, 7.220000000000001e-11, 8.010000000000001e-11, 1.099e-10, 1.55e-10, 2.246e-10}, {1.4000000000000003e-10, 1.401e-10, 1.401e-10, 1.4000000000000003e-10, 1.402e-10, 1.5680000000000002e-10, 2.1620000000000001e-10, 3.054e-10}}; +double lookTrAxis_INV_X4_A_ZN_risingTransition(int iTr) {return trAxis_INV_X4_A_ZN_risingTransition[iTr];} +double lookCapAxis_INV_X4_A_ZN_risingTransition(int iCap) {return capAxis_INV_X4_A_ZN_risingTransition[iCap];} +double lookTable_INV_X4_A_ZN_risingTransition(int iTr, int iCap) {return table_INV_X4_A_ZN_risingTransition[iCap][iTr];} + +double trAxis_INV_X4_A_ZN_fallingTransition[8] = {7.5e-12, 1.5e-11, 3.0e-11, 6.0e-11, 1.2e-10, 2.4e-10, 4.8e-10, 9.6e-10}; +double capAxis_INV_X4_A_ZN_fallingTransition[6] = {4.0e-16, 3.2e-15, 6.4e-15, 1.28e-14, 2.56e-14, 5.12e-14}; +double table_INV_X4_A_ZN_fallingTransition[6][8] = {{3.5000000000000004e-12, 5.1000000000000005e-12, 7.700000000000002e-12, 1.24e-11, 2.0800000000000002e-11, 3.620000000000001e-11, 6.610000000000001e-11, 1.2620000000000001e-10}, {5.9e-12, 7.900000000000001e-12, 1.13e-11, 1.71e-11, 2.6700000000000002e-11, 4.4e-11, 7.55e-11, 1.357e-10}, {9.6e-12, 1.0500000000000001e-11, 1.44e-11, 2.1200000000000002e-11, 3.21e-11, 5.0900000000000006e-11, 8.46e-11, 1.4660000000000002e-10}, {1.73e-11, 1.73e-11, 1.95e-11, 2.7700000000000002e-11, 4.0700000000000006e-11, 6.19e-11, 9.89e-11, 1.654e-10}, {3.2800000000000006e-11, 3.2800000000000006e-11, 3.2800000000000006e-11, 3.8000000000000004e-11, 5.4e-11, 7.920000000000001e-11, 1.213e-10, 1.949e-10}, {6.390000000000001e-11, 6.390000000000001e-11, 6.38e-11, 6.41e-11, 7.46e-11, 1.064e-10, 1.565e-10, 2.404e-10}}; +double lookTrAxis_INV_X4_A_ZN_fallingTransition(int iTr) {return trAxis_INV_X4_A_ZN_fallingTransition[iTr];} +double lookCapAxis_INV_X4_A_ZN_fallingTransition(int iCap) {return capAxis_INV_X4_A_ZN_fallingTransition[iCap];} +double lookTable_INV_X4_A_ZN_fallingTransition(int iTr, int iCap) {return table_INV_X4_A_ZN_fallingTransition[iCap][iTr];} + +double trAxis_INV_X8_A_ZN_risingDelay[8] = {7.5e-12, 1.5e-11, 3.0e-11, 6.0e-11, 1.2e-10, 2.4e-10, 4.8e-10, 9.6e-10}; +double capAxis_INV_X8_A_ZN_risingDelay[6] = {4.0e-16, 6.4e-15, 1.28e-14, 2.56e-14, 5.12e-14, 1.024e-13}; +double table_INV_X8_A_ZN_risingDelay[6][8] = {{1.14e-11, 1.5e-11, 1.97e-11, 2.66e-11, 3.7600000000000005e-11, 5.6200000000000004e-11, 8.910000000000001e-11, 1.5140000000000001e-10}, {1.9900000000000004e-11, 2.3800000000000004e-11, 3.1600000000000006e-11, 4.220000000000001e-11, 5.7400000000000003e-11, 8.1e-11, 1.1980000000000002e-10, 1.8740000000000002e-10}, {2.8900000000000002e-11, 3.27e-11, 4.09e-11, 5.5000000000000004e-11, 7.420000000000001e-11, 1.0230000000000001e-10, 1.467e-10, 2.2070000000000002e-10}, {4.69e-11, 5.0700000000000003e-11, 5.85e-11, 7.51e-11, 1.0140000000000001e-10, 1.377e-10, 1.915e-10, 2.7720000000000004e-10}, {8.28e-11, 8.65e-11, 9.41e-11, 1.1000000000000001e-10, 1.431e-10, 1.939e-10, 2.643e-10, 3.695e-10}, {1.5440000000000003e-10, 1.581e-10, 1.6550000000000002e-10, 1.81e-10, 2.1300000000000001e-10, 2.79e-10, 3.788e-10, 5.175e-10}}; +double lookTrAxis_INV_X8_A_ZN_risingDelay(int iTr) {return trAxis_INV_X8_A_ZN_risingDelay[iTr];} +double lookCapAxis_INV_X8_A_ZN_risingDelay(int iCap) {return capAxis_INV_X8_A_ZN_risingDelay[iCap];} +double lookTable_INV_X8_A_ZN_risingDelay(int iTr, int iCap) {return table_INV_X8_A_ZN_risingDelay[iCap][iTr];} + +double trAxis_INV_X8_A_ZN_fallingDelay[8] = {7.5e-12, 1.5e-11, 3.0e-11, 6.0e-11, 1.2e-10, 2.4e-10, 4.8e-10, 9.6e-10}; +double capAxis_INV_X8_A_ZN_fallingDelay[6] = {4.0e-16, 6.4e-15, 1.28e-14, 2.56e-14, 5.12e-14, 1.024e-13}; +double table_INV_X8_A_ZN_fallingDelay[6][8] = {{7.100000000000001e-12, 8.4e-12, 9.200000000000001e-12, 8.600000000000001e-12, 4.5e-12, 7.3e-12, 3.5200000000000005e-11, 9.49e-11}, {1.18e-11, 1.47e-11, 1.7800000000000003e-11, 2.01e-11, 2.0000000000000002e-11, 1.33e-11, 8.600000000000001e-12, 6.260000000000001e-11}, {1.6299999999999998e-11, 1.97e-11, 2.46e-11, 2.94e-11, 3.24e-11, 3.01e-11, 1.3700000000000002e-11, 3.3799999999999996e-11}, {2.52e-11, 2.8500000000000002e-11, 3.5300000000000003e-11, 4.41e-11, 5.240000000000001e-11, 5.6900000000000005e-11, 4.9700000000000007e-11, 1.3700000000000002e-11}, {4.3e-11, 4.6300000000000004e-11, 5.3000000000000004e-11, 6.63e-11, 8.300000000000001e-11, 9.83e-11, 1.055e-10, 8.85e-11}, {7.870000000000001e-11, 8.190000000000001e-11, 8.85e-11, 1.019e-10, 1.2850000000000002e-10, 1.608e-10, 1.9000000000000002e-10, 2.0240000000000002e-10}}; +double lookTrAxis_INV_X8_A_ZN_fallingDelay(int iTr) {return trAxis_INV_X8_A_ZN_fallingDelay[iTr];} +double lookCapAxis_INV_X8_A_ZN_fallingDelay(int iCap) {return capAxis_INV_X8_A_ZN_fallingDelay[iCap];} +double lookTable_INV_X8_A_ZN_fallingDelay(int iTr, int iCap) {return table_INV_X8_A_ZN_fallingDelay[iCap][iTr];} + +double trAxis_INV_X8_A_ZN_risingTransition[8] = {7.5e-12, 1.5e-11, 3.0e-11, 6.0e-11, 1.2e-10, 2.4e-10, 4.8e-10, 9.6e-10}; +double capAxis_INV_X8_A_ZN_risingTransition[6] = {4.0e-16, 6.4e-15, 1.28e-14, 2.56e-14, 5.12e-14, 1.024e-13}; +double table_INV_X8_A_ZN_risingTransition[6][8] = {{5.8e-12, 7.900000000000001e-12, 1.11e-11, 1.5699999999999998e-11, 2.3500000000000003e-11, 3.82e-11, 6.71e-11, 1.268e-10}, {1.36e-11, 1.38e-11, 1.71e-11, 2.4100000000000003e-11, 3.41e-11, 5.0300000000000003e-11, 7.98e-11, 1.3760000000000002e-10}, {2.22e-11, 2.2100000000000003e-11, 2.3300000000000003e-11, 3.07e-11, 4.33e-11, 6.180000000000001e-11, 9.3e-11, 1.513e-10}, {3.93e-11, 3.93e-11, 3.9200000000000004e-11, 4.250000000000001e-11, 5.76e-11, 8.1e-11, 1.166e-10, 1.78e-10}, {7.330000000000001e-11, 7.330000000000001e-11, 7.32e-11, 7.330000000000001e-11, 8.09e-11, 1.1080000000000001e-10, 1.5620000000000001e-10, 2.261e-10}, {1.4120000000000001e-10, 1.4120000000000001e-10, 1.4120000000000001e-10, 1.4120000000000001e-10, 1.4130000000000002e-10, 1.577e-10, 2.171e-10, 3.066e-10}}; +double lookTrAxis_INV_X8_A_ZN_risingTransition(int iTr) {return trAxis_INV_X8_A_ZN_risingTransition[iTr];} +double lookCapAxis_INV_X8_A_ZN_risingTransition(int iCap) {return capAxis_INV_X8_A_ZN_risingTransition[iCap];} +double lookTable_INV_X8_A_ZN_risingTransition(int iTr, int iCap) {return table_INV_X8_A_ZN_risingTransition[iCap][iTr];} + +double trAxis_INV_X8_A_ZN_fallingTransition[8] = {7.5e-12, 1.5e-11, 3.0e-11, 6.0e-11, 1.2e-10, 2.4e-10, 4.8e-10, 9.6e-10}; +double capAxis_INV_X8_A_ZN_fallingTransition[6] = {4.0e-16, 6.4e-15, 1.28e-14, 2.56e-14, 5.12e-14, 1.024e-13}; +double table_INV_X8_A_ZN_fallingTransition[6][8] = {{3.700000000000001e-12, 5.3000000000000004e-12, 8.000000000000001e-12, 1.2800000000000002e-11, 2.13e-11, 3.6800000000000005e-11, 6.67e-11, 1.268e-10}, {6.3e-12, 8.1e-12, 1.18e-11, 1.7600000000000003e-11, 2.7500000000000002e-11, 4.5e-11, 7.68e-11, 1.371e-10}, {1.0000000000000001e-11, 1.0800000000000001e-11, 1.47e-11, 2.1600000000000002e-11, 3.2800000000000006e-11, 5.1700000000000006e-11, 8.57e-11, 1.479e-10}, {1.7800000000000003e-11, 1.7800000000000003e-11, 1.9900000000000004e-11, 2.8100000000000002e-11, 4.1200000000000004e-11, 6.25e-11, 9.980000000000001e-11, 1.6650000000000002e-10}, {3.3300000000000004e-11, 3.34e-11, 3.34e-11, 3.84e-11, 5.43e-11, 7.97e-11, 1.22e-10, 1.958e-10}, {6.44e-11, 6.44e-11, 6.44e-11, 6.47e-11, 7.5e-11, 1.069e-10, 1.571e-10, 2.411e-10}}; +double lookTrAxis_INV_X8_A_ZN_fallingTransition(int iTr) {return trAxis_INV_X8_A_ZN_fallingTransition[iTr];} +double lookCapAxis_INV_X8_A_ZN_fallingTransition(int iCap) {return capAxis_INV_X8_A_ZN_fallingTransition[iCap];} +double lookTable_INV_X8_A_ZN_fallingTransition(int iTr, int iCap) {return table_INV_X8_A_ZN_fallingTransition[iCap][iTr];} + +double trAxis_NAND2_X1_A1_ZN_risingDelay[8] = {7.5e-12, 1.5e-11, 3.0e-11, 6.0e-11, 1.2e-10, 2.4e-10, 4.8e-10, 9.6e-10}; +double capAxis_NAND2_X1_A1_ZN_risingDelay[6] = {4.0e-16, 8.0e-16, 1.6e-15, 3.2e-15, 6.4e-15, 1.28e-14}; +double table_NAND2_X1_A1_ZN_risingDelay[6][8] = {{2.4e-11, 2.7900000000000002e-11, 3.6100000000000003e-11, 4.8700000000000004e-11, 6.690000000000001e-11, 9.500000000000001e-11, 1.4080000000000002e-10, 2.194e-10}, {2.88e-11, 3.2599999999999996e-11, 4.0800000000000004e-11, 5.510000000000001e-11, 7.51e-11, 1.056e-10, 1.543e-10, 2.363e-10}, {3.8300000000000006e-11, 4.2000000000000004e-11, 5.01e-11, 6.63e-11, 9.01e-11, 1.2460000000000001e-10, 1.786e-10, 2.673e-10}, {5.7400000000000003e-11, 6.09e-11, 6.87e-11, 8.52e-11, 1.153e-10, 1.576e-10, 2.2070000000000002e-10, 3.2100000000000003e-10}, {9.520000000000002e-11, 9.87e-11, 1.0630000000000001e-10, 1.222e-10, 1.555e-10, 2.119e-10, 2.9120000000000004e-10, 4.11e-10}, {1.706e-10, 1.742e-10, 1.8160000000000002e-10, 1.9710000000000002e-10, 2.292e-10, 2.961e-10, 4.0450000000000005e-10, 5.575e-10}}; +double lookTrAxis_NAND2_X1_A1_ZN_risingDelay(int iTr) {return trAxis_NAND2_X1_A1_ZN_risingDelay[iTr];} +double lookCapAxis_NAND2_X1_A1_ZN_risingDelay(int iCap) {return capAxis_NAND2_X1_A1_ZN_risingDelay[iCap];} +double lookTable_NAND2_X1_A1_ZN_risingDelay(int iTr, int iCap) {return table_NAND2_X1_A1_ZN_risingDelay[iCap][iTr];} + +double trAxis_NAND2_X1_A1_ZN_fallingDelay[8] = {7.5e-12, 1.5e-11, 3.0e-11, 6.0e-11, 1.2e-10, 2.4e-10, 4.8e-10, 9.6e-10}; +double capAxis_NAND2_X1_A1_ZN_fallingDelay[6] = {4.0e-16, 8.0e-16, 1.6e-15, 3.2e-15, 6.4e-15, 1.28e-14}; +double table_NAND2_X1_A1_ZN_fallingDelay[6][8] = {{1.53e-11, 1.85e-11, 2.28e-11, 2.6500000000000002e-11, 2.7700000000000002e-11, 2.2100000000000003e-11, 0.0, 5.6500000000000005e-11}, {1.8e-11, 2.1100000000000003e-11, 2.6300000000000002e-11, 3.1399999999999996e-11, 3.43e-11, 3.0900000000000004e-11, 1.1900000000000002e-11, 4.1600000000000004e-11}, {2.36e-11, 2.66e-11, 3.2599999999999996e-11, 3.980000000000001e-11, 4.5900000000000004e-11, 4.64e-11, 3.27e-11, 1.4200000000000002e-11}, {3.4500000000000004e-11, 3.75e-11, 4.3600000000000003e-11, 5.4500000000000006e-11, 6.57e-11, 7.290000000000001e-11, 6.800000000000001e-11, 3.2599999999999996e-11}, {5.6200000000000004e-11, 5.920000000000001e-11, 6.53e-11, 7.79e-11, 9.740000000000001e-11, 1.158e-10, 1.2540000000000003e-10, 1.0920000000000001e-10}, {9.96e-11, 1.026e-10, 1.085e-10, 1.209e-10, 1.465e-10, 1.8260000000000002e-10, 2.153e-10, 2.294e-10}}; +double lookTrAxis_NAND2_X1_A1_ZN_fallingDelay(int iTr) {return trAxis_NAND2_X1_A1_ZN_fallingDelay[iTr];} +double lookCapAxis_NAND2_X1_A1_ZN_fallingDelay(int iCap) {return capAxis_NAND2_X1_A1_ZN_fallingDelay[iCap];} +double lookTable_NAND2_X1_A1_ZN_fallingDelay(int iTr, int iCap) {return table_NAND2_X1_A1_ZN_fallingDelay[iCap][iTr];} + +double trAxis_NAND2_X1_A1_ZN_risingTransition[8] = {7.5e-12, 1.5e-11, 3.0e-11, 6.0e-11, 1.2e-10, 2.4e-10, 4.8e-10, 9.6e-10}; +double capAxis_NAND2_X1_A1_ZN_risingTransition[6] = {4.0e-16, 8.0e-16, 1.6e-15, 3.2e-15, 6.4e-15, 1.28e-14}; +double table_NAND2_X1_A1_ZN_risingTransition[6][8] = {{1.7500000000000004e-11, 1.7500000000000004e-11, 1.9600000000000002e-11, 2.7100000000000002e-11, 3.81e-11, 5.5700000000000005e-11, 8.7e-11, 1.459e-10}, {2.2100000000000003e-11, 2.2100000000000003e-11, 2.32e-11, 3.05e-11, 4.2700000000000005e-11, 6.13e-11, 9.340000000000001e-11, 1.5300000000000001e-10}, {3.12e-11, 3.1300000000000004e-11, 3.15e-11, 3.6700000000000006e-11, 5.0900000000000006e-11, 7.180000000000001e-11, 1.0570000000000001e-10, 1.668e-10}, {4.9100000000000004e-11, 4.9100000000000004e-11, 4.9100000000000004e-11, 5.0600000000000005e-11, 6.41e-11, 8.980000000000002e-11, 1.281e-10, 1.93e-10}, {8.480000000000001e-11, 8.490000000000001e-11, 8.480000000000001e-11, 8.480000000000001e-11, 8.980000000000002e-11, 1.186e-10, 1.6650000000000002e-10, 2.3980000000000004e-10}, {1.565e-10, 1.565e-10, 1.565e-10, 1.565e-10, 1.5640000000000002e-10, 1.689e-10, 2.2710000000000002e-10, 3.196e-10}}; +double lookTrAxis_NAND2_X1_A1_ZN_risingTransition(int iTr) {return trAxis_NAND2_X1_A1_ZN_risingTransition[iTr];} +double lookCapAxis_NAND2_X1_A1_ZN_risingTransition(int iCap) {return capAxis_NAND2_X1_A1_ZN_risingTransition[iCap];} +double lookTable_NAND2_X1_A1_ZN_risingTransition(int iTr, int iCap) {return table_NAND2_X1_A1_ZN_risingTransition[iCap][iTr];} + +double trAxis_NAND2_X1_A1_ZN_fallingTransition[8] = {7.5e-12, 1.5e-11, 3.0e-11, 6.0e-11, 1.2e-10, 2.4e-10, 4.8e-10, 9.6e-10}; +double capAxis_NAND2_X1_A1_ZN_fallingTransition[6] = {4.0e-16, 8.0e-16, 1.6e-15, 3.2e-15, 6.4e-15, 1.28e-14}; +double table_NAND2_X1_A1_ZN_fallingTransition[6][8] = {{1.0000000000000001e-11, 1.0700000000000001e-11, 1.44e-11, 2.0800000000000002e-11, 3.1600000000000006e-11, 5.0300000000000003e-11, 8.37e-11, 1.454e-10}, {1.2500000000000002e-11, 1.3e-11, 1.6400000000000003e-11, 2.31e-11, 3.4400000000000005e-11, 5.390000000000001e-11, 8.85e-11, 1.5160000000000002e-10}, {1.73e-11, 1.7200000000000003e-11, 1.97e-11, 2.7300000000000002e-11, 3.9500000000000006e-11, 6.05e-11, 9.71e-11, 1.6270000000000002e-10}, {2.6700000000000002e-11, 2.6700000000000002e-11, 2.7300000000000002e-11, 3.41e-11, 4.84e-11, 7.16e-11, 1.115e-10, 1.819e-10}, {4.56e-11, 4.5500000000000004e-11, 4.5500000000000004e-11, 4.7800000000000006e-11, 6.270000000000001e-11, 9.0e-11, 1.3519999999999998e-10, 2.129e-10}, {8.300000000000001e-11, 8.300000000000001e-11, 8.300000000000001e-11, 8.300000000000001e-11, 8.910000000000001e-11, 1.2e-10, 1.735e-10, 2.621e-10}}; +double lookTrAxis_NAND2_X1_A1_ZN_fallingTransition(int iTr) {return trAxis_NAND2_X1_A1_ZN_fallingTransition[iTr];} +double lookCapAxis_NAND2_X1_A1_ZN_fallingTransition(int iCap) {return capAxis_NAND2_X1_A1_ZN_fallingTransition[iCap];} +double lookTable_NAND2_X1_A1_ZN_fallingTransition(int iTr, int iCap) {return table_NAND2_X1_A1_ZN_fallingTransition[iCap][iTr];} + +double trAxis_NAND2_X1_A2_ZN_risingDelay[8] = {7.5e-12, 1.5e-11, 3.0e-11, 6.0e-11, 1.2e-10, 2.4e-10, 4.8e-10, 9.6e-10}; +double capAxis_NAND2_X1_A2_ZN_risingDelay[6] = {4.0e-16, 8.0e-16, 1.6e-15, 3.2e-15, 6.4e-15, 1.28e-14}; +double table_NAND2_X1_A2_ZN_risingDelay[6][8] = {{3.51e-11, 3.89e-11, 4.69e-11, 6.3e-11, 8.63e-11, 1.208e-10, 1.759e-10, 2.698e-10}, {3.99e-11, 4.370000000000001e-11, 5.1700000000000006e-11, 6.82e-11, 9.340000000000001e-11, 1.2989999999999999e-10, 1.877e-10, 2.844e-10}, {4.96e-11, 5.3300000000000006e-11, 6.12e-11, 7.79e-11, 1.064e-10, 1.469e-10, 2.0910000000000003e-10, 3.1180000000000005e-10}, {6.880000000000001e-11, 7.240000000000002e-11, 8.010000000000001e-11, 9.65e-11, 1.2900000000000002e-10, 1.77e-10, 2.476e-10, 3.6030000000000004e-10}, {1.069e-10, 1.104e-10, 1.18e-10, 1.339e-10, 1.671e-10, 2.2770000000000003e-10, 3.137e-10, 4.441e-10}, {1.8250000000000002e-10, 1.861e-10, 1.9350000000000003e-10, 2.0910000000000003e-10, 2.412e-10, 3.082e-10, 4.22e-10, 5.84e-10}}; +double lookTrAxis_NAND2_X1_A2_ZN_risingDelay(int iTr) {return trAxis_NAND2_X1_A2_ZN_risingDelay[iTr];} +double lookCapAxis_NAND2_X1_A2_ZN_risingDelay(int iCap) {return capAxis_NAND2_X1_A2_ZN_risingDelay[iCap];} +double lookTable_NAND2_X1_A2_ZN_risingDelay(int iTr, int iCap) {return table_NAND2_X1_A2_ZN_risingDelay[iCap][iTr];} + +double trAxis_NAND2_X1_A2_ZN_fallingDelay[8] = {7.5e-12, 1.5e-11, 3.0e-11, 6.0e-11, 1.2e-10, 2.4e-10, 4.8e-10, 9.6e-10}; +double capAxis_NAND2_X1_A2_ZN_fallingDelay[6] = {4.0e-16, 8.0e-16, 1.6e-15, 3.2e-15, 6.4e-15, 1.28e-14}; +double table_NAND2_X1_A2_ZN_fallingDelay[6][8] = {{2.0000000000000002e-11, 2.28e-11, 2.72e-11, 3.21e-11, 3.5300000000000003e-11, 3.19e-11, 1.32e-11, 4.0000000000000004e-11}, {2.2700000000000003e-11, 2.5600000000000004e-11, 3.03e-11, 3.6100000000000003e-11, 4.09e-11, 3.980000000000001e-11, 2.4100000000000003e-11, 2.46e-11}, {2.82e-11, 3.1e-11, 3.6100000000000003e-11, 4.3200000000000003e-11, 5.0700000000000003e-11, 5.3800000000000004e-11, 4.3600000000000003e-11, 2.1e-12}, {3.9e-11, 4.1900000000000005e-11, 4.7000000000000006e-11, 5.61e-11, 6.740000000000001e-11, 7.710000000000001e-11, 7.630000000000001e-11, 4.7100000000000004e-11}, {6.08e-11, 6.36e-11, 6.87e-11, 7.890000000000001e-11, 9.500000000000001e-11, 1.1430000000000001e-10, 1.281e-10, 1.191e-10}, {1.0420000000000001e-10, 1.0710000000000001e-10, 1.122e-10, 1.224e-10, 1.42e-10, 1.7240000000000002e-10, 2.0710000000000001e-10, 2.29e-10}}; +double lookTrAxis_NAND2_X1_A2_ZN_fallingDelay(int iTr) {return trAxis_NAND2_X1_A2_ZN_fallingDelay[iTr];} +double lookCapAxis_NAND2_X1_A2_ZN_fallingDelay(int iCap) {return capAxis_NAND2_X1_A2_ZN_fallingDelay[iCap];} +double lookTable_NAND2_X1_A2_ZN_fallingDelay(int iTr, int iCap) {return table_NAND2_X1_A2_ZN_fallingDelay[iCap][iTr];} + +double trAxis_NAND2_X1_A2_ZN_risingTransition[8] = {7.5e-12, 1.5e-11, 3.0e-11, 6.0e-11, 1.2e-10, 2.4e-10, 4.8e-10, 9.6e-10}; +double capAxis_NAND2_X1_A2_ZN_risingTransition[6] = {4.0e-16, 8.0e-16, 1.6e-15, 3.2e-15, 6.4e-15, 1.28e-14}; +double table_NAND2_X1_A2_ZN_risingTransition[6][8] = {{2.46e-11, 2.46e-11, 2.4700000000000003e-11, 3.0e-11, 4.21e-11, 5.9e-11, 8.540000000000001e-11, 1.31e-10}, {2.92e-11, 2.92e-11, 2.92e-11, 3.3300000000000004e-11, 4.64e-11, 6.500000000000001e-11, 9.3e-11, 1.406e-10}, {3.85e-11, 3.84e-11, 3.85e-11, 4.0700000000000006e-11, 5.4200000000000004e-11, 7.56e-11, 1.0680000000000001e-10, 1.5790000000000002e-10}, {5.6500000000000005e-11, 5.64e-11, 5.64e-11, 5.6900000000000005e-11, 6.700000000000001e-11, 9.35e-11, 1.3070000000000002e-10, 1.881e-10}, {9.24e-11, 9.23e-11, 9.24e-11, 9.24e-11, 9.53e-11, 1.216e-10, 1.699e-10, 2.3910000000000003e-10}, {1.642e-10, 1.642e-10, 1.642e-10, 1.642e-10, 1.6430000000000002e-10, 1.74e-10, 2.302e-10, 3.217e-10}}; +double lookTrAxis_NAND2_X1_A2_ZN_risingTransition(int iTr) {return trAxis_NAND2_X1_A2_ZN_risingTransition[iTr];} +double lookCapAxis_NAND2_X1_A2_ZN_risingTransition(int iCap) {return capAxis_NAND2_X1_A2_ZN_risingTransition[iCap];} +double lookTable_NAND2_X1_A2_ZN_risingTransition(int iTr, int iCap) {return table_NAND2_X1_A2_ZN_risingTransition[iCap][iTr];} + +double trAxis_NAND2_X1_A2_ZN_fallingTransition[8] = {7.5e-12, 1.5e-11, 3.0e-11, 6.0e-11, 1.2e-10, 2.4e-10, 4.8e-10, 9.6e-10}; +double capAxis_NAND2_X1_A2_ZN_fallingTransition[6] = {4.0e-16, 8.0e-16, 1.6e-15, 3.2e-15, 6.4e-15, 1.28e-14}; +double table_NAND2_X1_A2_ZN_fallingTransition[6][8] = {{1.0100000000000001e-11, 1.0200000000000001e-11, 1.1900000000000002e-11, 1.6299999999999998e-11, 2.4500000000000003e-11, 3.94e-11, 6.53e-11, 1.0900000000000001e-10}, {1.26e-11, 1.26e-11, 1.41e-11, 1.83e-11, 2.6800000000000004e-11, 4.2000000000000004e-11, 6.86e-11, 1.137e-10}, {1.73e-11, 1.7200000000000003e-11, 1.8200000000000002e-11, 2.25e-11, 3.12e-11, 4.7000000000000006e-11, 7.49e-11, 1.222e-10}, {2.6700000000000002e-11, 2.6800000000000004e-11, 2.6900000000000002e-11, 3.02e-11, 3.8800000000000004e-11, 5.5800000000000004e-11, 8.6e-11, 1.373e-10}, {4.5500000000000004e-11, 4.56e-11, 4.5500000000000004e-11, 4.6600000000000006e-11, 5.390000000000001e-11, 7.140000000000001e-11, 1.046e-10, 1.62e-10}, {8.300000000000001e-11, 8.300000000000001e-11, 8.300000000000001e-11, 8.300000000000001e-11, 8.58e-11, 1.0140000000000001e-10, 1.366e-10, 2.016e-10}}; +double lookTrAxis_NAND2_X1_A2_ZN_fallingTransition(int iTr) {return trAxis_NAND2_X1_A2_ZN_fallingTransition[iTr];} +double lookCapAxis_NAND2_X1_A2_ZN_fallingTransition(int iCap) {return capAxis_NAND2_X1_A2_ZN_fallingTransition[iCap];} +double lookTable_NAND2_X1_A2_ZN_fallingTransition(int iTr, int iCap) {return table_NAND2_X1_A2_ZN_fallingTransition[iCap][iTr];} + +double trAxis_NAND2_X2_A1_ZN_risingDelay[8] = {7.5e-12, 1.5e-11, 3.0e-11, 6.0e-11, 1.2e-10, 2.4e-10, 4.8e-10, 9.6e-10}; +double capAxis_NAND2_X2_A1_ZN_risingDelay[6] = {4.0e-16, 1.6e-15, 3.2e-15, 6.4e-15, 1.28e-14, 2.56e-14}; +double table_NAND2_X2_A1_ZN_risingDelay[6][8] = {{1.8e-11, 2.2e-11, 2.93e-11, 3.9600000000000004e-11, 5.52e-11, 8.000000000000001e-11, 1.215e-10, 1.9500000000000002e-10}, {2.5000000000000004e-11, 2.88e-11, 3.7100000000000006e-11, 5.000000000000001e-11, 6.84e-11, 9.68e-11, 1.43e-10, 2.2160000000000002e-10}, {3.4400000000000005e-11, 3.8000000000000004e-11, 4.610000000000001e-11, 6.160000000000001e-11, 8.37e-11, 1.163e-10, 1.678e-10, 2.532e-10}, {5.2600000000000004e-11, 5.630000000000001e-11, 6.41e-11, 8.05e-11, 1.0920000000000001e-10, 1.495e-10, 2.102e-10, 3.073e-10}, {8.920000000000001e-11, 9.28e-11, 1.002e-10, 1.1620000000000001e-10, 1.495e-10, 2.037e-10, 2.803e-10, 3.968e-10}, {1.62e-10, 1.657e-10, 1.73e-10, 1.8850000000000002e-10, 2.206e-10, 2.874e-10, 3.9230000000000003e-10, 5.413000000000001e-10}}; +double lookTrAxis_NAND2_X2_A1_ZN_risingDelay(int iTr) {return trAxis_NAND2_X2_A1_ZN_risingDelay[iTr];} +double lookCapAxis_NAND2_X2_A1_ZN_risingDelay(int iCap) {return capAxis_NAND2_X2_A1_ZN_risingDelay[iCap];} +double lookTable_NAND2_X2_A1_ZN_risingDelay(int iTr, int iCap) {return table_NAND2_X2_A1_ZN_risingDelay[iCap][iTr];} + +double trAxis_NAND2_X2_A1_ZN_fallingDelay[8] = {7.5e-12, 1.5e-11, 3.0e-11, 6.0e-11, 1.2e-10, 2.4e-10, 4.8e-10, 9.6e-10}; +double capAxis_NAND2_X2_A1_ZN_fallingDelay[6] = {4.0e-16, 1.6e-15, 3.2e-15, 6.4e-15, 1.28e-14, 2.56e-14}; +double table_NAND2_X2_A1_ZN_fallingDelay[6][8] = {{1.2e-11, 1.4800000000000003e-11, 1.7600000000000003e-11, 1.9400000000000002e-11, 1.8200000000000002e-11, 9.400000000000001e-12, 1.65e-11, 7.720000000000002e-11}, {1.6000000000000003e-11, 1.91e-11, 2.3500000000000003e-11, 2.7400000000000004e-11, 2.8900000000000002e-11, 2.37e-11, 2.5000000000000003e-12, 5.3300000000000006e-11}, {2.1400000000000002e-11, 2.4400000000000004e-11, 3.02e-11, 3.63e-11, 4.09e-11, 3.980000000000001e-11, 2.4e-11, 2.52e-11}, {3.2000000000000006e-11, 3.51e-11, 4.130000000000001e-11, 5.1400000000000005e-11, 6.12e-11, 6.690000000000001e-11, 6.0e-11, 2.22e-11}, {5.3300000000000006e-11, 5.630000000000001e-11, 6.24e-11, 7.49e-11, 9.33e-11, 1.1010000000000001e-10, 1.1770000000000002e-10, 9.900000000000001e-11}, {9.560000000000001e-11, 9.86e-11, 1.045e-10, 1.169e-10, 1.4240000000000002e-10, 1.7680000000000003e-10, 2.074e-10, 2.188e-10}}; +double lookTrAxis_NAND2_X2_A1_ZN_fallingDelay(int iTr) {return trAxis_NAND2_X2_A1_ZN_fallingDelay[iTr];} +double lookCapAxis_NAND2_X2_A1_ZN_fallingDelay(int iCap) {return capAxis_NAND2_X2_A1_ZN_fallingDelay[iCap];} +double lookTable_NAND2_X2_A1_ZN_fallingDelay(int iTr, int iCap) {return table_NAND2_X2_A1_ZN_fallingDelay[iCap][iTr];} + +double trAxis_NAND2_X2_A1_ZN_risingTransition[8] = {7.5e-12, 1.5e-11, 3.0e-11, 6.0e-11, 1.2e-10, 2.4e-10, 4.8e-10, 9.6e-10}; +double capAxis_NAND2_X2_A1_ZN_risingTransition[6] = {4.0e-16, 1.6e-15, 3.2e-15, 6.4e-15, 1.28e-14, 2.56e-14}; +double table_NAND2_X2_A1_ZN_risingTransition[6][8] = {{1.18e-11, 1.2200000000000002e-11, 1.5800000000000003e-11, 2.22e-11, 3.17e-11, 4.8e-11, 7.820000000000001e-11, 1.367e-10}, {1.83e-11, 1.83e-11, 2.03e-11, 2.78e-11, 3.9e-11, 5.67e-11, 8.790000000000001e-11, 1.469e-10}, {2.72e-11, 2.7400000000000004e-11, 2.78e-11, 3.4000000000000005e-11, 4.760000000000001e-11, 6.73e-11, 1.003e-10, 1.6050000000000001e-10}, {4.4600000000000006e-11, 4.45e-11, 4.45e-11, 4.68e-11, 6.11e-11, 8.540000000000001e-11, 1.2250000000000002e-10, 1.8640000000000002e-10}, {7.900000000000001e-11, 7.900000000000001e-11, 7.900000000000001e-11, 7.900000000000001e-11, 8.51e-11, 1.1430000000000001e-10, 1.6070000000000002e-10, 2.3250000000000002e-10}, {1.481e-10, 1.481e-10, 1.481e-10, 1.481e-10, 1.4820000000000002e-10, 1.625e-10, 2.2090000000000003e-10, 3.111e-10}}; +double lookTrAxis_NAND2_X2_A1_ZN_risingTransition(int iTr) {return trAxis_NAND2_X2_A1_ZN_risingTransition[iTr];} +double lookCapAxis_NAND2_X2_A1_ZN_risingTransition(int iCap) {return capAxis_NAND2_X2_A1_ZN_risingTransition[iCap];} +double lookTable_NAND2_X2_A1_ZN_risingTransition(int iTr, int iCap) {return table_NAND2_X2_A1_ZN_risingTransition[iCap][iTr];} + +double trAxis_NAND2_X2_A1_ZN_fallingTransition[8] = {7.5e-12, 1.5e-11, 3.0e-11, 6.0e-11, 1.2e-10, 2.4e-10, 4.8e-10, 9.6e-10}; +double capAxis_NAND2_X2_A1_ZN_fallingTransition[6] = {4.0e-16, 1.6e-15, 3.2e-15, 6.4e-15, 1.28e-14, 2.56e-14}; +double table_NAND2_X2_A1_ZN_fallingTransition[6][8] = {{6.9e-12, 8.500000000000001e-12, 1.1900000000000002e-11, 1.77e-11, 2.7700000000000002e-11, 4.52e-11, 7.7e-11, 1.374e-10}, {1.0500000000000001e-11, 1.11e-11, 1.49e-11, 2.1400000000000002e-11, 3.22e-11, 5.11e-11, 8.480000000000001e-11, 1.469e-10}, {1.5e-11, 1.51e-11, 1.8400000000000002e-11, 2.5600000000000004e-11, 3.77e-11, 5.79e-11, 9.370000000000001e-11, 1.583e-10}, {2.43e-11, 2.43e-11, 2.5300000000000002e-11, 3.24e-11, 4.6300000000000004e-11, 6.92e-11, 1.083e-10, 1.7770000000000002e-10}, {4.26e-11, 4.2700000000000005e-11, 4.2700000000000005e-11, 4.5500000000000004e-11, 6.08e-11, 8.76e-11, 1.32e-10, 2.0890000000000002e-10}, {7.94e-11, 7.94e-11, 7.94e-11, 7.94e-11, 8.620000000000001e-11, 1.174e-10, 1.702e-10, 2.578e-10}}; +double lookTrAxis_NAND2_X2_A1_ZN_fallingTransition(int iTr) {return trAxis_NAND2_X2_A1_ZN_fallingTransition[iTr];} +double lookCapAxis_NAND2_X2_A1_ZN_fallingTransition(int iCap) {return capAxis_NAND2_X2_A1_ZN_fallingTransition[iCap];} +double lookTable_NAND2_X2_A1_ZN_fallingTransition(int iTr, int iCap) {return table_NAND2_X2_A1_ZN_fallingTransition[iCap][iTr];} + +double trAxis_NAND2_X2_A2_ZN_risingDelay[8] = {7.5e-12, 1.5e-11, 3.0e-11, 6.0e-11, 1.2e-10, 2.4e-10, 4.8e-10, 9.6e-10}; +double capAxis_NAND2_X2_A2_ZN_risingDelay[6] = {4.0e-16, 1.6e-15, 3.2e-15, 6.4e-15, 1.28e-14, 2.56e-14}; +double table_NAND2_X2_A2_ZN_risingDelay[6][8] = {{2.6500000000000002e-11, 3.03e-11, 3.860000000000001e-11, 5.25e-11, 7.230000000000001e-11, 1.0290000000000001e-10, 1.5320000000000002e-10, 2.411e-10}, {3.350000000000001e-11, 3.73e-11, 4.5400000000000006e-11, 6.11e-11, 8.37e-11, 1.174e-10, 1.717e-10, 2.6440000000000004e-10}, {4.29e-11, 4.65e-11, 5.4500000000000006e-11, 7.120000000000001e-11, 9.72e-11, 1.3480000000000002e-10, 1.9370000000000001e-10, 2.924e-10}, {6.14e-11, 6.500000000000001e-11, 7.280000000000001e-11, 8.920000000000001e-11, 1.205e-10, 1.6550000000000002e-10, 2.327e-10, 3.4150000000000006e-10}, {9.800000000000001e-11, 1.016e-10, 1.0920000000000001e-10, 1.2509999999999999e-10, 1.5850000000000002e-10, 2.165e-10, 2.9880000000000004e-10, 4.251e-10}, {1.709e-10, 1.745e-10, 1.8200000000000002e-10, 1.9750000000000002e-10, 2.297e-10, 2.9690000000000003e-10, 4.065e-10, 5.635000000000001e-10}}; +double lookTrAxis_NAND2_X2_A2_ZN_risingDelay(int iTr) {return trAxis_NAND2_X2_A2_ZN_risingDelay[iTr];} +double lookCapAxis_NAND2_X2_A2_ZN_risingDelay(int iCap) {return capAxis_NAND2_X2_A2_ZN_risingDelay[iCap];} +double lookTable_NAND2_X2_A2_ZN_risingDelay(int iTr, int iCap) {return table_NAND2_X2_A2_ZN_risingDelay[iCap][iTr];} + +double trAxis_NAND2_X2_A2_ZN_fallingDelay[8] = {7.5e-12, 1.5e-11, 3.0e-11, 6.0e-11, 1.2e-10, 2.4e-10, 4.8e-10, 9.6e-10}; +double capAxis_NAND2_X2_A2_ZN_fallingDelay[6] = {4.0e-16, 1.6e-15, 3.2e-15, 6.4e-15, 1.28e-14, 2.56e-14}; +double table_NAND2_X2_A2_ZN_fallingDelay[6][8] = {{1.5400000000000003e-11, 1.8e-11, 2.1400000000000002e-11, 2.4400000000000004e-11, 2.4700000000000003e-11, 1.77e-11, 5.5e-12, 6.49e-11}, {1.95e-11, 2.2100000000000003e-11, 2.6300000000000002e-11, 3.1e-11, 3.41e-11, 3.0800000000000006e-11, 1.2500000000000002e-11, 4.01e-11}, {2.49e-11, 2.7500000000000002e-11, 3.22e-11, 3.85e-11, 4.45e-11, 4.5500000000000004e-11, 3.2800000000000006e-11, 1.2200000000000002e-11}, {3.54e-11, 3.81e-11, 4.3100000000000005e-11, 5.15e-11, 6.17e-11, 6.95e-11, 6.63e-11, 3.39e-11}, {5.67e-11, 5.940000000000001e-11, 6.44e-11, 7.420000000000001e-11, 8.95e-11, 1.0720000000000001e-10, 1.186e-10, 1.0650000000000001e-10}, {9.91e-11, 1.019e-10, 1.069e-10, 1.169e-10, 1.361e-10, 1.6520000000000003e-10, 1.9760000000000002e-10, 2.1620000000000001e-10}}; +double lookTrAxis_NAND2_X2_A2_ZN_fallingDelay(int iTr) {return trAxis_NAND2_X2_A2_ZN_fallingDelay[iTr];} +double lookCapAxis_NAND2_X2_A2_ZN_fallingDelay(int iCap) {return capAxis_NAND2_X2_A2_ZN_fallingDelay[iCap];} +double lookTable_NAND2_X2_A2_ZN_fallingDelay(int iTr, int iCap) {return table_NAND2_X2_A2_ZN_fallingDelay[iCap][iTr];} + +double trAxis_NAND2_X2_A2_ZN_risingTransition[8] = {7.5e-12, 1.5e-11, 3.0e-11, 6.0e-11, 1.2e-10, 2.4e-10, 4.8e-10, 9.6e-10}; +double capAxis_NAND2_X2_A2_ZN_risingTransition[6] = {4.0e-16, 1.6e-15, 3.2e-15, 6.4e-15, 1.28e-14, 2.56e-14}; +double table_NAND2_X2_A2_ZN_risingTransition[6][8] = {{1.7200000000000003e-11, 1.7200000000000003e-11, 1.8400000000000002e-11, 2.49e-11, 3.4900000000000004e-11, 4.9400000000000005e-11, 7.330000000000001e-11, 1.167e-10}, {2.3900000000000003e-11, 2.3900000000000003e-11, 2.42e-11, 3.0e-11, 4.2000000000000004e-11, 5.89e-11, 8.540000000000001e-11, 1.318e-10}, {3.27e-11, 3.27e-11, 3.27e-11, 3.6400000000000005e-11, 5.0200000000000005e-11, 6.990000000000001e-11, 9.95e-11, 1.493e-10}, {5.01e-11, 5.0200000000000005e-11, 5.01e-11, 5.1e-11, 6.320000000000001e-11, 8.82e-11, 1.2360000000000002e-10, 1.795e-10}, {8.47e-11, 8.480000000000001e-11, 8.480000000000001e-11, 8.480000000000001e-11, 8.9e-11, 1.167e-10, 1.629e-10, 2.3000000000000003e-10}, {1.541e-10, 1.541e-10, 1.541e-10, 1.54e-10, 1.541e-10, 1.662e-10, 2.231e-10, 3.117e-10}}; +double lookTrAxis_NAND2_X2_A2_ZN_risingTransition(int iTr) {return trAxis_NAND2_X2_A2_ZN_risingTransition[iTr];} +double lookCapAxis_NAND2_X2_A2_ZN_risingTransition(int iCap) {return capAxis_NAND2_X2_A2_ZN_risingTransition[iCap];} +double lookTable_NAND2_X2_A2_ZN_risingTransition(int iTr, int iCap) {return table_NAND2_X2_A2_ZN_risingTransition[iCap][iTr];} + +double trAxis_NAND2_X2_A2_ZN_fallingTransition[8] = {7.5e-12, 1.5e-11, 3.0e-11, 6.0e-11, 1.2e-10, 2.4e-10, 4.8e-10, 9.6e-10}; +double capAxis_NAND2_X2_A2_ZN_fallingTransition[6] = {4.0e-16, 1.6e-15, 3.2e-15, 6.4e-15, 1.28e-14, 2.56e-14}; +double table_NAND2_X2_A2_ZN_fallingTransition[6][8] = {{7.000000000000001e-12, 7.5e-12, 9.6e-12, 1.38e-11, 2.1600000000000002e-11, 3.5600000000000005e-11, 5.95e-11, 1.007e-10}, {1.0500000000000001e-11, 1.0700000000000001e-11, 1.2500000000000002e-11, 1.68e-11, 2.5100000000000003e-11, 3.980000000000001e-11, 6.500000000000001e-11, 1.08e-10}, {1.51e-11, 1.51e-11, 1.6299999999999998e-11, 2.0600000000000002e-11, 2.93e-11, 4.490000000000001e-11, 7.170000000000001e-11, 1.1710000000000001e-10}, {2.42e-11, 2.43e-11, 2.46e-11, 2.8100000000000002e-11, 3.6800000000000005e-11, 5.3800000000000004e-11, 8.31e-11, 1.329e-10}, {4.26e-11, 4.26e-11, 4.26e-11, 4.3900000000000005e-11, 5.16e-11, 6.92e-11, 1.0180000000000001e-10, 1.5800000000000002e-10}, {7.94e-11, 7.94e-11, 7.94e-11, 7.94e-11, 8.27e-11, 9.850000000000001e-11, 1.335e-10, 1.9760000000000002e-10}}; +double lookTrAxis_NAND2_X2_A2_ZN_fallingTransition(int iTr) {return trAxis_NAND2_X2_A2_ZN_fallingTransition[iTr];} +double lookCapAxis_NAND2_X2_A2_ZN_fallingTransition(int iCap) {return capAxis_NAND2_X2_A2_ZN_fallingTransition[iCap];} +double lookTable_NAND2_X2_A2_ZN_fallingTransition(int iTr, int iCap) {return table_NAND2_X2_A2_ZN_fallingTransition[iCap][iTr];} + +double trAxis_NAND2_X4_A1_ZN_risingDelay[8] = {7.5e-12, 1.5e-11, 3.0e-11, 6.0e-11, 1.2e-10, 2.4e-10, 4.8e-10, 9.6e-10}; +double capAxis_NAND2_X4_A1_ZN_risingDelay[6] = {4.0e-16, 3.2e-15, 6.4e-15, 1.28e-14, 2.56e-14, 5.12e-14}; +double table_NAND2_X4_A1_ZN_risingDelay[6][8] = {{1.8400000000000002e-11, 2.24e-11, 2.98e-11, 4.01e-11, 5.56e-11, 8.05e-11, 1.22e-10, 1.954e-10}, {2.66e-11, 3.04e-11, 3.860000000000001e-11, 5.19e-11, 7.090000000000001e-11, 9.990000000000001e-11, 1.4680000000000003e-10, 2.2620000000000003e-10}, {3.58e-11, 3.9600000000000004e-11, 4.7500000000000004e-11, 6.33e-11, 8.590000000000001e-11, 1.19e-10, 1.7120000000000001e-10, 2.573e-10}, {5.4200000000000004e-11, 5.79e-11, 6.560000000000001e-11, 8.200000000000001e-11, 1.1110000000000001e-10, 1.5190000000000001e-10, 2.1310000000000002e-10, 3.1090000000000003e-10}, {9.080000000000001e-11, 9.44e-11, 1.019e-10, 1.1770000000000002e-10, 1.51e-10, 2.057e-10, 2.828e-10, 3.998e-10}, {1.6380000000000002e-10, 1.674e-10, 1.7480000000000003e-10, 1.901e-10, 2.2220000000000002e-10, 2.889e-10, 3.944e-10, 5.439000000000001e-10}}; +double lookTrAxis_NAND2_X4_A1_ZN_risingDelay(int iTr) {return trAxis_NAND2_X4_A1_ZN_risingDelay[iTr];} +double lookCapAxis_NAND2_X4_A1_ZN_risingDelay(int iCap) {return capAxis_NAND2_X4_A1_ZN_risingDelay[iCap];} +double lookTable_NAND2_X4_A1_ZN_risingDelay(int iTr, int iCap) {return table_NAND2_X4_A1_ZN_risingDelay[iCap][iTr];} + +double trAxis_NAND2_X4_A1_ZN_fallingDelay[8] = {7.5e-12, 1.5e-11, 3.0e-11, 6.0e-11, 1.2e-10, 2.4e-10, 4.8e-10, 9.6e-10}; +double capAxis_NAND2_X4_A1_ZN_fallingDelay[6] = {4.0e-16, 3.2e-15, 6.4e-15, 1.28e-14, 2.56e-14, 5.12e-14}; +double table_NAND2_X4_A1_ZN_fallingDelay[6][8] = {{1.18e-11, 1.46e-11, 1.74e-11, 1.92e-11, 1.8e-11, 9.3e-12, 1.6400000000000003e-11, 7.720000000000002e-11}, {1.65e-11, 1.9600000000000002e-11, 2.42e-11, 2.8500000000000002e-11, 3.04e-11, 2.58e-11, 5.4000000000000004e-12, 4.96e-11}, {2.1800000000000002e-11, 2.49e-11, 3.0800000000000006e-11, 3.73e-11, 4.23e-11, 4.1600000000000004e-11, 2.64e-11, 2.2e-11}, {3.2500000000000004e-11, 3.55e-11, 4.17e-11, 5.2100000000000006e-11, 6.22e-11, 6.83e-11, 6.2e-11, 2.49e-11}, {5.37e-11, 5.67e-11, 6.279999999999999e-11, 7.54e-11, 9.41e-11, 1.112e-10, 1.1930000000000002e-10, 1.0120000000000001e-10}, {9.610000000000001e-11, 9.91e-11, 1.05e-10, 1.174e-10, 1.4290000000000002e-10, 1.776e-10, 2.085e-10, 2.2050000000000001e-10}}; +double lookTrAxis_NAND2_X4_A1_ZN_fallingDelay(int iTr) {return trAxis_NAND2_X4_A1_ZN_fallingDelay[iTr];} +double lookCapAxis_NAND2_X4_A1_ZN_fallingDelay(int iCap) {return capAxis_NAND2_X4_A1_ZN_fallingDelay[iCap];} +double lookTable_NAND2_X4_A1_ZN_fallingDelay(int iTr, int iCap) {return table_NAND2_X4_A1_ZN_fallingDelay[iCap][iTr];} + +double trAxis_NAND2_X4_A1_ZN_risingTransition[8] = {7.5e-12, 1.5e-11, 3.0e-11, 6.0e-11, 1.2e-10, 2.4e-10, 4.8e-10, 9.6e-10}; +double capAxis_NAND2_X4_A1_ZN_risingTransition[6] = {4.0e-16, 3.2e-15, 6.4e-15, 1.28e-14, 2.56e-14, 5.12e-14}; +double table_NAND2_X4_A1_ZN_risingTransition[6][8] = {{1.2e-11, 1.23e-11, 1.59e-11, 2.2300000000000003e-11, 3.19e-11, 4.81e-11, 7.8e-11, 1.366e-10}, {1.97e-11, 1.97e-11, 2.1200000000000002e-11, 2.8700000000000002e-11, 4.02e-11, 5.8200000000000003e-11, 8.96e-11, 1.485e-10}, {2.8400000000000003e-11, 2.8500000000000002e-11, 2.88e-11, 3.470000000000001e-11, 4.86e-11, 6.86e-11, 1.019e-10, 1.6220000000000002e-10}, {4.5800000000000006e-11, 4.5800000000000006e-11, 4.57e-11, 4.7800000000000006e-11, 6.180000000000001e-11, 8.66e-11, 1.24e-10, 1.881e-10}, {8.03e-11, 8.03e-11, 8.03e-11, 8.04e-11, 8.61e-11, 1.153e-10, 1.62e-10, 2.341e-10}, {1.495e-10, 1.495e-10, 1.4960000000000003e-10, 1.4960000000000003e-10, 1.495e-10, 1.635e-10, 2.219e-10, 3.125e-10}}; +double lookTrAxis_NAND2_X4_A1_ZN_risingTransition(int iTr) {return trAxis_NAND2_X4_A1_ZN_risingTransition[iTr];} +double lookCapAxis_NAND2_X4_A1_ZN_risingTransition(int iCap) {return capAxis_NAND2_X4_A1_ZN_risingTransition[iCap];} +double lookTable_NAND2_X4_A1_ZN_risingTransition(int iTr, int iCap) {return table_NAND2_X4_A1_ZN_risingTransition[iCap][iTr];} + +double trAxis_NAND2_X4_A1_ZN_fallingTransition[8] = {7.5e-12, 1.5e-11, 3.0e-11, 6.0e-11, 1.2e-10, 2.4e-10, 4.8e-10, 9.6e-10}; +double capAxis_NAND2_X4_A1_ZN_fallingTransition[6] = {4.0e-16, 3.2e-15, 6.4e-15, 1.28e-14, 2.56e-14, 5.12e-14}; +double table_NAND2_X4_A1_ZN_fallingTransition[6][8] = {{6.9e-12, 8.500000000000001e-12, 1.1900000000000002e-11, 1.77e-11, 2.7700000000000002e-11, 4.53e-11, 7.710000000000001e-11, 1.3760000000000002e-10}, {1.0900000000000001e-11, 1.16e-11, 1.52e-11, 2.1800000000000002e-11, 3.29e-11, 5.2100000000000006e-11, 8.6e-11, 1.485e-10}, {1.56e-11, 1.56e-11, 1.8400000000000002e-11, 2.6100000000000002e-11, 3.82e-11, 5.87e-11, 9.48e-11, 1.5970000000000003e-10}, {2.4700000000000003e-11, 2.48e-11, 2.5600000000000004e-11, 3.2800000000000006e-11, 4.68e-11, 6.980000000000001e-11, 1.0920000000000001e-10, 1.7890000000000002e-10}, {4.3200000000000003e-11, 4.3200000000000003e-11, 4.3200000000000003e-11, 4.5800000000000006e-11, 6.12e-11, 8.81e-11, 1.3270000000000002e-10, 2.098e-10}, {8.000000000000001e-11, 7.99e-11, 8.000000000000001e-11, 8.000000000000001e-11, 8.670000000000001e-11, 1.178e-10, 1.7080000000000002e-10, 2.586e-10}}; +double lookTrAxis_NAND2_X4_A1_ZN_fallingTransition(int iTr) {return trAxis_NAND2_X4_A1_ZN_fallingTransition[iTr];} +double lookCapAxis_NAND2_X4_A1_ZN_fallingTransition(int iCap) {return capAxis_NAND2_X4_A1_ZN_fallingTransition[iCap];} +double lookTable_NAND2_X4_A1_ZN_fallingTransition(int iTr, int iCap) {return table_NAND2_X4_A1_ZN_fallingTransition[iCap][iTr];} + +double trAxis_NAND2_X4_A2_ZN_risingDelay[8] = {7.5e-12, 1.5e-11, 3.0e-11, 6.0e-11, 1.2e-10, 2.4e-10, 4.8e-10, 9.6e-10}; +double capAxis_NAND2_X4_A2_ZN_risingDelay[6] = {4.0e-16, 3.2e-15, 6.4e-15, 1.28e-14, 2.56e-14, 5.12e-14}; +double table_NAND2_X4_A2_ZN_risingDelay[6][8] = {{2.6900000000000002e-11, 3.07e-11, 3.9e-11, 5.31e-11, 7.31e-11, 1.037e-10, 1.5440000000000003e-10, 2.422e-10}, {3.5200000000000005e-11, 3.89e-11, 4.7000000000000006e-11, 6.3e-11, 8.620000000000001e-11, 1.205e-10, 1.7560000000000002e-10, 2.692e-10}, {4.45e-11, 4.8200000000000005e-11, 5.6200000000000004e-11, 7.290000000000001e-11, 9.95e-11, 1.377e-10, 1.973e-10, 2.9680000000000005e-10}, {6.3e-11, 6.67e-11, 7.44e-11, 9.080000000000001e-11, 1.224e-10, 1.6800000000000001e-10, 2.3590000000000003e-10, 3.455e-10}, {9.97e-11, 1.0330000000000001e-10, 1.109e-10, 1.268e-10, 1.601e-10, 2.186e-10, 3.015e-10, 4.285e-10}, {1.727e-10, 1.764e-10, 1.838e-10, 1.9930000000000003e-10, 2.3150000000000003e-10, 2.986e-10, 4.0870000000000005e-10, 5.664e-10}}; +double lookTrAxis_NAND2_X4_A2_ZN_risingDelay(int iTr) {return trAxis_NAND2_X4_A2_ZN_risingDelay[iTr];} +double lookCapAxis_NAND2_X4_A2_ZN_risingDelay(int iCap) {return capAxis_NAND2_X4_A2_ZN_risingDelay[iCap];} +double lookTable_NAND2_X4_A2_ZN_risingDelay(int iTr, int iCap) {return table_NAND2_X4_A2_ZN_risingDelay[iCap][iTr];} + +double trAxis_NAND2_X4_A2_ZN_fallingDelay[8] = {7.5e-12, 1.5e-11, 3.0e-11, 6.0e-11, 1.2e-10, 2.4e-10, 4.8e-10, 9.6e-10}; +double capAxis_NAND2_X4_A2_ZN_fallingDelay[6] = {4.0e-16, 3.2e-15, 6.4e-15, 1.28e-14, 2.56e-14, 5.12e-14}; +double table_NAND2_X4_A2_ZN_fallingDelay[6][8] = {{1.6000000000000003e-11, 1.85e-11, 2.1700000000000003e-11, 2.4700000000000003e-11, 2.4700000000000003e-11, 1.7200000000000003e-11, 6.5e-12, 6.640000000000001e-11}, {2.07e-11, 2.3300000000000003e-11, 2.7500000000000002e-11, 3.230000000000001e-11, 3.5600000000000005e-11, 3.2599999999999996e-11, 1.46e-11, 3.740000000000001e-11}, {2.6e-11, 2.8700000000000002e-11, 3.3300000000000004e-11, 3.980000000000001e-11, 4.5800000000000006e-11, 4.7000000000000006e-11, 3.46e-11, 9.900000000000001e-12}, {3.6700000000000006e-11, 3.93e-11, 4.4200000000000006e-11, 5.2600000000000004e-11, 6.3e-11, 7.090000000000001e-11, 6.79e-11, 3.5900000000000007e-11}, {5.8000000000000007e-11, 6.06e-11, 6.560000000000001e-11, 7.54e-11, 9.070000000000001e-11, 1.0840000000000001e-10, 1.201e-10, 1.0820000000000001e-10}, {1.0040000000000001e-10, 1.031e-10, 1.0820000000000001e-10, 1.181e-10, 1.373e-10, 1.6640000000000001e-10, 1.989e-10, 2.1780000000000001e-10}}; +double lookTrAxis_NAND2_X4_A2_ZN_fallingDelay(int iTr) {return trAxis_NAND2_X4_A2_ZN_fallingDelay[iTr];} +double lookCapAxis_NAND2_X4_A2_ZN_fallingDelay(int iCap) {return capAxis_NAND2_X4_A2_ZN_fallingDelay[iCap];} +double lookTable_NAND2_X4_A2_ZN_fallingDelay(int iTr, int iCap) {return table_NAND2_X4_A2_ZN_fallingDelay[iCap][iTr];} + +double trAxis_NAND2_X4_A2_ZN_risingTransition[8] = {7.5e-12, 1.5e-11, 3.0e-11, 6.0e-11, 1.2e-10, 2.4e-10, 4.8e-10, 9.6e-10}; +double capAxis_NAND2_X4_A2_ZN_risingTransition[6] = {4.0e-16, 3.2e-15, 6.4e-15, 1.28e-14, 2.56e-14, 5.12e-14}; +double table_NAND2_X4_A2_ZN_risingTransition[6][8] = {{1.73e-11, 1.73e-11, 1.83e-11, 2.48e-11, 3.470000000000001e-11, 4.92e-11, 7.26e-11, 1.152e-10}, {2.5000000000000004e-11, 2.5100000000000003e-11, 2.52e-11, 3.06e-11, 4.29e-11, 6.02e-11, 8.670000000000001e-11, 1.329e-10}, {3.3799999999999996e-11, 3.39e-11, 3.39e-11, 3.72e-11, 5.1e-11, 7.11e-11, 1.008e-10, 1.505e-10}, {5.120000000000001e-11, 5.13e-11, 5.120000000000001e-11, 5.2200000000000005e-11, 6.38e-11, 8.920000000000001e-11, 1.248e-10, 1.807e-10}, {8.6e-11, 8.61e-11, 8.61e-11, 8.61e-11, 9.0e-11, 1.174e-10, 1.6400000000000003e-10, 2.3120000000000001e-10}, {1.555e-10, 1.555e-10, 1.555e-10, 1.555e-10, 1.5540000000000003e-10, 1.672e-10, 2.2400000000000003e-10, 3.1280000000000005e-10}}; +double lookTrAxis_NAND2_X4_A2_ZN_risingTransition(int iTr) {return trAxis_NAND2_X4_A2_ZN_risingTransition[iTr];} +double lookCapAxis_NAND2_X4_A2_ZN_risingTransition(int iCap) {return capAxis_NAND2_X4_A2_ZN_risingTransition[iCap];} +double lookTable_NAND2_X4_A2_ZN_risingTransition(int iTr, int iCap) {return table_NAND2_X4_A2_ZN_risingTransition[iCap][iTr];} + +double trAxis_NAND2_X4_A2_ZN_fallingTransition[8] = {7.5e-12, 1.5e-11, 3.0e-11, 6.0e-11, 1.2e-10, 2.4e-10, 4.8e-10, 9.6e-10}; +double capAxis_NAND2_X4_A2_ZN_fallingTransition[6] = {4.0e-16, 3.2e-15, 6.4e-15, 1.28e-14, 2.56e-14, 5.12e-14}; +double table_NAND2_X4_A2_ZN_fallingTransition[6][8] = {{6.9e-12, 7.400000000000002e-12, 9.3e-12, 1.35e-11, 2.1400000000000002e-11, 3.55e-11, 5.96e-11, 1.011e-10}, {1.1e-11, 1.11e-11, 1.2800000000000002e-11, 1.7000000000000003e-11, 2.5300000000000002e-11, 4.0300000000000006e-11, 6.58e-11, 1.094e-10}, {1.55e-11, 1.56e-11, 1.67e-11, 2.09e-11, 2.9600000000000006e-11, 4.53e-11, 7.240000000000002e-11, 1.1830000000000002e-10}, {2.4700000000000003e-11, 2.48e-11, 2.5000000000000004e-11, 2.8300000000000002e-11, 3.7e-11, 5.4e-11, 8.36e-11, 1.3370000000000001e-10}, {4.3200000000000003e-11, 4.3200000000000003e-11, 4.3100000000000005e-11, 4.4300000000000005e-11, 5.19e-11, 6.940000000000001e-11, 1.022e-10, 1.587e-10}, {8.000000000000001e-11, 8.000000000000001e-11, 7.99e-11, 8.000000000000001e-11, 8.320000000000001e-11, 9.880000000000001e-11, 1.3380000000000002e-10, 1.9810000000000002e-10}}; +double lookTrAxis_NAND2_X4_A2_ZN_fallingTransition(int iTr) {return trAxis_NAND2_X4_A2_ZN_fallingTransition[iTr];} +double lookCapAxis_NAND2_X4_A2_ZN_fallingTransition(int iCap) {return capAxis_NAND2_X4_A2_ZN_fallingTransition[iCap];} +double lookTable_NAND2_X4_A2_ZN_fallingTransition(int iTr, int iCap) {return table_NAND2_X4_A2_ZN_fallingTransition[iCap][iTr];} + +double trAxis_NOR2_X1_A1_ZN_risingDelay[8] = {7.5e-12, 1.5e-11, 3.0e-11, 6.0e-11, 1.2e-10, 2.4e-10, 4.8e-10, 9.6e-10}; +double capAxis_NOR2_X1_A1_ZN_risingDelay[6] = {4.0e-16, 8.0e-16, 1.6e-15, 3.2e-15, 6.4e-15, 1.28e-14}; +double table_NOR2_X1_A1_ZN_risingDelay[6][8] = {{3.1300000000000004e-11, 3.4500000000000004e-11, 4.17e-11, 5.5000000000000004e-11, 7.330000000000001e-11, 1.007e-10, 1.442e-10, 2.186e-10}, {3.81e-11, 4.1200000000000004e-11, 4.8200000000000005e-11, 6.260000000000001e-11, 8.31e-11, 1.128e-10, 1.596e-10, 2.3710000000000004e-10}, {5.1700000000000006e-11, 5.47e-11, 6.14e-11, 7.630000000000001e-11, 1.008e-10, 1.351e-10, 1.872e-10, 2.716e-10}, {7.83e-11, 8.13e-11, 8.780000000000001e-11, 1.02e-10, 1.3120000000000002e-10, 1.742e-10, 2.358e-10, 3.3200000000000004e-10}, {1.315e-10, 1.344e-10, 1.407e-10, 1.543e-10, 1.8320000000000002e-10, 2.394e-10, 3.1890000000000006e-10, 4.3510000000000003e-10}, {2.3760000000000004e-10, 2.405e-10, 2.466e-10, 2.597e-10, 2.8720000000000005e-10, 3.4560000000000003e-10, 4.5470000000000004e-10, 6.072e-10}}; +double lookTrAxis_NOR2_X1_A1_ZN_risingDelay(int iTr) {return trAxis_NOR2_X1_A1_ZN_risingDelay[iTr];} +double lookCapAxis_NOR2_X1_A1_ZN_risingDelay(int iCap) {return capAxis_NOR2_X1_A1_ZN_risingDelay[iCap];} +double lookTable_NOR2_X1_A1_ZN_risingDelay(int iTr, int iCap) {return table_NOR2_X1_A1_ZN_risingDelay[iCap][iTr];} + +double trAxis_NOR2_X1_A1_ZN_fallingDelay[8] = {7.5e-12, 1.5e-11, 3.0e-11, 6.0e-11, 1.2e-10, 2.4e-10, 4.8e-10, 9.6e-10}; +double capAxis_NOR2_X1_A1_ZN_fallingDelay[6] = {4.0e-16, 8.0e-16, 1.6e-15, 3.2e-15, 6.4e-15, 1.28e-14}; +double table_NOR2_X1_A1_ZN_fallingDelay[6][8] = {{1.36e-11, 1.7000000000000003e-11, 2.1100000000000003e-11, 2.5100000000000003e-11, 2.72e-11, 2.3500000000000003e-11, 5.2000000000000005e-12, 4.47e-11}, {1.6000000000000003e-11, 1.9400000000000002e-11, 2.4500000000000003e-11, 2.9700000000000005e-11, 3.350000000000001e-11, 3.2000000000000006e-11, 1.68e-11, 2.9600000000000006e-11}, {2.0800000000000002e-11, 2.4100000000000003e-11, 3.04e-11, 3.77e-11, 4.45e-11, 4.7000000000000006e-11, 3.72e-11, 2.3000000000000003e-12}, {3.03e-11, 3.3700000000000004e-11, 4.0400000000000004e-11, 5.13e-11, 6.3e-11, 7.220000000000001e-11, 7.140000000000001e-11, 4.38e-11}, {4.9100000000000004e-11, 5.25e-11, 5.920000000000001e-11, 7.3e-11, 9.260000000000001e-11, 1.1240000000000001e-10, 1.261e-10, 1.181e-10}, {8.680000000000001e-11, 9.020000000000001e-11, 9.68e-11, 1.103e-10, 1.379e-10, 1.745e-10, 2.1040000000000002e-10, 2.329e-10}}; +double lookTrAxis_NOR2_X1_A1_ZN_fallingDelay(int iTr) {return trAxis_NOR2_X1_A1_ZN_fallingDelay[iTr];} +double lookCapAxis_NOR2_X1_A1_ZN_fallingDelay(int iCap) {return capAxis_NOR2_X1_A1_ZN_fallingDelay[iCap];} +double lookTable_NOR2_X1_A1_ZN_fallingDelay(int iTr, int iCap) {return table_NOR2_X1_A1_ZN_fallingDelay[iCap][iTr];} + +double trAxis_NOR2_X1_A1_ZN_risingTransition[8] = {7.5e-12, 1.5e-11, 3.0e-11, 6.0e-11, 1.2e-10, 2.4e-10, 4.8e-10, 9.6e-10}; +double capAxis_NOR2_X1_A1_ZN_risingTransition[6] = {4.0e-16, 8.0e-16, 1.6e-15, 3.2e-15, 6.4e-15, 1.28e-14}; +double table_NOR2_X1_A1_ZN_risingTransition[6][8] = {{2.6500000000000002e-11, 2.6300000000000002e-11, 2.6700000000000002e-11, 3.27e-11, 4.3400000000000007e-11, 5.990000000000001e-11, 8.910000000000001e-11, 1.443e-10}, {3.27e-11, 3.2599999999999996e-11, 3.2500000000000004e-11, 3.72e-11, 4.92e-11, 6.700000000000001e-11, 9.700000000000001e-11, 1.529e-10}, {4.5e-11, 4.5100000000000005e-11, 4.5e-11, 4.7100000000000004e-11, 5.98e-11, 8.010000000000001e-11, 1.122e-10, 1.6960000000000001e-10}, {6.930000000000001e-11, 6.930000000000001e-11, 6.940000000000001e-11, 6.92e-11, 7.79e-11, 1.0280000000000001e-10, 1.4000000000000003e-10, 2.0130000000000002e-10}, {1.178e-10, 1.178e-10, 1.178e-10, 1.178e-10, 1.1890000000000002e-10, 1.4030000000000002e-10, 1.8800000000000002e-10, 2.5890000000000006e-10}, {2.148e-10, 2.1490000000000003e-10, 2.1490000000000003e-10, 2.1490000000000003e-10, 2.1490000000000003e-10, 2.1900000000000002e-10, 2.658e-10, 3.58e-10}}; +double lookTrAxis_NOR2_X1_A1_ZN_risingTransition(int iTr) {return trAxis_NOR2_X1_A1_ZN_risingTransition[iTr];} +double lookCapAxis_NOR2_X1_A1_ZN_risingTransition(int iCap) {return capAxis_NOR2_X1_A1_ZN_risingTransition[iCap];} +double lookTable_NOR2_X1_A1_ZN_risingTransition(int iTr, int iCap) {return table_NOR2_X1_A1_ZN_risingTransition[iCap][iTr];} + +double trAxis_NOR2_X1_A1_ZN_fallingTransition[8] = {7.5e-12, 1.5e-11, 3.0e-11, 6.0e-11, 1.2e-10, 2.4e-10, 4.8e-10, 9.6e-10}; +double capAxis_NOR2_X1_A1_ZN_fallingTransition[6] = {4.0e-16, 8.0e-16, 1.6e-15, 3.2e-15, 6.4e-15, 1.28e-14}; +double table_NOR2_X1_A1_ZN_fallingTransition[6][8] = {{7.6e-12, 8.800000000000001e-12, 1.26e-11, 1.89e-11, 2.95e-11, 4.81e-11, 8.1e-11, 1.4130000000000002e-10}, {9.800000000000001e-12, 1.0600000000000001e-11, 1.44e-11, 2.09e-11, 3.21e-11, 5.1400000000000005e-11, 8.550000000000001e-11, 1.4720000000000002e-10}, {1.38e-11, 1.41e-11, 1.73e-11, 2.48e-11, 3.6800000000000005e-11, 5.750000000000001e-11, 9.36e-11, 1.5790000000000002e-10}, {2.2100000000000003e-11, 2.2100000000000003e-11, 2.34e-11, 3.0800000000000006e-11, 4.47e-11, 6.750000000000001e-11, 1.069e-10, 1.76e-10}, {3.85e-11, 3.85e-11, 3.85e-11, 4.1900000000000005e-11, 5.7800000000000003e-11, 8.430000000000001e-11, 1.2850000000000002e-10, 2.05e-10}, {7.120000000000001e-11, 7.120000000000001e-11, 7.13e-11, 7.13e-11, 7.94e-11, 1.1140000000000001e-10, 1.635e-10, 2.5040000000000003e-10}}; +double lookTrAxis_NOR2_X1_A1_ZN_fallingTransition(int iTr) {return trAxis_NOR2_X1_A1_ZN_fallingTransition[iTr];} +double lookCapAxis_NOR2_X1_A1_ZN_fallingTransition(int iCap) {return capAxis_NOR2_X1_A1_ZN_fallingTransition[iCap];} +double lookTable_NOR2_X1_A1_ZN_fallingTransition(int iTr, int iCap) {return table_NOR2_X1_A1_ZN_fallingTransition[iCap][iTr];} + +double trAxis_NOR2_X1_A2_ZN_risingDelay[8] = {7.5e-12, 1.5e-11, 3.0e-11, 6.0e-11, 1.2e-10, 2.4e-10, 4.8e-10, 9.6e-10}; +double capAxis_NOR2_X1_A2_ZN_risingDelay[6] = {4.0e-16, 8.0e-16, 1.6e-15, 3.2e-15, 6.4e-15, 1.28e-14}; +double table_NOR2_X1_A2_ZN_risingDelay[6][8] = {{4.4600000000000006e-11, 4.8300000000000004e-11, 5.510000000000001e-11, 6.68e-11, 8.28e-11, 1.067e-10, 1.478e-10, 2.1590000000000002e-10}, {5.13e-11, 5.5000000000000004e-11, 6.19e-11, 7.4e-11, 9.160000000000001e-11, 1.1770000000000002e-10, 1.614e-10, 2.339e-10}, {6.49e-11, 6.84e-11, 7.530000000000001e-11, 8.76e-11, 1.079e-10, 1.378e-10, 1.863e-10, 2.6560000000000004e-10}, {9.150000000000001e-11, 9.510000000000001e-11, 1.0180000000000001e-10, 1.142e-10, 1.374e-10, 1.7340000000000002e-10, 2.301e-10, 3.212e-10}, {1.4460000000000002e-10, 1.483e-10, 1.55e-10, 1.672e-10, 1.908e-10, 2.356e-10, 3.0520000000000004e-10, 4.1440000000000004e-10}, {2.506e-10, 2.5430000000000004e-10, 2.6100000000000003e-10, 2.7330000000000003e-10, 2.966e-10, 3.4430000000000004e-10, 4.33e-10, 5.693000000000001e-10}}; +double lookTrAxis_NOR2_X1_A2_ZN_risingDelay(int iTr) {return trAxis_NOR2_X1_A2_ZN_risingDelay[iTr];} +double lookCapAxis_NOR2_X1_A2_ZN_risingDelay(int iCap) {return capAxis_NOR2_X1_A2_ZN_risingDelay[iCap];} +double lookTable_NOR2_X1_A2_ZN_risingDelay(int iTr, int iCap) {return table_NOR2_X1_A2_ZN_risingDelay[iCap][iTr];} + +double trAxis_NOR2_X1_A2_ZN_fallingDelay[8] = {7.5e-12, 1.5e-11, 3.0e-11, 6.0e-11, 1.2e-10, 2.4e-10, 4.8e-10, 9.6e-10}; +double capAxis_NOR2_X1_A2_ZN_fallingDelay[6] = {4.0e-16, 8.0e-16, 1.6e-15, 3.2e-15, 6.4e-15, 1.28e-14}; +double table_NOR2_X1_A2_ZN_fallingDelay[6][8] = {{1.79e-11, 2.15e-11, 2.78e-11, 3.4900000000000004e-11, 4.14e-11, 4.4200000000000006e-11, 3.73e-11, 7.3e-12}, {2.0600000000000002e-11, 2.4e-11, 3.0800000000000006e-11, 3.9e-11, 4.6700000000000004e-11, 5.1400000000000005e-11, 4.6700000000000004e-11, 1.9900000000000004e-11}, {2.5900000000000002e-11, 2.92e-11, 3.6100000000000003e-11, 4.610000000000001e-11, 5.6500000000000005e-11, 6.44e-11, 6.400000000000001e-11, 4.26e-11}, {3.6e-11, 3.9200000000000004e-11, 4.5900000000000004e-11, 5.86e-11, 7.360000000000001e-11, 8.730000000000001e-11, 9.43e-11, 8.250000000000001e-11}, {5.55e-11, 5.88e-11, 6.54e-11, 7.91e-11, 1.0140000000000001e-10, 1.25e-10, 1.447e-10, 1.493e-10}, {9.38e-11, 9.71e-11, 1.035e-10, 1.17e-10, 1.449e-10, 1.845e-10, 2.2500000000000002e-10, 2.566e-10}}; +double lookTrAxis_NOR2_X1_A2_ZN_fallingDelay(int iTr) {return trAxis_NOR2_X1_A2_ZN_fallingDelay[iTr];} +double lookCapAxis_NOR2_X1_A2_ZN_fallingDelay(int iCap) {return capAxis_NOR2_X1_A2_ZN_fallingDelay[iCap];} +double lookTable_NOR2_X1_A2_ZN_fallingDelay(int iTr, int iCap) {return table_NOR2_X1_A2_ZN_fallingDelay[iCap][iTr];} + +double trAxis_NOR2_X1_A2_ZN_risingTransition[8] = {7.5e-12, 1.5e-11, 3.0e-11, 6.0e-11, 1.2e-10, 2.4e-10, 4.8e-10, 9.6e-10}; +double capAxis_NOR2_X1_A2_ZN_risingTransition[6] = {4.0e-16, 8.0e-16, 1.6e-15, 3.2e-15, 6.4e-15, 1.28e-14}; +double table_NOR2_X1_A2_ZN_risingTransition[6][8] = {{2.66e-11, 2.66e-11, 2.6700000000000002e-11, 2.9700000000000005e-11, 3.860000000000001e-11, 5.3800000000000004e-11, 7.900000000000001e-11, 1.229e-10}, {3.27e-11, 3.27e-11, 3.2800000000000006e-11, 3.48e-11, 4.3900000000000005e-11, 5.940000000000001e-11, 8.500000000000002e-11, 1.296e-10}, {4.5e-11, 4.5e-11, 4.5100000000000005e-11, 4.6e-11, 5.4500000000000006e-11, 7.060000000000001e-11, 9.72e-11, 1.431e-10}, {6.930000000000001e-11, 6.930000000000001e-11, 6.930000000000001e-11, 6.940000000000001e-11, 7.43e-11, 9.180000000000001e-11, 1.204e-10, 1.689e-10}, {1.178e-10, 1.178e-10, 1.178e-10, 1.178e-10, 1.1840000000000003e-10, 1.323e-10, 1.646e-10, 2.176e-10}, {2.1490000000000003e-10, 2.148e-10, 2.1490000000000003e-10, 2.148e-10, 2.1490000000000003e-10, 2.1780000000000001e-10, 2.4790000000000004e-10, 3.0880000000000006e-10}}; +double lookTrAxis_NOR2_X1_A2_ZN_risingTransition(int iTr) {return trAxis_NOR2_X1_A2_ZN_risingTransition[iTr];} +double lookCapAxis_NOR2_X1_A2_ZN_risingTransition(int iCap) {return capAxis_NOR2_X1_A2_ZN_risingTransition[iCap];} +double lookTable_NOR2_X1_A2_ZN_risingTransition(int iTr, int iCap) {return table_NOR2_X1_A2_ZN_risingTransition[iCap][iTr];} + +double trAxis_NOR2_X1_A2_ZN_fallingTransition[8] = {7.5e-12, 1.5e-11, 3.0e-11, 6.0e-11, 1.2e-10, 2.4e-10, 4.8e-10, 9.6e-10}; +double capAxis_NOR2_X1_A2_ZN_fallingTransition[6] = {4.0e-16, 8.0e-16, 1.6e-15, 3.2e-15, 6.4e-15, 1.28e-14}; +double table_NOR2_X1_A2_ZN_fallingTransition[6][8] = {{1.21e-11, 1.21e-11, 1.53e-11, 2.2e-11, 3.2599999999999996e-11, 5.0300000000000003e-11, 8.07e-11, 1.342e-10}, {1.4500000000000002e-11, 1.4200000000000002e-11, 1.67e-11, 2.3900000000000003e-11, 3.5200000000000005e-11, 5.37e-11, 8.550000000000001e-11, 1.41e-10}, {1.8700000000000004e-11, 1.85e-11, 2.01e-11, 2.76e-11, 3.980000000000001e-11, 5.990000000000001e-11, 9.38e-11, 1.5300000000000001e-10}, {2.6900000000000002e-11, 2.6900000000000002e-11, 2.7e-11, 3.3300000000000004e-11, 4.7500000000000004e-11, 7.01e-11, 1.0760000000000001e-10, 1.7230000000000002e-10}, {4.3200000000000003e-11, 4.3200000000000003e-11, 4.33e-11, 4.52e-11, 6.01e-11, 8.69e-11, 1.3000000000000002e-10, 2.027e-10}, {7.600000000000001e-11, 7.600000000000001e-11, 7.59e-11, 7.600000000000001e-11, 8.240000000000001e-11, 1.1380000000000001e-10, 1.657e-10, 2.4970000000000003e-10}}; +double lookTrAxis_NOR2_X1_A2_ZN_fallingTransition(int iTr) {return trAxis_NOR2_X1_A2_ZN_fallingTransition[iTr];} +double lookCapAxis_NOR2_X1_A2_ZN_fallingTransition(int iCap) {return capAxis_NOR2_X1_A2_ZN_fallingTransition[iCap];} +double lookTable_NOR2_X1_A2_ZN_fallingTransition(int iTr, int iCap) {return table_NOR2_X1_A2_ZN_fallingTransition[iCap][iTr];} + +double trAxis_NOR2_X2_A1_ZN_risingDelay[8] = {7.5e-12, 1.5e-11, 3.0e-11, 6.0e-11, 1.2e-10, 2.4e-10, 4.8e-10, 9.6e-10}; +double capAxis_NOR2_X2_A1_ZN_risingDelay[6] = {4.0e-16, 1.6e-15, 3.2e-15, 6.4e-15, 1.28e-14, 2.56e-14}; +double table_NOR2_X2_A1_ZN_risingDelay[6][8] = {{2.3e-11, 2.6300000000000002e-11, 3.3700000000000004e-11, 4.4300000000000005e-11, 5.970000000000001e-11, 8.400000000000001e-11, 1.243e-10, 1.954e-10}, {3.3e-11, 3.620000000000001e-11, 4.33e-11, 5.67e-11, 7.54e-11, 1.0340000000000001e-10, 1.485e-10, 2.2470000000000004e-10}, {4.6300000000000004e-11, 4.93e-11, 5.6200000000000004e-11, 7.1e-11, 9.370000000000001e-11, 1.2620000000000001e-10, 1.767e-10, 2.5979999999999997e-10}, {7.240000000000002e-11, 7.530000000000001e-11, 8.190000000000001e-11, 9.610000000000001e-11, 1.2470000000000002e-10, 1.658e-10, 2.2570000000000003e-10, 3.206e-10}, {1.243e-10, 1.272e-10, 1.335e-10, 1.4710000000000001e-10, 1.762e-10, 2.3120000000000001e-10, 3.086e-10, 4.2330000000000003e-10}, {2.278e-10, 2.3080000000000002e-10, 2.3690000000000003e-10, 2.5e-10, 2.7760000000000005e-10, 3.363e-10, 4.4370000000000003e-10, 5.937e-10}}; +double lookTrAxis_NOR2_X2_A1_ZN_risingDelay(int iTr) {return trAxis_NOR2_X2_A1_ZN_risingDelay[iTr];} +double lookCapAxis_NOR2_X2_A1_ZN_risingDelay(int iCap) {return capAxis_NOR2_X2_A1_ZN_risingDelay[iCap];} +double lookTable_NOR2_X2_A1_ZN_risingDelay(int iTr, int iCap) {return table_NOR2_X2_A1_ZN_risingDelay[iCap][iTr];} + +double trAxis_NOR2_X2_A1_ZN_fallingDelay[8] = {7.5e-12, 1.5e-11, 3.0e-11, 6.0e-11, 1.2e-10, 2.4e-10, 4.8e-10, 9.6e-10}; +double capAxis_NOR2_X2_A1_ZN_fallingDelay[6] = {4.0e-16, 1.6e-15, 3.2e-15, 6.4e-15, 1.28e-14, 2.56e-14}; +double table_NOR2_X2_A1_ZN_fallingDelay[6][8] = {{1.0600000000000001e-11, 1.33e-11, 1.61e-11, 1.8100000000000004e-11, 1.7600000000000003e-11, 1.0000000000000001e-11, 1.35e-11, 7.02e-11}, {1.41e-11, 1.74e-11, 2.1600000000000002e-11, 2.5700000000000002e-11, 2.78e-11, 2.4e-11, 5.4000000000000004e-12, 4.6e-11}, {1.8700000000000004e-11, 2.2100000000000003e-11, 2.78e-11, 3.4000000000000005e-11, 3.9200000000000004e-11, 3.9600000000000004e-11, 2.64e-11, 1.79e-11}, {2.7900000000000002e-11, 3.12e-11, 3.8000000000000004e-11, 4.7900000000000004e-11, 5.8100000000000005e-11, 6.519999999999999e-11, 6.12e-11, 2.8900000000000002e-11}, {4.6e-11, 4.93e-11, 5.600000000000001e-11, 6.95e-11, 8.77e-11, 1.055e-10, 1.161e-10, 1.0330000000000001e-10}, {8.22e-11, 8.550000000000001e-11, 9.2e-11, 1.056e-10, 1.3270000000000002e-10, 1.6700000000000002e-10, 1.9960000000000001e-10, 2.172e-10}}; +double lookTrAxis_NOR2_X2_A1_ZN_fallingDelay(int iTr) {return trAxis_NOR2_X2_A1_ZN_fallingDelay[iTr];} +double lookCapAxis_NOR2_X2_A1_ZN_fallingDelay(int iCap) {return capAxis_NOR2_X2_A1_ZN_fallingDelay[iCap];} +double lookTable_NOR2_X2_A1_ZN_fallingDelay(int iTr, int iCap) {return table_NOR2_X2_A1_ZN_fallingDelay[iCap][iTr];} + +double trAxis_NOR2_X2_A1_ZN_risingTransition[8] = {7.5e-12, 1.5e-11, 3.0e-11, 6.0e-11, 1.2e-10, 2.4e-10, 4.8e-10, 9.6e-10}; +double capAxis_NOR2_X2_A1_ZN_risingTransition[6] = {4.0e-16, 1.6e-15, 3.2e-15, 6.4e-15, 1.28e-14, 2.56e-14}; +double table_NOR2_X2_A1_ZN_risingTransition[6][8] = {{1.8200000000000002e-11, 1.79e-11, 2.0000000000000002e-11, 2.6200000000000004e-11, 3.5200000000000005e-11, 5.0300000000000003e-11, 7.85e-11, 1.3330000000000002e-10}, {2.7400000000000004e-11, 2.7300000000000002e-11, 2.76e-11, 3.3700000000000004e-11, 4.45e-11, 6.12e-11, 9.04e-11, 1.457e-10}, {3.93e-11, 3.9500000000000006e-11, 3.9200000000000004e-11, 4.2700000000000005e-11, 5.55e-11, 7.45e-11, 1.056e-10, 1.6210000000000001e-10}, {6.3e-11, 6.310000000000001e-11, 6.310000000000001e-11, 6.34e-11, 7.340000000000001e-11, 9.750000000000001e-11, 1.3320000000000002e-10, 1.934e-10}, {1.104e-10, 1.104e-10, 1.104e-10, 1.104e-10, 1.122e-10, 1.3519999999999998e-10, 1.812e-10, 2.5040000000000003e-10}, {2.052e-10, 2.052e-10, 2.052e-10, 2.052e-10, 2.052e-10, 2.1040000000000002e-10, 2.588e-10, 3.4860000000000007e-10}}; +double lookTrAxis_NOR2_X2_A1_ZN_risingTransition(int iTr) {return trAxis_NOR2_X2_A1_ZN_risingTransition[iTr];} +double lookCapAxis_NOR2_X2_A1_ZN_risingTransition(int iCap) {return capAxis_NOR2_X2_A1_ZN_risingTransition[iCap];} +double lookTable_NOR2_X2_A1_ZN_risingTransition(int iTr, int iCap) {return table_NOR2_X2_A1_ZN_risingTransition[iCap][iTr];} + +double trAxis_NOR2_X2_A1_ZN_fallingTransition[8] = {7.5e-12, 1.5e-11, 3.0e-11, 6.0e-11, 1.2e-10, 2.4e-10, 4.8e-10, 9.6e-10}; +double capAxis_NOR2_X2_A1_ZN_fallingTransition[6] = {4.0e-16, 1.6e-15, 3.2e-15, 6.4e-15, 1.28e-14, 2.56e-14}; +double table_NOR2_X2_A1_ZN_fallingTransition[6][8] = {{5.3000000000000004e-12, 7.100000000000001e-12, 1.0400000000000001e-11, 1.6000000000000003e-11, 2.5900000000000002e-11, 4.3100000000000005e-11, 7.43e-11, 1.3280000000000002e-10}, {8.000000000000001e-12, 9.200000000000001e-12, 1.3100000000000002e-11, 1.9300000000000004e-11, 2.99e-11, 4.86e-11, 8.15e-11, 1.42e-10}, {1.2e-11, 1.2200000000000002e-11, 1.6000000000000003e-11, 2.3e-11, 3.48e-11, 5.480000000000001e-11, 9.0e-11, 1.529e-10}, {1.9800000000000002e-11, 1.9800000000000002e-11, 2.1400000000000002e-11, 2.92e-11, 4.26e-11, 6.500000000000001e-11, 1.035e-10, 1.714e-10}, {3.5600000000000005e-11, 3.5600000000000005e-11, 3.5700000000000003e-11, 3.980000000000001e-11, 5.5700000000000005e-11, 8.160000000000001e-11, 1.2509999999999999e-10, 2.0050000000000003e-10}, {6.72e-11, 6.71e-11, 6.72e-11, 6.73e-11, 7.660000000000001e-11, 1.085e-10, 1.5950000000000002e-10, 2.453e-10}}; +double lookTrAxis_NOR2_X2_A1_ZN_fallingTransition(int iTr) {return trAxis_NOR2_X2_A1_ZN_fallingTransition[iTr];} +double lookCapAxis_NOR2_X2_A1_ZN_fallingTransition(int iCap) {return capAxis_NOR2_X2_A1_ZN_fallingTransition[iCap];} +double lookTable_NOR2_X2_A1_ZN_fallingTransition(int iTr, int iCap) {return table_NOR2_X2_A1_ZN_fallingTransition[iCap][iTr];} + +double trAxis_NOR2_X2_A2_ZN_risingDelay[8] = {7.5e-12, 1.5e-11, 3.0e-11, 6.0e-11, 1.2e-10, 2.4e-10, 4.8e-10, 9.6e-10}; +double capAxis_NOR2_X2_A2_ZN_risingDelay[6] = {4.0e-16, 1.6e-15, 3.2e-15, 6.4e-15, 1.28e-14, 2.56e-14}; +double table_NOR2_X2_A2_ZN_risingDelay[6][8] = {{3.3700000000000004e-11, 3.740000000000001e-11, 4.4e-11, 5.390000000000001e-11, 6.71e-11, 8.88e-11, 1.267e-10, 1.903e-10}, {4.370000000000001e-11, 4.730000000000001e-11, 5.390000000000001e-11, 6.53e-11, 8.12e-11, 1.0630000000000001e-10, 1.486e-10, 2.188e-10}, {5.7000000000000003e-11, 6.05e-11, 6.690000000000001e-11, 7.920000000000001e-11, 9.800000000000001e-11, 1.268e-10, 1.742e-10, 2.515e-10}, {8.300000000000001e-11, 8.65e-11, 9.3e-11, 1.051e-10, 1.277e-10, 1.6270000000000002e-10, 2.1840000000000002e-10, 3.077e-10}, {1.349e-10, 1.385e-10, 1.4480000000000003e-10, 1.5680000000000002e-10, 1.8040000000000002e-10, 2.246e-10, 2.93e-10, 4.009e-10}, {2.384e-10, 2.42e-10, 2.485e-10, 2.6040000000000005e-10, 2.837e-10, 3.317e-10, 4.194e-10, 5.542e-10}}; +double lookTrAxis_NOR2_X2_A2_ZN_risingDelay(int iTr) {return trAxis_NOR2_X2_A2_ZN_risingDelay[iTr];} +double lookCapAxis_NOR2_X2_A2_ZN_risingDelay(int iCap) {return capAxis_NOR2_X2_A2_ZN_risingDelay[iCap];} +double lookTable_NOR2_X2_A2_ZN_risingDelay(int iTr, int iCap) {return table_NOR2_X2_A2_ZN_risingDelay[iCap][iTr];} + +double trAxis_NOR2_X2_A2_ZN_fallingDelay[8] = {7.5e-12, 1.5e-11, 3.0e-11, 6.0e-11, 1.2e-10, 2.4e-10, 4.8e-10, 9.6e-10}; +double capAxis_NOR2_X2_A2_ZN_fallingDelay[6] = {4.0e-16, 1.6e-15, 3.2e-15, 6.4e-15, 1.28e-14, 2.56e-14}; +double table_NOR2_X2_A2_ZN_fallingDelay[6][8] = {{1.39e-11, 1.7500000000000004e-11, 2.25e-11, 2.7400000000000004e-11, 3.1e-11, 3.0e-11, 1.8e-11, 1.89e-11}, {1.7800000000000003e-11, 2.1200000000000002e-11, 2.7300000000000002e-11, 3.4000000000000005e-11, 3.980000000000001e-11, 4.17e-11, 3.3200000000000006e-11, 1.1000000000000002e-12}, {2.2900000000000003e-11, 2.6200000000000004e-11, 3.2800000000000006e-11, 4.1500000000000005e-11, 4.9900000000000003e-11, 5.510000000000001e-11, 5.11e-11, 2.4500000000000003e-11}, {3.2500000000000004e-11, 3.58e-11, 4.26e-11, 5.43e-11, 6.72e-11, 7.840000000000001e-11, 8.190000000000001e-11, 6.510000000000001e-11}, {5.120000000000001e-11, 5.44e-11, 6.11e-11, 7.480000000000002e-11, 9.53e-11, 1.1620000000000001e-10, 1.325e-10, 1.3210000000000001e-10}, {8.790000000000001e-11, 9.11e-11, 9.760000000000002e-11, 1.11e-10, 1.385e-10, 1.755e-10, 2.123e-10, 2.385e-10}}; +double lookTrAxis_NOR2_X2_A2_ZN_fallingDelay(int iTr) {return trAxis_NOR2_X2_A2_ZN_fallingDelay[iTr];} +double lookCapAxis_NOR2_X2_A2_ZN_fallingDelay(int iCap) {return capAxis_NOR2_X2_A2_ZN_fallingDelay[iCap];} +double lookTable_NOR2_X2_A2_ZN_fallingDelay(int iTr, int iCap) {return table_NOR2_X2_A2_ZN_fallingDelay[iCap][iTr];} + +double trAxis_NOR2_X2_A2_ZN_risingTransition[8] = {7.5e-12, 1.5e-11, 3.0e-11, 6.0e-11, 1.2e-10, 2.4e-10, 4.8e-10, 9.6e-10}; +double capAxis_NOR2_X2_A2_ZN_risingTransition[6] = {4.0e-16, 1.6e-15, 3.2e-15, 6.4e-15, 1.28e-14, 2.56e-14}; +double table_NOR2_X2_A2_ZN_risingTransition[6][8] = {{1.8400000000000002e-11, 1.8400000000000002e-11, 1.89e-11, 2.3300000000000003e-11, 3.1600000000000006e-11, 4.5800000000000006e-11, 6.95e-11, 1.122e-10}, {2.7400000000000004e-11, 2.7300000000000002e-11, 2.7500000000000002e-11, 3.07e-11, 3.9500000000000006e-11, 5.4100000000000006e-11, 7.86e-11, 1.218e-10}, {3.94e-11, 3.9500000000000006e-11, 3.94e-11, 4.11e-11, 5.01e-11, 6.54e-11, 9.070000000000001e-11, 1.3530000000000001e-10}, {6.310000000000001e-11, 6.310000000000001e-11, 6.3e-11, 6.310000000000001e-11, 6.940000000000001e-11, 8.640000000000001e-11, 1.1380000000000001e-10, 1.611e-10}, {1.104e-10, 1.104e-10, 1.104e-10, 1.104e-10, 1.1160000000000001e-10, 1.265e-10, 1.576e-10, 2.0930000000000002e-10}, {2.052e-10, 2.052e-10, 2.052e-10, 2.052e-10, 2.052e-10, 2.0890000000000002e-10, 2.399e-10, 2.9930000000000004e-10}}; +double lookTrAxis_NOR2_X2_A2_ZN_risingTransition(int iTr) {return trAxis_NOR2_X2_A2_ZN_risingTransition[iTr];} +double lookCapAxis_NOR2_X2_A2_ZN_risingTransition(int iCap) {return capAxis_NOR2_X2_A2_ZN_risingTransition[iCap];} +double lookTable_NOR2_X2_A2_ZN_risingTransition(int iTr, int iCap) {return table_NOR2_X2_A2_ZN_risingTransition[iCap][iTr];} + +double trAxis_NOR2_X2_A2_ZN_fallingTransition[8] = {7.5e-12, 1.5e-11, 3.0e-11, 6.0e-11, 1.2e-10, 2.4e-10, 4.8e-10, 9.6e-10}; +double capAxis_NOR2_X2_A2_ZN_fallingTransition[6] = {4.0e-16, 1.6e-15, 3.2e-15, 6.4e-15, 1.28e-14, 2.56e-14}; +double table_NOR2_X2_A2_ZN_fallingTransition[6][8] = {{8.500000000000001e-12, 9.200000000000001e-12, 1.2800000000000002e-11, 1.8700000000000004e-11, 2.8300000000000002e-11, 4.45e-11, 7.27e-11, 1.2320000000000002e-10}, {1.18e-11, 1.18e-11, 1.53e-11, 2.1800000000000002e-11, 3.24e-11, 5.01e-11, 8.07e-11, 1.346e-10}, {1.5800000000000003e-11, 1.56e-11, 1.8200000000000002e-11, 2.5700000000000002e-11, 3.73e-11, 5.64e-11, 8.94e-11, 1.4710000000000001e-10}, {2.37e-11, 2.37e-11, 2.4500000000000003e-11, 3.1399999999999996e-11, 4.5100000000000005e-11, 6.690000000000001e-11, 1.035e-10, 1.6700000000000002e-10}, {3.9500000000000006e-11, 3.9500000000000006e-11, 3.9500000000000006e-11, 4.220000000000001e-11, 5.7700000000000005e-11, 8.380000000000001e-11, 1.2590000000000003e-10, 1.9750000000000002e-10}, {7.1e-11, 7.1e-11, 7.11e-11, 7.1e-11, 7.890000000000001e-11, 1.104e-10, 1.6120000000000002e-10, 2.44e-10}}; +double lookTrAxis_NOR2_X2_A2_ZN_fallingTransition(int iTr) {return trAxis_NOR2_X2_A2_ZN_fallingTransition[iTr];} +double lookCapAxis_NOR2_X2_A2_ZN_fallingTransition(int iCap) {return capAxis_NOR2_X2_A2_ZN_fallingTransition[iCap];} +double lookTable_NOR2_X2_A2_ZN_fallingTransition(int iTr, int iCap) {return table_NOR2_X2_A2_ZN_fallingTransition[iCap][iTr];} + +double trAxis_NOR2_X4_A1_ZN_risingDelay[8] = {7.5e-12, 1.5e-11, 3.0e-11, 6.0e-11, 1.2e-10, 2.4e-10, 4.8e-10, 9.6e-10}; +double capAxis_NOR2_X4_A1_ZN_risingDelay[6] = {4.0e-16, 3.2e-15, 6.4e-15, 1.28e-14, 2.56e-14, 5.12e-14}; +double table_NOR2_X4_A1_ZN_risingDelay[6][8] = {{2.0000000000000002e-11, 2.3500000000000003e-11, 3.0800000000000006e-11, 4.09e-11, 5.5800000000000004e-11, 7.97e-11, 1.1990000000000002e-10, 1.913e-10}, {3.17e-11, 3.48e-11, 4.21e-11, 5.56e-11, 7.43e-11, 1.026e-10, 1.483e-10, 2.2590000000000002e-10}, {4.490000000000001e-11, 4.8e-11, 5.480000000000001e-11, 6.980000000000001e-11, 9.260000000000001e-11, 1.253e-10, 1.764e-10, 2.6090000000000005e-10}, {7.1e-11, 7.4e-11, 8.060000000000001e-11, 9.49e-11, 1.2360000000000002e-10, 1.649e-10, 2.2530000000000001e-10, 3.2150000000000003e-10}, {1.229e-10, 1.2590000000000003e-10, 1.3220000000000002e-10, 1.4580000000000003e-10, 1.75e-10, 2.302e-10, 3.081e-10, 4.2400000000000004e-10}, {2.2650000000000002e-10, 2.2950000000000003e-10, 2.357e-10, 2.4870000000000003e-10, 2.764e-10, 3.3520000000000004e-10, 4.43e-10, 5.94e-10}}; +double lookTrAxis_NOR2_X4_A1_ZN_risingDelay(int iTr) {return trAxis_NOR2_X4_A1_ZN_risingDelay[iTr];} +double lookCapAxis_NOR2_X4_A1_ZN_risingDelay(int iCap) {return capAxis_NOR2_X4_A1_ZN_risingDelay[iCap];} +double lookTable_NOR2_X4_A1_ZN_risingDelay(int iTr, int iCap) {return table_NOR2_X4_A1_ZN_risingDelay[iCap][iTr];} + +double trAxis_NOR2_X4_A1_ZN_fallingDelay[8] = {7.5e-12, 1.5e-11, 3.0e-11, 6.0e-11, 1.2e-10, 2.4e-10, 4.8e-10, 9.6e-10}; +double capAxis_NOR2_X4_A1_ZN_fallingDelay[6] = {4.0e-16, 3.2e-15, 6.4e-15, 1.28e-14, 2.56e-14, 5.12e-14}; +double table_NOR2_X4_A1_ZN_fallingDelay[6][8] = {{1.0200000000000001e-11, 1.26e-11, 1.5e-11, 1.65e-11, 1.5e-11, 6.100000000000001e-12, 1.92e-11, 7.900000000000001e-11}, {1.4200000000000002e-11, 1.74e-11, 2.1600000000000002e-11, 2.54e-11, 2.72e-11, 2.2700000000000003e-11, 3.0e-12, 5.0300000000000003e-11}, {1.8700000000000004e-11, 2.2e-11, 2.78e-11, 3.3799999999999996e-11, 3.85e-11, 3.82e-11, 2.4e-11, 2.2300000000000003e-11}, {2.76e-11, 3.0900000000000004e-11, 3.78e-11, 4.7500000000000004e-11, 5.7200000000000007e-11, 6.370000000000001e-11, 5.86e-11, 2.42e-11}, {4.5400000000000006e-11, 4.8700000000000004e-11, 5.55e-11, 6.89e-11, 8.670000000000001e-11, 1.037e-10, 1.1310000000000002e-10, 9.820000000000001e-11}, {8.1e-11, 8.430000000000001e-11, 9.09e-11, 1.043e-10, 1.3120000000000002e-10, 1.6470000000000004e-10, 1.961e-10, 2.113e-10}}; +double lookTrAxis_NOR2_X4_A1_ZN_fallingDelay(int iTr) {return trAxis_NOR2_X4_A1_ZN_fallingDelay[iTr];} +double lookCapAxis_NOR2_X4_A1_ZN_fallingDelay(int iCap) {return capAxis_NOR2_X4_A1_ZN_fallingDelay[iCap];} +double lookTable_NOR2_X4_A1_ZN_fallingDelay(int iTr, int iCap) {return table_NOR2_X4_A1_ZN_fallingDelay[iCap][iTr];} + +double trAxis_NOR2_X4_A1_ZN_risingTransition[8] = {7.5e-12, 1.5e-11, 3.0e-11, 6.0e-11, 1.2e-10, 2.4e-10, 4.8e-10, 9.6e-10}; +double capAxis_NOR2_X4_A1_ZN_risingTransition[6] = {4.0e-16, 3.2e-15, 6.4e-15, 1.28e-14, 2.56e-14, 5.12e-14}; +double table_NOR2_X4_A1_ZN_risingTransition[6][8] = {{1.61e-11, 1.59e-11, 1.86e-11, 2.43e-11, 3.31e-11, 4.81e-11, 7.59e-11, 1.313e-10}, {2.6900000000000002e-11, 2.6800000000000004e-11, 2.72e-11, 3.3300000000000004e-11, 4.4e-11, 6.07e-11, 8.99e-11, 1.454e-10}, {3.9e-11, 3.9e-11, 3.89e-11, 4.2400000000000004e-11, 5.5000000000000004e-11, 7.39e-11, 1.05e-10, 1.6160000000000002e-10}, {6.270000000000001e-11, 6.279999999999999e-11, 6.279999999999999e-11, 6.310000000000001e-11, 7.3e-11, 9.700000000000001e-11, 1.326e-10, 1.9270000000000002e-10}, {1.1010000000000001e-10, 1.1020000000000002e-10, 1.1020000000000002e-10, 1.1010000000000001e-10, 1.1190000000000001e-10, 1.3480000000000002e-10, 1.8060000000000003e-10, 2.495e-10}, {2.05e-10, 2.049e-10, 2.05e-10, 2.05e-10, 2.05e-10, 2.1010000000000003e-10, 2.583e-10, 3.4770000000000005e-10}}; +double lookTrAxis_NOR2_X4_A1_ZN_risingTransition(int iTr) {return trAxis_NOR2_X4_A1_ZN_risingTransition[iTr];} +double lookCapAxis_NOR2_X4_A1_ZN_risingTransition(int iCap) {return capAxis_NOR2_X4_A1_ZN_risingTransition[iCap];} +double lookTable_NOR2_X4_A1_ZN_risingTransition(int iTr, int iCap) {return table_NOR2_X4_A1_ZN_risingTransition[iCap][iTr];} + +double trAxis_NOR2_X4_A1_ZN_fallingTransition[8] = {7.5e-12, 1.5e-11, 3.0e-11, 6.0e-11, 1.2e-10, 2.4e-10, 4.8e-10, 9.6e-10}; +double capAxis_NOR2_X4_A1_ZN_fallingTransition[6] = {4.0e-16, 3.2e-15, 6.4e-15, 1.28e-14, 2.56e-14, 5.12e-14}; +double table_NOR2_X4_A1_ZN_fallingTransition[6][8] = {{4.8e-12, 6.700000000000001e-12, 9.800000000000001e-12, 1.52e-11, 2.4700000000000003e-11, 4.1500000000000005e-11, 7.19e-11, 1.3000000000000002e-10}, {7.900000000000001e-12, 9.100000000000001e-12, 1.29e-11, 1.91e-11, 2.9600000000000006e-11, 4.81e-11, 8.080000000000001e-11, 1.409e-10}, {1.18e-11, 1.21e-11, 1.5699999999999998e-11, 2.3e-11, 3.4500000000000004e-11, 5.43e-11, 8.920000000000001e-11, 1.5190000000000001e-10}, {1.95e-11, 1.95e-11, 2.1100000000000003e-11, 2.9000000000000003e-11, 4.23e-11, 6.450000000000001e-11, 1.0280000000000001e-10, 1.704e-10}, {3.500000000000001e-11, 3.500000000000001e-11, 3.500000000000001e-11, 3.94e-11, 5.52e-11, 8.110000000000001e-11, 1.2420000000000002e-10, 1.994e-10}, {6.610000000000001e-11, 6.6e-11, 6.6e-11, 6.62e-11, 7.59e-11, 1.0760000000000001e-10, 1.5840000000000002e-10, 2.439e-10}}; +double lookTrAxis_NOR2_X4_A1_ZN_fallingTransition(int iTr) {return trAxis_NOR2_X4_A1_ZN_fallingTransition[iTr];} +double lookCapAxis_NOR2_X4_A1_ZN_fallingTransition(int iCap) {return capAxis_NOR2_X4_A1_ZN_fallingTransition[iCap];} +double lookTable_NOR2_X4_A1_ZN_fallingTransition(int iTr, int iCap) {return table_NOR2_X4_A1_ZN_fallingTransition[iCap][iTr];} + +double trAxis_NOR2_X4_A2_ZN_risingDelay[8] = {7.5e-12, 1.5e-11, 3.0e-11, 6.0e-11, 1.2e-10, 2.4e-10, 4.8e-10, 9.6e-10}; +double capAxis_NOR2_X4_A2_ZN_risingDelay[6] = {4.0e-16, 3.2e-15, 6.4e-15, 1.28e-14, 2.56e-14, 5.12e-14}; +double table_NOR2_X4_A2_ZN_risingDelay[6][8] = {{3.34e-11, 3.7e-11, 4.33e-11, 5.2200000000000005e-11, 6.42e-11, 8.480000000000001e-11, 1.218e-10, 1.848e-10}, {4.5100000000000005e-11, 4.86e-11, 5.5000000000000004e-11, 6.59e-11, 8.12e-11, 1.0580000000000001e-10, 1.481e-10, 2.188e-10}, {5.84e-11, 6.180000000000001e-11, 6.800000000000001e-11, 7.98e-11, 9.810000000000002e-11, 1.2640000000000002e-10, 1.7390000000000001e-10, 2.517e-10}, {8.440000000000001e-11, 8.790000000000001e-11, 9.41e-11, 1.059e-10, 1.281e-10, 1.626e-10, 2.182e-10, 3.081e-10}, {1.362e-10, 1.3980000000000002e-10, 1.4610000000000002e-10, 1.5780000000000001e-10, 1.8110000000000003e-10, 2.2480000000000001e-10, 2.9310000000000005e-10, 4.014e-10}, {2.3980000000000004e-10, 2.434e-10, 2.498e-10, 2.6150000000000003e-10, 2.8460000000000003e-10, 3.323e-10, 4.1980000000000004e-10, 5.55e-10}}; +double lookTrAxis_NOR2_X4_A2_ZN_risingDelay(int iTr) {return trAxis_NOR2_X4_A2_ZN_risingDelay[iTr];} +double lookCapAxis_NOR2_X4_A2_ZN_risingDelay(int iCap) {return capAxis_NOR2_X4_A2_ZN_risingDelay[iCap];} +double lookTable_NOR2_X4_A2_ZN_risingDelay(int iTr, int iCap) {return table_NOR2_X4_A2_ZN_risingDelay[iCap][iTr];} + +double trAxis_NOR2_X4_A2_ZN_fallingDelay[8] = {7.5e-12, 1.5e-11, 3.0e-11, 6.0e-11, 1.2e-10, 2.4e-10, 4.8e-10, 9.6e-10}; +double capAxis_NOR2_X4_A2_ZN_fallingDelay[6] = {4.0e-16, 3.2e-15, 6.4e-15, 1.28e-14, 2.56e-14, 5.12e-14}; +double table_NOR2_X4_A2_ZN_fallingDelay[6][8] = {{1.33e-11, 1.6899999999999998e-11, 2.15e-11, 2.6100000000000002e-11, 2.9100000000000002e-11, 2.7300000000000002e-11, 1.36e-11, 2.5900000000000002e-11}, {1.7800000000000003e-11, 2.1200000000000002e-11, 2.72e-11, 3.3799999999999996e-11, 3.94e-11, 4.09e-11, 3.1600000000000006e-11, 2.4e-12}, {2.28e-11, 2.6100000000000002e-11, 3.2800000000000006e-11, 4.11e-11, 4.9400000000000005e-11, 5.4200000000000004e-11, 4.93e-11, 2.09e-11}, {3.22e-11, 3.55e-11, 4.23e-11, 5.390000000000001e-11, 6.660000000000001e-11, 7.73e-11, 7.99e-11, 6.12e-11}, {5.0600000000000005e-11, 5.3800000000000004e-11, 6.05e-11, 7.420000000000001e-11, 9.43e-11, 1.1480000000000001e-10, 1.3000000000000002e-10, 1.277e-10}, {8.670000000000001e-11, 8.99e-11, 9.63e-11, 1.098e-10, 1.372e-10, 1.735e-10, 2.0910000000000003e-10, 2.334e-10}}; +double lookTrAxis_NOR2_X4_A2_ZN_fallingDelay(int iTr) {return trAxis_NOR2_X4_A2_ZN_fallingDelay[iTr];} +double lookCapAxis_NOR2_X4_A2_ZN_fallingDelay(int iCap) {return capAxis_NOR2_X4_A2_ZN_fallingDelay[iCap];} +double lookTable_NOR2_X4_A2_ZN_fallingDelay(int iTr, int iCap) {return table_NOR2_X4_A2_ZN_fallingDelay[iCap][iTr];} + +double trAxis_NOR2_X4_A2_ZN_risingTransition[8] = {7.5e-12, 1.5e-11, 3.0e-11, 6.0e-11, 1.2e-10, 2.4e-10, 4.8e-10, 9.6e-10}; +double capAxis_NOR2_X4_A2_ZN_risingTransition[6] = {4.0e-16, 3.2e-15, 6.4e-15, 1.28e-14, 2.56e-14, 5.12e-14}; +double table_NOR2_X4_A2_ZN_risingTransition[6][8] = {{1.6400000000000003e-11, 1.65e-11, 1.7000000000000003e-11, 2.15e-11, 2.98e-11, 4.3900000000000005e-11, 6.77e-11, 1.1110000000000001e-10}, {2.7e-11, 2.6900000000000002e-11, 2.7e-11, 3.02e-11, 3.9100000000000006e-11, 5.37e-11, 7.820000000000001e-11, 1.218e-10}, {3.9100000000000006e-11, 3.9100000000000006e-11, 3.9100000000000006e-11, 4.05e-11, 4.96e-11, 6.500000000000001e-11, 9.030000000000001e-11, 1.3500000000000002e-10}, {6.279999999999999e-11, 6.270000000000001e-11, 6.270000000000001e-11, 6.279999999999999e-11, 6.900000000000001e-11, 8.6e-11, 1.134e-10, 1.606e-10}, {1.1010000000000001e-10, 1.1020000000000002e-10, 1.1010000000000001e-10, 1.1020000000000002e-10, 1.113e-10, 1.2620000000000001e-10, 1.572e-10, 2.0880000000000002e-10}, {2.05e-10, 2.05e-10, 2.05e-10, 2.049e-10, 2.05e-10, 2.086e-10, 2.3960000000000003e-10, 2.9880000000000004e-10}}; +double lookTrAxis_NOR2_X4_A2_ZN_risingTransition(int iTr) {return trAxis_NOR2_X4_A2_ZN_risingTransition[iTr];} +double lookCapAxis_NOR2_X4_A2_ZN_risingTransition(int iCap) {return capAxis_NOR2_X4_A2_ZN_risingTransition[iCap];} +double lookTable_NOR2_X4_A2_ZN_risingTransition(int iTr, int iCap) {return table_NOR2_X4_A2_ZN_risingTransition[iCap][iTr];} + +double trAxis_NOR2_X4_A2_ZN_fallingTransition[8] = {7.5e-12, 1.5e-11, 3.0e-11, 6.0e-11, 1.2e-10, 2.4e-10, 4.8e-10, 9.6e-10}; +double capAxis_NOR2_X4_A2_ZN_fallingTransition[6] = {4.0e-16, 3.2e-15, 6.4e-15, 1.28e-14, 2.56e-14, 5.12e-14}; +double table_NOR2_X4_A2_ZN_fallingTransition[6][8] = {{7.8e-12, 8.600000000000001e-12, 1.2200000000000002e-11, 1.7800000000000003e-11, 2.7e-11, 4.2700000000000005e-11, 6.990000000000001e-11, 1.1890000000000002e-10}, {1.15e-11, 1.16e-11, 1.5e-11, 2.15e-11, 3.19e-11, 4.9400000000000005e-11, 7.950000000000001e-11, 1.3280000000000002e-10}, {1.55e-11, 1.53e-11, 1.7600000000000003e-11, 2.5100000000000003e-11, 3.6800000000000005e-11, 5.5800000000000004e-11, 8.840000000000001e-11, 1.455e-10}, {2.3300000000000003e-11, 2.32e-11, 2.4e-11, 3.1e-11, 4.4600000000000006e-11, 6.62e-11, 1.026e-10, 1.6550000000000002e-10}, {3.87e-11, 3.87e-11, 3.87e-11, 4.1600000000000004e-11, 5.71e-11, 8.300000000000001e-11, 1.249e-10, 1.9600000000000002e-10}, {6.990000000000001e-11, 6.980000000000001e-11, 6.990000000000001e-11, 6.980000000000001e-11, 7.79e-11, 1.0950000000000001e-10, 1.5989999999999999e-10, 2.423e-10}}; +double lookTrAxis_NOR2_X4_A2_ZN_fallingTransition(int iTr) {return trAxis_NOR2_X4_A2_ZN_fallingTransition[iTr];} +double lookCapAxis_NOR2_X4_A2_ZN_fallingTransition(int iCap) {return capAxis_NOR2_X4_A2_ZN_fallingTransition[iCap];} +double lookTable_NOR2_X4_A2_ZN_fallingTransition(int iTr, int iCap) {return table_NOR2_X4_A2_ZN_fallingTransition[iCap][iTr];} + +double trAxis_OR2_X1_A1_ZN_risingDelay[8] = {7.5e-12, 1.5e-11, 3.0e-11, 6.0e-11, 1.2e-10, 2.4e-10, 4.8e-10, 9.6e-10}; +double capAxis_OR2_X1_A1_ZN_risingDelay[6] = {4.0e-16, 8.0e-16, 1.6e-15, 3.2e-15, 6.4e-15, 1.28e-14}; +double table_OR2_X1_A1_ZN_risingDelay[6][8] = {{3.5600000000000005e-11, 3.9e-11, 4.5e-11, 5.240000000000001e-11, 5.98e-11, 6.390000000000001e-11, 5.64e-11, 2.2700000000000003e-11}, {4.05e-11, 4.3900000000000005e-11, 4.9900000000000003e-11, 5.750000000000001e-11, 6.519999999999999e-11, 7.03e-11, 6.450000000000001e-11, 3.2500000000000004e-11}, {5.0200000000000005e-11, 5.360000000000001e-11, 5.940000000000001e-11, 6.71e-11, 7.51e-11, 8.13e-11, 7.83e-11, 4.9400000000000005e-11}, {6.92e-11, 7.25e-11, 7.820000000000001e-11, 8.620000000000001e-11, 9.41e-11, 1.0090000000000001e-10, 1.0040000000000001e-10, 7.770000000000001e-11}, {1.07e-10, 1.1010000000000001e-10, 1.1600000000000001e-10, 1.2360000000000002e-10, 1.3170000000000002e-10, 1.3860000000000002e-10, 1.3930000000000003e-10, 1.2190000000000001e-10}, {1.824e-10, 1.855e-10, 1.913e-10, 1.989e-10, 2.0680000000000003e-10, 2.1360000000000002e-10, 2.1490000000000003e-10, 1.999e-10}}; +double lookTrAxis_OR2_X1_A1_ZN_risingDelay(int iTr) {return trAxis_OR2_X1_A1_ZN_risingDelay[iTr];} +double lookCapAxis_OR2_X1_A1_ZN_risingDelay(int iCap) {return capAxis_OR2_X1_A1_ZN_risingDelay[iCap];} +double lookTable_OR2_X1_A1_ZN_risingDelay(int iTr, int iCap) {return table_OR2_X1_A1_ZN_risingDelay[iCap][iTr];} + +double trAxis_OR2_X1_A1_ZN_fallingDelay[8] = {7.5e-12, 1.5e-11, 3.0e-11, 6.0e-11, 1.2e-10, 2.4e-10, 4.8e-10, 9.6e-10}; +double capAxis_OR2_X1_A1_ZN_fallingDelay[6] = {4.0e-16, 8.0e-16, 1.6e-15, 3.2e-15, 6.4e-15, 1.28e-14}; +double table_OR2_X1_A1_ZN_fallingDelay[6][8] = {{4.9700000000000007e-11, 5.2900000000000006e-11, 6.01e-11, 7.44e-11, 9.54e-11, 1.2559999999999999e-10, 1.72e-10, 2.481e-10}, {5.4e-11, 5.7200000000000007e-11, 6.44e-11, 7.870000000000001e-11, 1.002e-10, 1.31e-10, 1.783e-10, 2.5580000000000004e-10}, {6.150000000000001e-11, 6.48e-11, 7.2e-11, 8.63e-11, 1.0820000000000001e-10, 1.401e-10, 1.894e-10, 2.688e-10}, {7.44e-11, 7.770000000000001e-11, 8.500000000000002e-11, 9.91e-11, 1.217e-10, 1.548e-10, 2.065e-10, 2.903e-10}, {9.660000000000001e-11, 9.980000000000001e-11, 1.0710000000000001e-10, 1.213e-10, 1.447e-10, 1.7890000000000002e-10, 2.335e-10, 3.2320000000000003e-10}, {1.362e-10, 1.395e-10, 1.4680000000000003e-10, 1.61e-10, 1.848e-10, 2.2000000000000002e-10, 2.7720000000000004e-10, 3.74e-10}}; +double lookTrAxis_OR2_X1_A1_ZN_fallingDelay(int iTr) {return trAxis_OR2_X1_A1_ZN_fallingDelay[iTr];} +double lookCapAxis_OR2_X1_A1_ZN_fallingDelay(int iCap) {return capAxis_OR2_X1_A1_ZN_fallingDelay[iCap];} +double lookTable_OR2_X1_A1_ZN_fallingDelay(int iTr, int iCap) {return table_OR2_X1_A1_ZN_fallingDelay[iCap][iTr];} + +double trAxis_OR2_X1_A1_ZN_risingTransition[8] = {7.5e-12, 1.5e-11, 3.0e-11, 6.0e-11, 1.2e-10, 2.4e-10, 4.8e-10, 9.6e-10}; +double capAxis_OR2_X1_A1_ZN_risingTransition[6] = {4.0e-16, 8.0e-16, 1.6e-15, 3.2e-15, 6.4e-15, 1.28e-14}; +double table_OR2_X1_A1_ZN_risingTransition[6][8] = {{1.2500000000000002e-11, 1.2500000000000002e-11, 1.2800000000000002e-11, 1.36e-11, 1.56e-11, 1.95e-11, 2.5600000000000004e-11, 3.500000000000001e-11}, {1.67e-11, 1.67e-11, 1.68e-11, 1.74e-11, 1.9000000000000002e-11, 2.2900000000000003e-11, 2.98e-11, 4.02e-11}, {2.5300000000000002e-11, 2.5300000000000002e-11, 2.5300000000000002e-11, 2.5700000000000002e-11, 2.66e-11, 2.9600000000000006e-11, 3.6800000000000005e-11, 4.92e-11}, {4.3100000000000005e-11, 4.3100000000000005e-11, 4.3100000000000005e-11, 4.33e-11, 4.3600000000000003e-11, 4.5100000000000005e-11, 5.0500000000000007e-11, 6.41e-11}, {7.900000000000001e-11, 7.900000000000001e-11, 7.900000000000001e-11, 7.900000000000001e-11, 7.900000000000001e-11, 7.97e-11, 8.240000000000001e-11, 9.19e-11}, {1.5060000000000003e-10, 1.5060000000000003e-10, 1.5060000000000003e-10, 1.5060000000000003e-10, 1.5060000000000003e-10, 1.508e-10, 1.5250000000000002e-10, 1.5800000000000002e-10}}; +double lookTrAxis_OR2_X1_A1_ZN_risingTransition(int iTr) {return trAxis_OR2_X1_A1_ZN_risingTransition[iTr];} +double lookCapAxis_OR2_X1_A1_ZN_risingTransition(int iCap) {return capAxis_OR2_X1_A1_ZN_risingTransition[iCap];} +double lookTable_OR2_X1_A1_ZN_risingTransition(int iTr, int iCap) {return table_OR2_X1_A1_ZN_risingTransition[iCap][iTr];} + +double trAxis_OR2_X1_A1_ZN_fallingTransition[8] = {7.5e-12, 1.5e-11, 3.0e-11, 6.0e-11, 1.2e-10, 2.4e-10, 4.8e-10, 9.6e-10}; +double capAxis_OR2_X1_A1_ZN_fallingTransition[6] = {4.0e-16, 8.0e-16, 1.6e-15, 3.2e-15, 6.4e-15, 1.28e-14}; +double table_OR2_X1_A1_ZN_fallingTransition[6][8] = {{1.18e-11, 1.18e-11, 1.17e-11, 1.2200000000000002e-11, 1.4300000000000002e-11, 1.77e-11, 2.32e-11, 3.2599999999999996e-11}, {1.4000000000000002e-11, 1.4000000000000002e-11, 1.4000000000000002e-11, 1.4300000000000002e-11, 1.6400000000000003e-11, 1.9800000000000002e-11, 2.5600000000000004e-11, 3.55e-11}, {1.8200000000000002e-11, 1.8200000000000002e-11, 1.8200000000000002e-11, 1.8400000000000002e-11, 2.03e-11, 2.37e-11, 2.98e-11, 4.05e-11}, {2.6100000000000002e-11, 2.6100000000000002e-11, 2.6100000000000002e-11, 2.6300000000000002e-11, 2.8000000000000003e-11, 3.0900000000000004e-11, 3.72e-11, 4.9000000000000005e-11}, {4.11e-11, 4.11e-11, 4.11e-11, 4.130000000000001e-11, 4.250000000000001e-11, 4.490000000000001e-11, 5.0600000000000005e-11, 6.34e-11}, {7.15e-11, 7.140000000000001e-11, 7.140000000000001e-11, 7.15e-11, 7.21e-11, 7.38e-11, 7.78e-11, 8.95e-11}}; +double lookTrAxis_OR2_X1_A1_ZN_fallingTransition(int iTr) {return trAxis_OR2_X1_A1_ZN_fallingTransition[iTr];} +double lookCapAxis_OR2_X1_A1_ZN_fallingTransition(int iCap) {return capAxis_OR2_X1_A1_ZN_fallingTransition[iCap];} +double lookTable_OR2_X1_A1_ZN_fallingTransition(int iTr, int iCap) {return table_OR2_X1_A1_ZN_fallingTransition[iCap][iTr];} + +double trAxis_OR2_X1_A2_ZN_risingDelay[8] = {7.5e-12, 1.5e-11, 3.0e-11, 6.0e-11, 1.2e-10, 2.4e-10, 4.8e-10, 9.6e-10}; +double capAxis_OR2_X1_A2_ZN_risingDelay[6] = {4.0e-16, 8.0e-16, 1.6e-15, 3.2e-15, 6.4e-15, 1.28e-14}; +double table_OR2_X1_A2_ZN_risingDelay[6][8] = {{4.2000000000000004e-11, 4.5400000000000006e-11, 5.23e-11, 6.270000000000001e-11, 7.420000000000001e-11, 8.41e-11, 8.66e-11, 7.01e-11}, {4.7100000000000004e-11, 5.0500000000000007e-11, 5.73e-11, 6.78e-11, 7.960000000000001e-11, 9.030000000000001e-11, 9.400000000000001e-11, 7.91e-11}, {5.7000000000000003e-11, 6.04e-11, 6.71e-11, 7.760000000000001e-11, 8.95e-11, 1.0100000000000001e-10, 1.0680000000000001e-10, 9.47e-11}, {7.64e-11, 7.98e-11, 8.61e-11, 9.68e-11, 1.0870000000000001e-10, 1.2030000000000001e-10, 1.277e-10, 1.1980000000000002e-10}, {1.1430000000000001e-10, 1.175e-10, 1.239e-10, 1.344e-10, 1.464e-10, 1.5800000000000002e-10, 1.656e-10, 1.608e-10}, {1.8990000000000004e-10, 1.931e-10, 1.994e-10, 2.0990000000000002e-10, 2.2170000000000002e-10, 2.331e-10, 2.407e-10, 2.3660000000000004e-10}}; +double lookTrAxis_OR2_X1_A2_ZN_risingDelay(int iTr) {return trAxis_OR2_X1_A2_ZN_risingDelay[iTr];} +double lookCapAxis_OR2_X1_A2_ZN_risingDelay(int iCap) {return capAxis_OR2_X1_A2_ZN_risingDelay[iCap];} +double lookTable_OR2_X1_A2_ZN_risingDelay(int iTr, int iCap) {return table_OR2_X1_A2_ZN_risingDelay[iCap][iTr];} + +double trAxis_OR2_X1_A2_ZN_fallingDelay[8] = {7.5e-12, 1.5e-11, 3.0e-11, 6.0e-11, 1.2e-10, 2.4e-10, 4.8e-10, 9.6e-10}; +double capAxis_OR2_X1_A2_ZN_fallingDelay[6] = {4.0e-16, 8.0e-16, 1.6e-15, 3.2e-15, 6.4e-15, 1.28e-14}; +double table_OR2_X1_A2_ZN_fallingDelay[6][8] = {{7.000000000000002e-11, 7.37e-11, 8.010000000000001e-11, 9.11e-11, 1.0730000000000001e-10, 1.3210000000000001e-10, 1.742e-10, 2.437e-10}, {7.44e-11, 7.8e-11, 8.440000000000001e-11, 9.54e-11, 1.1200000000000001e-10, 1.373e-10, 1.803e-10, 2.51e-10}, {8.190000000000001e-11, 8.550000000000001e-11, 9.19e-11, 1.03e-10, 1.201e-10, 1.4610000000000002e-10, 1.9070000000000002e-10, 2.635e-10}, {9.47e-11, 9.810000000000002e-11, 1.0470000000000001e-10, 1.1590000000000001e-10, 1.3370000000000001e-10, 1.611e-10, 2.0770000000000002e-10, 2.8360000000000003e-10}, {1.169e-10, 1.202e-10, 1.267e-10, 1.3800000000000001e-10, 1.565e-10, 1.855e-10, 2.35e-10, 3.161e-10}, {1.566e-10, 1.5989999999999999e-10, 1.6640000000000001e-10, 1.776e-10, 1.9650000000000002e-10, 2.2700000000000002e-10, 2.798e-10, 3.673e-10}}; +double lookTrAxis_OR2_X1_A2_ZN_fallingDelay(int iTr) {return trAxis_OR2_X1_A2_ZN_fallingDelay[iTr];} +double lookCapAxis_OR2_X1_A2_ZN_fallingDelay(int iCap) {return capAxis_OR2_X1_A2_ZN_fallingDelay[iCap];} +double lookTable_OR2_X1_A2_ZN_fallingDelay(int iTr, int iCap) {return table_OR2_X1_A2_ZN_fallingDelay[iCap][iTr];} + +double trAxis_OR2_X1_A2_ZN_risingTransition[8] = {7.5e-12, 1.5e-11, 3.0e-11, 6.0e-11, 1.2e-10, 2.4e-10, 4.8e-10, 9.6e-10}; +double capAxis_OR2_X1_A2_ZN_risingTransition[6] = {4.0e-16, 8.0e-16, 1.6e-15, 3.2e-15, 6.4e-15, 1.28e-14}; +double table_OR2_X1_A2_ZN_risingTransition[6][8] = {{1.33e-11, 1.33e-11, 1.33e-11, 1.39e-11, 1.55e-11, 1.86e-11, 2.36e-11, 3.11e-11}, {1.74e-11, 1.74e-11, 1.73e-11, 1.77e-11, 1.9000000000000002e-11, 2.19e-11, 2.7400000000000004e-11, 3.5700000000000003e-11}, {2.5900000000000002e-11, 2.5900000000000002e-11, 2.5900000000000002e-11, 2.6100000000000002e-11, 2.6700000000000002e-11, 2.88e-11, 3.41e-11, 4.38e-11}, {4.35e-11, 4.3600000000000003e-11, 4.35e-11, 4.3600000000000003e-11, 4.3900000000000005e-11, 4.490000000000001e-11, 4.81e-11, 5.73e-11}, {7.93e-11, 7.93e-11, 7.93e-11, 7.93e-11, 7.94e-11, 7.97e-11, 8.110000000000001e-11, 8.620000000000001e-11}, {1.508e-10, 1.508e-10, 1.508e-10, 1.508e-10, 1.5090000000000002e-10, 1.51e-10, 1.517e-10, 1.545e-10}}; +double lookTrAxis_OR2_X1_A2_ZN_risingTransition(int iTr) {return trAxis_OR2_X1_A2_ZN_risingTransition[iTr];} +double lookCapAxis_OR2_X1_A2_ZN_risingTransition(int iCap) {return capAxis_OR2_X1_A2_ZN_risingTransition[iCap];} +double lookTable_OR2_X1_A2_ZN_risingTransition(int iTr, int iCap) {return table_OR2_X1_A2_ZN_risingTransition[iCap][iTr];} + +double trAxis_OR2_X1_A2_ZN_fallingTransition[8] = {7.5e-12, 1.5e-11, 3.0e-11, 6.0e-11, 1.2e-10, 2.4e-10, 4.8e-10, 9.6e-10}; +double capAxis_OR2_X1_A2_ZN_fallingTransition[6] = {4.0e-16, 8.0e-16, 1.6e-15, 3.2e-15, 6.4e-15, 1.28e-14}; +double table_OR2_X1_A2_ZN_fallingTransition[6][8] = {{1.18e-11, 1.18e-11, 1.18e-11, 1.2e-11, 1.36e-11, 1.6299999999999998e-11, 2.0600000000000002e-11, 2.7900000000000002e-11}, {1.4000000000000002e-11, 1.4000000000000002e-11, 1.4000000000000002e-11, 1.4200000000000002e-11, 1.5800000000000003e-11, 1.86e-11, 2.32e-11, 3.0800000000000006e-11}, {1.8200000000000002e-11, 1.8200000000000002e-11, 1.8200000000000002e-11, 1.83e-11, 2.0000000000000002e-11, 2.2900000000000003e-11, 2.7900000000000002e-11, 3.6100000000000003e-11}, {2.6200000000000004e-11, 2.6200000000000004e-11, 2.6200000000000004e-11, 2.6300000000000002e-11, 2.78e-11, 3.0800000000000006e-11, 3.6100000000000003e-11, 4.5400000000000006e-11}, {4.11e-11, 4.11e-11, 4.11e-11, 4.11e-11, 4.23e-11, 4.53e-11, 5.0900000000000006e-11, 6.13e-11}, {7.15e-11, 7.140000000000001e-11, 7.140000000000001e-11, 7.15e-11, 7.2e-11, 7.410000000000001e-11, 7.890000000000001e-11, 9.01e-11}}; +double lookTrAxis_OR2_X1_A2_ZN_fallingTransition(int iTr) {return trAxis_OR2_X1_A2_ZN_fallingTransition[iTr];} +double lookCapAxis_OR2_X1_A2_ZN_fallingTransition(int iCap) {return capAxis_OR2_X1_A2_ZN_fallingTransition[iCap];} +double lookTable_OR2_X1_A2_ZN_fallingTransition(int iTr, int iCap) {return table_OR2_X1_A2_ZN_fallingTransition[iCap][iTr];} + +double trAxis_OR2_X2_A1_ZN_risingDelay[8] = {7.5e-12, 1.5e-11, 3.0e-11, 6.0e-11, 1.2e-10, 2.4e-10, 4.8e-10, 9.6e-10}; +double capAxis_OR2_X2_A1_ZN_risingDelay[6] = {4.0e-16, 1.6e-15, 3.2e-15, 6.4e-15, 1.28e-14, 2.56e-14}; +double table_OR2_X2_A1_ZN_risingDelay[6][8] = {{3.2800000000000006e-11, 3.620000000000001e-11, 4.26e-11, 5.0700000000000003e-11, 5.87e-11, 6.33e-11, 5.7200000000000007e-11, 2.5700000000000002e-11}, {4.05e-11, 4.3900000000000005e-11, 5.0300000000000003e-11, 5.88e-11, 6.78e-11, 7.410000000000001e-11, 7.02e-11, 4.11e-11}, {5.000000000000001e-11, 5.3400000000000004e-11, 5.970000000000001e-11, 6.84e-11, 7.770000000000001e-11, 8.560000000000001e-11, 8.440000000000001e-11, 5.8100000000000005e-11}, {6.83e-11, 7.170000000000001e-11, 7.78e-11, 8.670000000000001e-11, 9.63e-11, 1.0480000000000002e-10, 1.0680000000000001e-10, 8.65e-11}, {1.0480000000000002e-10, 1.08e-10, 1.142e-10, 1.228e-10, 1.3220000000000002e-10, 1.411e-10, 1.445e-10, 1.3050000000000001e-10}, {1.776e-10, 1.808e-10, 1.8690000000000002e-10, 1.9550000000000002e-10, 2.0480000000000003e-10, 2.133e-10, 2.172e-10, 2.055e-10}}; +double lookTrAxis_OR2_X2_A1_ZN_risingDelay(int iTr) {return trAxis_OR2_X2_A1_ZN_risingDelay[iTr];} +double lookCapAxis_OR2_X2_A1_ZN_risingDelay(int iCap) {return capAxis_OR2_X2_A1_ZN_risingDelay[iCap];} +double lookTable_OR2_X2_A1_ZN_risingDelay(int iTr, int iCap) {return table_OR2_X2_A1_ZN_risingDelay[iCap][iTr];} + +double trAxis_OR2_X2_A1_ZN_fallingDelay[8] = {7.5e-12, 1.5e-11, 3.0e-11, 6.0e-11, 1.2e-10, 2.4e-10, 4.8e-10, 9.6e-10}; +double capAxis_OR2_X2_A1_ZN_fallingDelay[6] = {4.0e-16, 1.6e-15, 3.2e-15, 6.4e-15, 1.28e-14, 2.56e-14}; +double table_OR2_X2_A1_ZN_fallingDelay[6][8] = {{5.0500000000000007e-11, 5.37e-11, 6.07e-11, 7.56e-11, 9.79e-11, 1.293e-10, 1.774e-10, 2.557e-10}, {5.79e-11, 6.11e-11, 6.81e-11, 8.29e-11, 1.059e-10, 1.384e-10, 1.8790000000000002e-10, 2.684e-10}, {6.58e-11, 6.900000000000001e-11, 7.61e-11, 9.070000000000001e-11, 1.1430000000000001e-10, 1.48e-10, 1.9930000000000003e-10, 2.8160000000000004e-10}, {7.91e-11, 8.23e-11, 8.95e-11, 1.04e-10, 1.281e-10, 1.631e-10, 2.1680000000000002e-10, 3.0320000000000005e-10}, {1.013e-10, 1.045e-10, 1.117e-10, 1.2620000000000001e-10, 1.51e-10, 1.8740000000000002e-10, 2.44e-10, 3.3600000000000003e-10}, {1.404e-10, 1.4360000000000003e-10, 1.5090000000000002e-10, 1.6520000000000003e-10, 1.9040000000000004e-10, 2.278e-10, 2.871e-10, 3.862e-10}}; +double lookTrAxis_OR2_X2_A1_ZN_fallingDelay(int iTr) {return trAxis_OR2_X2_A1_ZN_fallingDelay[iTr];} +double lookCapAxis_OR2_X2_A1_ZN_fallingDelay(int iCap) {return capAxis_OR2_X2_A1_ZN_fallingDelay[iCap];} +double lookTable_OR2_X2_A1_ZN_fallingDelay(int iTr, int iCap) {return table_OR2_X2_A1_ZN_fallingDelay[iCap][iTr];} + +double trAxis_OR2_X2_A1_ZN_risingTransition[8] = {7.5e-12, 1.5e-11, 3.0e-11, 6.0e-11, 1.2e-10, 2.4e-10, 4.8e-10, 9.6e-10}; +double capAxis_OR2_X2_A1_ZN_risingTransition[6] = {4.0e-16, 1.6e-15, 3.2e-15, 6.4e-15, 1.28e-14, 2.56e-14}; +double table_OR2_X2_A1_ZN_risingTransition[6][8] = {{9.100000000000001e-12, 9.100000000000001e-12, 9.3e-12, 1.0600000000000001e-11, 1.2800000000000002e-11, 1.6299999999999998e-11, 2.2100000000000003e-11, 3.18e-11}, {1.47e-11, 1.47e-11, 1.49e-11, 1.5699999999999998e-11, 1.77e-11, 2.19e-11, 2.8700000000000002e-11, 3.93e-11}, {2.28e-11, 2.28e-11, 2.2900000000000003e-11, 2.34e-11, 2.4700000000000003e-11, 2.8300000000000002e-11, 3.6e-11, 4.8300000000000004e-11}, {3.980000000000001e-11, 3.99e-11, 3.980000000000001e-11, 4.0000000000000004e-11, 4.06e-11, 4.26e-11, 4.89e-11, 6.310000000000001e-11}, {7.44e-11, 7.43e-11, 7.44e-11, 7.43e-11, 7.45e-11, 7.51e-11, 7.840000000000001e-11, 8.910000000000001e-11}, {1.435e-10, 1.435e-10, 1.435e-10, 1.435e-10, 1.435e-10, 1.438e-10, 1.454e-10, 1.51e-10}}; +double lookTrAxis_OR2_X2_A1_ZN_risingTransition(int iTr) {return trAxis_OR2_X2_A1_ZN_risingTransition[iTr];} +double lookCapAxis_OR2_X2_A1_ZN_risingTransition(int iCap) {return capAxis_OR2_X2_A1_ZN_risingTransition[iCap];} +double lookTable_OR2_X2_A1_ZN_risingTransition(int iTr, int iCap) {return table_OR2_X2_A1_ZN_risingTransition[iCap][iTr];} + +double trAxis_OR2_X2_A1_ZN_fallingTransition[8] = {7.5e-12, 1.5e-11, 3.0e-11, 6.0e-11, 1.2e-10, 2.4e-10, 4.8e-10, 9.6e-10}; +double capAxis_OR2_X2_A1_ZN_fallingTransition[6] = {4.0e-16, 1.6e-15, 3.2e-15, 6.4e-15, 1.28e-14, 2.56e-14}; +double table_OR2_X2_A1_ZN_fallingTransition[6][8] = {{1.0600000000000001e-11, 1.0600000000000001e-11, 1.0600000000000001e-11, 1.1e-11, 1.35e-11, 1.7200000000000003e-11, 2.3e-11, 3.3e-11}, {1.41e-11, 1.41e-11, 1.41e-11, 1.4300000000000002e-11, 1.6600000000000003e-11, 2.0500000000000004e-11, 2.6700000000000002e-11, 3.72e-11}, {1.83e-11, 1.83e-11, 1.83e-11, 1.8400000000000002e-11, 2.0500000000000004e-11, 2.4400000000000004e-11, 3.0800000000000006e-11, 4.21e-11}, {2.6e-11, 2.6e-11, 2.5900000000000002e-11, 2.6100000000000002e-11, 2.7900000000000002e-11, 3.1399999999999996e-11, 3.81e-11, 5.0200000000000005e-11}, {4.0300000000000006e-11, 4.0300000000000006e-11, 4.0300000000000006e-11, 4.0400000000000004e-11, 4.1600000000000004e-11, 4.4600000000000006e-11, 5.08e-11, 6.400000000000001e-11}, {6.930000000000001e-11, 6.930000000000001e-11, 6.930000000000001e-11, 6.930000000000001e-11, 7.000000000000002e-11, 7.19e-11, 7.64e-11, 8.860000000000001e-11}}; +double lookTrAxis_OR2_X2_A1_ZN_fallingTransition(int iTr) {return trAxis_OR2_X2_A1_ZN_fallingTransition[iTr];} +double lookCapAxis_OR2_X2_A1_ZN_fallingTransition(int iCap) {return capAxis_OR2_X2_A1_ZN_fallingTransition[iCap];} +double lookTable_OR2_X2_A1_ZN_fallingTransition(int iTr, int iCap) {return table_OR2_X2_A1_ZN_fallingTransition[iCap][iTr];} + +double trAxis_OR2_X2_A2_ZN_risingDelay[8] = {7.5e-12, 1.5e-11, 3.0e-11, 6.0e-11, 1.2e-10, 2.4e-10, 4.8e-10, 9.6e-10}; +double capAxis_OR2_X2_A2_ZN_risingDelay[6] = {4.0e-16, 1.6e-15, 3.2e-15, 6.4e-15, 1.28e-14, 2.56e-14}; +double table_OR2_X2_A2_ZN_risingDelay[6][8] = {{3.9100000000000006e-11, 4.250000000000001e-11, 4.9400000000000005e-11, 6.05e-11, 7.25e-11, 8.300000000000001e-11, 8.640000000000001e-11, 7.170000000000001e-11}, {4.72e-11, 5.0500000000000007e-11, 5.7400000000000003e-11, 6.87e-11, 8.15e-11, 9.35e-11, 9.87e-11, 8.61e-11}, {5.6900000000000005e-11, 6.03e-11, 6.71e-11, 7.840000000000001e-11, 9.150000000000001e-11, 1.045e-10, 1.121e-10, 1.019e-10}, {7.56e-11, 7.890000000000001e-11, 8.550000000000001e-11, 9.690000000000001e-11, 1.1020000000000002e-10, 1.2360000000000002e-10, 1.331e-10, 1.2780000000000001e-10}, {1.122e-10, 1.1540000000000001e-10, 1.22e-10, 1.3330000000000002e-10, 1.4630000000000003e-10, 1.598e-10, 1.699e-10, 1.683e-10}, {1.8509999999999999e-10, 1.8840000000000002e-10, 1.9500000000000002e-10, 2.0610000000000002e-10, 2.1920000000000003e-10, 2.322e-10, 2.421e-10, 2.411e-10}}; +double lookTrAxis_OR2_X2_A2_ZN_risingDelay(int iTr) {return trAxis_OR2_X2_A2_ZN_risingDelay[iTr];} +double lookCapAxis_OR2_X2_A2_ZN_risingDelay(int iCap) {return capAxis_OR2_X2_A2_ZN_risingDelay[iCap];} +double lookTable_OR2_X2_A2_ZN_risingDelay(int iTr, int iCap) {return table_OR2_X2_A2_ZN_risingDelay[iCap][iTr];} + +double trAxis_OR2_X2_A2_ZN_fallingDelay[8] = {7.5e-12, 1.5e-11, 3.0e-11, 6.0e-11, 1.2e-10, 2.4e-10, 4.8e-10, 9.6e-10}; +double capAxis_OR2_X2_A2_ZN_fallingDelay[6] = {4.0e-16, 1.6e-15, 3.2e-15, 6.4e-15, 1.28e-14, 2.56e-14}; +double table_OR2_X2_A2_ZN_fallingDelay[6][8] = {{7.08e-11, 7.45e-11, 8.09e-11, 9.210000000000001e-11, 1.093e-10, 1.351e-10, 1.786e-10, 2.5080000000000005e-10}, {7.820000000000001e-11, 8.190000000000001e-11, 8.830000000000001e-11, 9.95e-11, 1.172e-10, 1.438e-10, 1.886e-10, 2.6240000000000005e-10}, {8.620000000000001e-11, 8.980000000000002e-11, 9.63e-11, 1.075e-10, 1.2559999999999999e-10, 1.5310000000000002e-10, 1.9960000000000001e-10, 2.747e-10}, {9.940000000000001e-11, 1.0290000000000001e-10, 1.0950000000000001e-10, 1.208e-10, 1.395e-10, 1.682e-10, 2.165e-10, 2.953e-10}, {1.216e-10, 1.25e-10, 1.315e-10, 1.43e-10, 1.6220000000000002e-10, 1.9270000000000002e-10, 2.4380000000000003e-10, 3.2710000000000004e-10}, {1.608e-10, 1.641e-10, 1.706e-10, 1.8210000000000002e-10, 2.016e-10, 2.336e-10, 2.8780000000000003e-10, 3.7740000000000006e-10}}; +double lookTrAxis_OR2_X2_A2_ZN_fallingDelay(int iTr) {return trAxis_OR2_X2_A2_ZN_fallingDelay[iTr];} +double lookCapAxis_OR2_X2_A2_ZN_fallingDelay(int iCap) {return capAxis_OR2_X2_A2_ZN_fallingDelay[iCap];} +double lookTable_OR2_X2_A2_ZN_fallingDelay(int iTr, int iCap) {return table_OR2_X2_A2_ZN_fallingDelay[iCap][iTr];} + +double trAxis_OR2_X2_A2_ZN_risingTransition[8] = {7.5e-12, 1.5e-11, 3.0e-11, 6.0e-11, 1.2e-10, 2.4e-10, 4.8e-10, 9.6e-10}; +double capAxis_OR2_X2_A2_ZN_risingTransition[6] = {4.0e-16, 1.6e-15, 3.2e-15, 6.4e-15, 1.28e-14, 2.56e-14}; +double table_OR2_X2_A2_ZN_risingTransition[6][8] = {{9.800000000000001e-12, 9.800000000000001e-12, 9.800000000000001e-12, 1.0700000000000001e-11, 1.27e-11, 1.5699999999999998e-11, 2.0400000000000002e-11, 2.8000000000000003e-11}, {1.55e-11, 1.55e-11, 1.5400000000000003e-11, 1.6000000000000003e-11, 1.7600000000000003e-11, 2.1000000000000002e-11, 2.66e-11, 3.51e-11}, {2.3500000000000003e-11, 2.3500000000000003e-11, 2.3500000000000003e-11, 2.37e-11, 2.48e-11, 2.7500000000000002e-11, 3.34e-11, 4.3400000000000007e-11}, {4.0300000000000006e-11, 4.0300000000000006e-11, 4.0300000000000006e-11, 4.0400000000000004e-11, 4.0800000000000004e-11, 4.21e-11, 4.64e-11, 5.680000000000001e-11}, {7.480000000000002e-11, 7.470000000000001e-11, 7.470000000000001e-11, 7.480000000000002e-11, 7.480000000000002e-11, 7.520000000000001e-11, 7.69e-11, 8.34e-11}, {1.438e-10, 1.438e-10, 1.437e-10, 1.438e-10, 1.438e-10, 1.44e-10, 1.447e-10, 1.476e-10}}; +double lookTrAxis_OR2_X2_A2_ZN_risingTransition(int iTr) {return trAxis_OR2_X2_A2_ZN_risingTransition[iTr];} +double lookCapAxis_OR2_X2_A2_ZN_risingTransition(int iCap) {return capAxis_OR2_X2_A2_ZN_risingTransition[iCap];} +double lookTable_OR2_X2_A2_ZN_risingTransition(int iTr, int iCap) {return table_OR2_X2_A2_ZN_risingTransition[iCap][iTr];} + +double trAxis_OR2_X2_A2_ZN_fallingTransition[8] = {7.5e-12, 1.5e-11, 3.0e-11, 6.0e-11, 1.2e-10, 2.4e-10, 4.8e-10, 9.6e-10}; +double capAxis_OR2_X2_A2_ZN_fallingTransition[6] = {4.0e-16, 1.6e-15, 3.2e-15, 6.4e-15, 1.28e-14, 2.56e-14}; +double table_OR2_X2_A2_ZN_fallingTransition[6][8] = {{1.0600000000000001e-11, 1.0600000000000001e-11, 1.0600000000000001e-11, 1.0800000000000001e-11, 1.24e-11, 1.52e-11, 1.9800000000000002e-11, 2.7400000000000004e-11}, {1.41e-11, 1.41e-11, 1.41e-11, 1.4200000000000002e-11, 1.5800000000000003e-11, 1.8800000000000002e-11, 2.37e-11, 3.17e-11}, {1.83e-11, 1.83e-11, 1.83e-11, 1.8400000000000002e-11, 1.9900000000000004e-11, 2.3e-11, 2.8100000000000002e-11, 3.6700000000000006e-11}, {2.6e-11, 2.6e-11, 2.6e-11, 2.6100000000000002e-11, 2.7400000000000004e-11, 3.06e-11, 3.6100000000000003e-11, 4.56e-11}, {4.0300000000000006e-11, 4.0400000000000004e-11, 4.0300000000000006e-11, 4.0400000000000004e-11, 4.14e-11, 4.47e-11, 5.0300000000000003e-11, 6.08e-11}, {6.930000000000001e-11, 6.930000000000001e-11, 6.930000000000001e-11, 6.930000000000001e-11, 6.980000000000001e-11, 7.220000000000001e-11, 7.710000000000001e-11, 8.82e-11}}; +double lookTrAxis_OR2_X2_A2_ZN_fallingTransition(int iTr) {return trAxis_OR2_X2_A2_ZN_fallingTransition[iTr];} +double lookCapAxis_OR2_X2_A2_ZN_fallingTransition(int iCap) {return capAxis_OR2_X2_A2_ZN_fallingTransition[iCap];} +double lookTable_OR2_X2_A2_ZN_fallingTransition(int iTr, int iCap) {return table_OR2_X2_A2_ZN_fallingTransition[iCap][iTr];} + +double trAxis_OR2_X4_A1_ZN_risingDelay[8] = {7.5e-12, 1.5e-11, 3.0e-11, 6.0e-11, 1.2e-10, 2.4e-10, 4.8e-10, 9.6e-10}; +double capAxis_OR2_X4_A1_ZN_risingDelay[6] = {4.0e-16, 3.2e-15, 6.4e-15, 1.28e-14, 2.56e-14, 5.12e-14}; +double table_OR2_X4_A1_ZN_risingDelay[6][8] = {{3.42e-11, 3.7600000000000005e-11, 4.4300000000000005e-11, 5.3800000000000004e-11, 6.34e-11, 7.05e-11, 6.87e-11, 4.33e-11}, {4.3900000000000005e-11, 4.730000000000001e-11, 5.4e-11, 6.400000000000001e-11, 7.5e-11, 8.39e-11, 8.41e-11, 6.08e-11}, {5.35e-11, 5.6900000000000005e-11, 6.35e-11, 7.37e-11, 8.52e-11, 9.59e-11, 9.83e-11, 7.760000000000001e-11}, {7.170000000000001e-11, 7.5e-11, 8.15e-11, 9.180000000000001e-11, 1.035e-10, 1.152e-10, 1.212e-10, 1.0580000000000001e-10}, {1.075e-10, 1.1080000000000001e-10, 1.172e-10, 1.2730000000000002e-10, 1.3880000000000003e-10, 1.505e-10, 1.583e-10, 1.4990000000000002e-10}, {1.7910000000000003e-10, 1.823e-10, 1.8870000000000003e-10, 1.987e-10, 2.1e-10, 2.213e-10, 2.292e-10, 2.231e-10}}; +double lookTrAxis_OR2_X4_A1_ZN_risingDelay(int iTr) {return trAxis_OR2_X4_A1_ZN_risingDelay[iTr];} +double lookCapAxis_OR2_X4_A1_ZN_risingDelay(int iCap) {return capAxis_OR2_X4_A1_ZN_risingDelay[iCap];} +double lookTable_OR2_X4_A1_ZN_risingDelay(int iTr, int iCap) {return table_OR2_X4_A1_ZN_risingDelay[iCap][iTr];} + +double trAxis_OR2_X4_A1_ZN_fallingDelay[8] = {7.5e-12, 1.5e-11, 3.0e-11, 6.0e-11, 1.2e-10, 2.4e-10, 4.8e-10, 9.6e-10}; +double capAxis_OR2_X4_A1_ZN_fallingDelay[6] = {4.0e-16, 3.2e-15, 6.4e-15, 1.28e-14, 2.56e-14, 5.12e-14}; +double table_OR2_X4_A1_ZN_fallingDelay[6][8] = {{5.79e-11, 6.1e-11, 6.800000000000001e-11, 8.29e-11, 1.08e-10, 1.427e-10, 1.9520000000000003e-10, 2.794e-10}, {6.740000000000001e-11, 7.060000000000001e-11, 7.75e-11, 9.24e-11, 1.181e-10, 1.54e-10, 2.0790000000000003e-10, 2.94e-10}, {7.59e-11, 7.91e-11, 8.6e-11, 1.008e-10, 1.2690000000000002e-10, 1.6400000000000003e-10, 2.1920000000000003e-10, 3.071e-10}, {8.99e-11, 9.310000000000001e-11, 1.0000000000000002e-10, 1.147e-10, 1.4120000000000001e-10, 1.7960000000000003e-10, 2.3730000000000005e-10, 3.287e-10}, {1.129e-10, 1.1600000000000001e-10, 1.2310000000000002e-10, 1.377e-10, 1.6450000000000003e-10, 2.044e-10, 2.6490000000000004e-10, 3.6170000000000005e-10}, {1.524e-10, 1.556e-10, 1.6270000000000002e-10, 1.7720000000000002e-10, 2.0410000000000002e-10, 2.451e-10, 3.0840000000000004e-10, 4.119e-10}}; +double lookTrAxis_OR2_X4_A1_ZN_fallingDelay(int iTr) {return trAxis_OR2_X4_A1_ZN_fallingDelay[iTr];} +double lookCapAxis_OR2_X4_A1_ZN_fallingDelay(int iCap) {return capAxis_OR2_X4_A1_ZN_fallingDelay[iCap];} +double lookTable_OR2_X4_A1_ZN_fallingDelay(int iTr, int iCap) {return table_OR2_X4_A1_ZN_fallingDelay[iCap][iTr];} + +double trAxis_OR2_X4_A1_ZN_risingTransition[8] = {7.5e-12, 1.5e-11, 3.0e-11, 6.0e-11, 1.2e-10, 2.4e-10, 4.8e-10, 9.6e-10}; +double capAxis_OR2_X4_A1_ZN_risingTransition[6] = {4.0e-16, 3.2e-15, 6.4e-15, 1.28e-14, 2.56e-14, 5.12e-14}; +double table_OR2_X4_A1_ZN_risingTransition[6][8] = {{8.200000000000001e-12, 8.200000000000001e-12, 8.4e-12, 9.800000000000001e-12, 1.2200000000000002e-11, 1.6000000000000003e-11, 2.2700000000000003e-11, 3.46e-11}, {1.47e-11, 1.47e-11, 1.4800000000000003e-11, 1.5800000000000003e-11, 1.8200000000000002e-11, 2.2700000000000003e-11, 3.0e-11, 4.18e-11}, {2.25e-11, 2.25e-11, 2.25e-11, 2.31e-11, 2.48e-11, 2.9000000000000003e-11, 3.73e-11, 5.0300000000000003e-11}, {3.89e-11, 3.89e-11, 3.89e-11, 3.9100000000000006e-11, 3.980000000000001e-11, 4.2400000000000004e-11, 4.98e-11, 6.500000000000001e-11}, {7.27e-11, 7.27e-11, 7.26e-11, 7.280000000000001e-11, 7.290000000000001e-11, 7.360000000000001e-11, 7.74e-11, 8.980000000000002e-11}, {1.406e-10, 1.406e-10, 1.406e-10, 1.406e-10, 1.407e-10, 1.409e-10, 1.425e-10, 1.485e-10}}; +double lookTrAxis_OR2_X4_A1_ZN_risingTransition(int iTr) {return trAxis_OR2_X4_A1_ZN_risingTransition[iTr];} +double lookCapAxis_OR2_X4_A1_ZN_risingTransition(int iCap) {return capAxis_OR2_X4_A1_ZN_risingTransition[iCap];} +double lookTable_OR2_X4_A1_ZN_risingTransition(int iTr, int iCap) {return table_OR2_X4_A1_ZN_risingTransition[iCap][iTr];} + +double trAxis_OR2_X4_A1_ZN_fallingTransition[8] = {7.5e-12, 1.5e-11, 3.0e-11, 6.0e-11, 1.2e-10, 2.4e-10, 4.8e-10, 9.6e-10}; +double capAxis_OR2_X4_A1_ZN_fallingTransition[6] = {4.0e-16, 3.2e-15, 6.4e-15, 1.28e-14, 2.56e-14, 5.12e-14}; +double table_OR2_X4_A1_ZN_fallingTransition[6][8] = {{1.21e-11, 1.21e-11, 1.21e-11, 1.21e-11, 1.51e-11, 1.9900000000000004e-11, 2.6800000000000004e-11, 3.860000000000001e-11}, {1.62e-11, 1.62e-11, 1.62e-11, 1.62e-11, 1.8700000000000004e-11, 2.3500000000000003e-11, 3.07e-11, 4.2700000000000005e-11}, {2.03e-11, 2.03e-11, 2.03e-11, 2.0400000000000002e-11, 2.24e-11, 2.72e-11, 3.46e-11, 4.7100000000000004e-11}, {2.8000000000000003e-11, 2.8000000000000003e-11, 2.8000000000000003e-11, 2.8000000000000003e-11, 2.9600000000000006e-11, 3.39e-11, 4.1500000000000005e-11, 5.47e-11}, {4.21e-11, 4.21e-11, 4.21e-11, 4.220000000000001e-11, 4.3200000000000003e-11, 4.69e-11, 5.37e-11, 6.77e-11}, {7.02e-11, 7.02e-11, 7.02e-11, 7.03e-11, 7.090000000000001e-11, 7.32e-11, 7.83e-11, 9.11e-11}}; +double lookTrAxis_OR2_X4_A1_ZN_fallingTransition(int iTr) {return trAxis_OR2_X4_A1_ZN_fallingTransition[iTr];} +double lookCapAxis_OR2_X4_A1_ZN_fallingTransition(int iCap) {return capAxis_OR2_X4_A1_ZN_fallingTransition[iCap];} +double lookTable_OR2_X4_A1_ZN_fallingTransition(int iTr, int iCap) {return table_OR2_X4_A1_ZN_fallingTransition[iCap][iTr];} + +double trAxis_OR2_X4_A2_ZN_risingDelay[8] = {7.5e-12, 1.5e-11, 3.0e-11, 6.0e-11, 1.2e-10, 2.4e-10, 4.8e-10, 9.6e-10}; +double capAxis_OR2_X4_A2_ZN_risingDelay[6] = {4.0e-16, 3.2e-15, 6.4e-15, 1.28e-14, 2.56e-14, 5.12e-14}; +double table_OR2_X4_A2_ZN_risingDelay[6][8] = {{4.06e-11, 4.3900000000000005e-11, 5.0900000000000006e-11, 6.29e-11, 7.650000000000001e-11, 8.910000000000001e-11, 9.580000000000001e-11, 8.63e-11}, {5.0700000000000003e-11, 5.4100000000000006e-11, 6.1e-11, 7.32e-11, 8.790000000000001e-11, 1.022e-10, 1.1070000000000002e-10, 1.031e-10}, {6.06e-11, 6.390000000000001e-11, 7.08e-11, 8.300000000000001e-11, 9.820000000000001e-11, 1.137e-10, 1.244e-10, 1.1890000000000002e-10}, {7.900000000000001e-11, 8.23e-11, 8.910000000000001e-11, 1.013e-10, 1.166e-10, 1.3280000000000002e-10, 1.459e-10, 1.452e-10}, {1.151e-10, 1.1830000000000002e-10, 1.25e-10, 1.371e-10, 1.522e-10, 1.683e-10, 1.823e-10, 1.858e-10}, {1.8680000000000002e-10, 1.9000000000000002e-10, 1.9670000000000003e-10, 2.0870000000000001e-10, 2.2350000000000003e-10, 2.392e-10, 2.527e-10, 2.569e-10}}; +double lookTrAxis_OR2_X4_A2_ZN_risingDelay(int iTr) {return trAxis_OR2_X4_A2_ZN_risingDelay[iTr];} +double lookCapAxis_OR2_X4_A2_ZN_risingDelay(int iCap) {return capAxis_OR2_X4_A2_ZN_risingDelay[iCap];} +double lookTable_OR2_X4_A2_ZN_risingDelay(int iTr, int iCap) {return table_OR2_X4_A2_ZN_risingDelay[iCap][iTr];} + +double trAxis_OR2_X4_A2_ZN_fallingDelay[8] = {7.5e-12, 1.5e-11, 3.0e-11, 6.0e-11, 1.2e-10, 2.4e-10, 4.8e-10, 9.6e-10}; +double capAxis_OR2_X4_A2_ZN_fallingDelay[6] = {4.0e-16, 3.2e-15, 6.4e-15, 1.28e-14, 2.56e-14, 5.12e-14}; +double table_OR2_X4_A2_ZN_fallingDelay[6][8] = {{7.83e-11, 8.190000000000001e-11, 8.840000000000001e-11, 9.980000000000001e-11, 1.1880000000000002e-10, 1.4710000000000001e-10, 1.944e-10, 2.722e-10}, {8.780000000000001e-11, 9.150000000000001e-11, 9.79e-11, 1.093e-10, 1.287e-10, 1.5790000000000002e-10, 2.065e-10, 2.859e-10}, {9.63e-11, 1.0000000000000002e-10, 1.064e-10, 1.178e-10, 1.3760000000000002e-10, 1.6760000000000002e-10, 2.1730000000000001e-10, 2.98e-10}, {1.1020000000000002e-10, 1.1380000000000001e-10, 1.204e-10, 1.318e-10, 1.5190000000000001e-10, 1.8310000000000002e-10, 2.3470000000000003e-10, 3.186e-10}, {1.3330000000000002e-10, 1.367e-10, 1.432e-10, 1.548e-10, 1.7510000000000002e-10, 2.08e-10, 2.62e-10, 3.5010000000000006e-10}, {1.7280000000000001e-10, 1.762e-10, 1.827e-10, 1.944e-10, 2.148e-10, 2.4920000000000003e-10, 3.061e-10, 3.999e-10}}; +double lookTrAxis_OR2_X4_A2_ZN_fallingDelay(int iTr) {return trAxis_OR2_X4_A2_ZN_fallingDelay[iTr];} +double lookCapAxis_OR2_X4_A2_ZN_fallingDelay(int iCap) {return capAxis_OR2_X4_A2_ZN_fallingDelay[iCap];} +double lookTable_OR2_X4_A2_ZN_fallingDelay(int iTr, int iCap) {return table_OR2_X4_A2_ZN_fallingDelay[iCap][iTr];} + +double trAxis_OR2_X4_A2_ZN_risingTransition[8] = {7.5e-12, 1.5e-11, 3.0e-11, 6.0e-11, 1.2e-10, 2.4e-10, 4.8e-10, 9.6e-10}; +double capAxis_OR2_X4_A2_ZN_risingTransition[6] = {4.0e-16, 3.2e-15, 6.4e-15, 1.28e-14, 2.56e-14, 5.12e-14}; +double table_OR2_X4_A2_ZN_risingTransition[6][8] = {{9.0e-12, 9.0e-12, 8.900000000000001e-12, 9.900000000000001e-12, 1.2e-11, 1.53e-11, 2.09e-11, 3.04e-11}, {1.55e-11, 1.55e-11, 1.5400000000000003e-11, 1.6000000000000003e-11, 1.8e-11, 2.19e-11, 2.8000000000000003e-11, 3.75e-11}, {2.31e-11, 2.31e-11, 2.31e-11, 2.34e-11, 2.49e-11, 2.82e-11, 3.4900000000000004e-11, 4.56e-11}, {3.94e-11, 3.93e-11, 3.94e-11, 3.9500000000000006e-11, 4.01e-11, 4.2000000000000004e-11, 4.730000000000001e-11, 5.910000000000001e-11}, {7.31e-11, 7.3e-11, 7.3e-11, 7.3e-11, 7.32e-11, 7.37e-11, 7.59e-11, 8.400000000000001e-11}, {1.409e-10, 1.409e-10, 1.409e-10, 1.409e-10, 1.409e-10, 1.411e-10, 1.4180000000000002e-10, 1.45e-10}}; +double lookTrAxis_OR2_X4_A2_ZN_risingTransition(int iTr) {return trAxis_OR2_X4_A2_ZN_risingTransition[iTr];} +double lookCapAxis_OR2_X4_A2_ZN_risingTransition(int iCap) {return capAxis_OR2_X4_A2_ZN_risingTransition[iCap];} +double lookTable_OR2_X4_A2_ZN_risingTransition(int iTr, int iCap) {return table_OR2_X4_A2_ZN_risingTransition[iCap][iTr];} + +double trAxis_OR2_X4_A2_ZN_fallingTransition[8] = {7.5e-12, 1.5e-11, 3.0e-11, 6.0e-11, 1.2e-10, 2.4e-10, 4.8e-10, 9.6e-10}; +double capAxis_OR2_X4_A2_ZN_fallingTransition[6] = {4.0e-16, 3.2e-15, 6.4e-15, 1.28e-14, 2.56e-14, 5.12e-14}; +double table_OR2_X4_A2_ZN_fallingTransition[6][8] = {{1.21e-11, 1.21e-11, 1.21e-11, 1.21e-11, 1.38e-11, 1.71e-11, 2.25e-11, 3.15e-11}, {1.62e-11, 1.62e-11, 1.62e-11, 1.62e-11, 1.7800000000000003e-11, 2.1100000000000003e-11, 2.66e-11, 3.58e-11}, {2.03e-11, 2.03e-11, 2.03e-11, 2.0400000000000002e-11, 2.1800000000000002e-11, 2.5100000000000003e-11, 3.0800000000000006e-11, 4.0400000000000004e-11}, {2.8000000000000003e-11, 2.8000000000000003e-11, 2.8000000000000003e-11, 2.8000000000000003e-11, 2.92e-11, 3.27e-11, 3.84e-11, 4.850000000000001e-11}, {4.21e-11, 4.21e-11, 4.21e-11, 4.21e-11, 4.29e-11, 4.64e-11, 5.2200000000000005e-11, 6.3e-11}, {7.03e-11, 7.03e-11, 7.03e-11, 7.02e-11, 7.07e-11, 7.32e-11, 7.83e-11, 8.95e-11}}; +double lookTrAxis_OR2_X4_A2_ZN_fallingTransition(int iTr) {return trAxis_OR2_X4_A2_ZN_fallingTransition[iTr];} +double lookCapAxis_OR2_X4_A2_ZN_fallingTransition(int iCap) {return capAxis_OR2_X4_A2_ZN_fallingTransition[iCap];} +double lookTable_OR2_X4_A2_ZN_fallingTransition(int iTr, int iCap) {return table_OR2_X4_A2_ZN_fallingTransition[iCap][iTr];} + +double trAxis_XNOR2_X1_A_ZN_risingDelay[8] = {7.5e-12, 1.5e-11, 3.0e-11, 6.0e-11, 1.2e-10, 2.4e-10, 4.8e-10, 9.6e-10}; +double capAxis_XNOR2_X1_A_ZN_risingDelay[6] = {4.0e-16, 8.0e-16, 1.6e-15, 3.2e-15, 6.4e-15, 1.28e-14}; +double table_XNOR2_X1_A_ZN_risingDelay[6][8] = {{7.78e-11, 8.080000000000001e-11, 8.61e-11, 9.270000000000001e-11, 9.87e-11, 1.31e-10, 1.871e-10, 2.8060000000000004e-10}, {8.250000000000001e-11, 8.560000000000001e-11, 9.09e-11, 9.760000000000002e-11, 1.0360000000000001e-10, 1.4130000000000002e-10, 2.002e-10, 2.967e-10}, {9.210000000000001e-11, 9.510000000000001e-11, 1.0040000000000001e-10, 1.0730000000000001e-10, 1.1870000000000001e-10, 1.606e-10, 2.2430000000000002e-10, 3.2710000000000004e-10}, {1.1140000000000001e-10, 1.1400000000000001e-10, 1.1930000000000002e-10, 1.265e-10, 1.4610000000000002e-10, 1.959e-10, 2.682e-10, 3.818e-10}, {1.49e-10, 1.517e-10, 1.571e-10, 1.683e-10, 1.972e-10, 2.5650000000000004e-10, 3.4530000000000004e-10, 4.777e-10}, {2.516e-10, 2.5460000000000003e-10, 2.607e-10, 2.7380000000000003e-10, 3.014e-10, 3.6020000000000006e-10, 4.748000000000001e-10, 6.411000000000001e-10}}; +double lookTrAxis_XNOR2_X1_A_ZN_risingDelay(int iTr) {return trAxis_XNOR2_X1_A_ZN_risingDelay[iTr];} +double lookCapAxis_XNOR2_X1_A_ZN_risingDelay(int iCap) {return capAxis_XNOR2_X1_A_ZN_risingDelay[iCap];} +double lookTable_XNOR2_X1_A_ZN_risingDelay(int iTr, int iCap) {return table_XNOR2_X1_A_ZN_risingDelay[iCap][iTr];} + +double trAxis_XNOR2_X1_A_ZN_fallingDelay[8] = {7.5e-12, 1.5e-11, 3.0e-11, 6.0e-11, 1.2e-10, 2.4e-10, 4.8e-10, 9.6e-10}; +double capAxis_XNOR2_X1_A_ZN_fallingDelay[6] = {4.0e-16, 8.0e-16, 1.6e-15, 3.2e-15, 6.4e-15, 1.28e-14}; +double table_XNOR2_X1_A_ZN_fallingDelay[6][8] = {{6.990000000000001e-11, 7.37e-11, 8.18e-11, 9.700000000000001e-11, 1.1940000000000002e-10, 1.528e-10, 2.059e-10, 2.935e-10}, {7.27e-11, 7.650000000000001e-11, 8.46e-11, 9.990000000000001e-11, 1.2250000000000002e-10, 1.56e-10, 2.097e-10, 2.984e-10}, {7.840000000000001e-11, 8.23e-11, 9.05e-11, 1.0570000000000001e-10, 1.2850000000000002e-10, 1.623e-10, 2.1690000000000002e-10, 3.071e-10}, {8.980000000000002e-11, 9.370000000000001e-11, 1.019e-10, 1.17e-10, 1.4050000000000003e-10, 1.7440000000000001e-10, 2.3000000000000003e-10, 3.228e-10}, {1.1190000000000001e-10, 1.158e-10, 1.24e-10, 1.3910000000000002e-10, 1.6280000000000002e-10, 1.9750000000000002e-10, 2.54e-10, 3.5e-10}, {1.5570000000000002e-10, 1.596e-10, 1.678e-10, 1.829e-10, 2.0670000000000002e-10, 2.42e-10, 2.9920000000000006e-10, 3.9820000000000003e-10}}; +double lookTrAxis_XNOR2_X1_A_ZN_fallingDelay(int iTr) {return trAxis_XNOR2_X1_A_ZN_fallingDelay[iTr];} +double lookCapAxis_XNOR2_X1_A_ZN_fallingDelay(int iCap) {return capAxis_XNOR2_X1_A_ZN_fallingDelay[iCap];} +double lookTable_XNOR2_X1_A_ZN_fallingDelay(int iTr, int iCap) {return table_XNOR2_X1_A_ZN_fallingDelay[iCap][iTr];} + +double trAxis_XNOR2_X1_A_ZN_risingTransition[8] = {7.5e-12, 1.5e-11, 3.0e-11, 6.0e-11, 1.2e-10, 2.4e-10, 4.8e-10, 9.6e-10}; +double capAxis_XNOR2_X1_A_ZN_risingTransition[6] = {4.0e-16, 8.0e-16, 1.6e-15, 3.2e-15, 6.4e-15, 1.28e-14}; +double table_XNOR2_X1_A_ZN_risingTransition[6][8] = {{4.14e-11, 4.14e-11, 4.14e-11, 4.3100000000000005e-11, 5.5400000000000004e-11, 7.470000000000001e-11, 1.0710000000000001e-10, 1.654e-10}, {4.7100000000000004e-11, 4.7100000000000004e-11, 4.69e-11, 4.84e-11, 6.04e-11, 8.1e-11, 1.1400000000000001e-10, 1.732e-10}, {5.940000000000001e-11, 5.95e-11, 5.940000000000001e-11, 5.96e-11, 6.980000000000001e-11, 9.260000000000001e-11, 1.277e-10, 1.886e-10}, {8.37e-11, 8.37e-11, 8.37e-11, 8.36e-11, 8.87e-11, 1.1350000000000001e-10, 1.5310000000000002e-10, 2.177e-10}, {1.3220000000000002e-10, 1.323e-10, 1.3220000000000002e-10, 1.3220000000000002e-10, 1.324e-10, 1.5e-10, 1.984e-10, 2.717e-10}, {2.2930000000000003e-10, 2.2930000000000003e-10, 2.2930000000000003e-10, 2.2930000000000003e-10, 2.2930000000000003e-10, 2.3180000000000002e-10, 2.742e-10, 3.6690000000000005e-10}}; +double lookTrAxis_XNOR2_X1_A_ZN_risingTransition(int iTr) {return trAxis_XNOR2_X1_A_ZN_risingTransition[iTr];} +double lookCapAxis_XNOR2_X1_A_ZN_risingTransition(int iCap) {return capAxis_XNOR2_X1_A_ZN_risingTransition[iCap];} +double lookTable_XNOR2_X1_A_ZN_risingTransition(int iTr, int iCap) {return table_XNOR2_X1_A_ZN_risingTransition[iCap][iTr];} + +double trAxis_XNOR2_X1_A_ZN_fallingTransition[8] = {7.5e-12, 1.5e-11, 3.0e-11, 6.0e-11, 1.2e-10, 2.4e-10, 4.8e-10, 9.6e-10}; +double capAxis_XNOR2_X1_A_ZN_fallingTransition[6] = {4.0e-16, 8.0e-16, 1.6e-15, 3.2e-15, 6.4e-15, 1.28e-14}; +double table_XNOR2_X1_A_ZN_fallingTransition[6][8] = {{2.19e-11, 2.19e-11, 2.19e-11, 2.5600000000000004e-11, 3.78e-11, 5.86e-11, 9.49e-11, 1.594e-10}, {2.42e-11, 2.42e-11, 2.42e-11, 2.7700000000000002e-11, 4.02e-11, 6.160000000000001e-11, 9.900000000000001e-11, 1.649e-10}, {2.8900000000000002e-11, 2.8900000000000002e-11, 2.8900000000000002e-11, 3.17e-11, 4.48e-11, 6.740000000000001e-11, 1.0650000000000001e-10, 1.7510000000000002e-10}, {3.84e-11, 3.8300000000000006e-11, 3.84e-11, 3.85e-11, 5.2900000000000006e-11, 7.74e-11, 1.195e-10, 1.9270000000000002e-10}, {5.7000000000000003e-11, 5.7000000000000003e-11, 5.7000000000000003e-11, 5.7000000000000003e-11, 6.67e-11, 9.47e-11, 1.416e-10, 2.2210000000000001e-10}, {9.43e-11, 9.43e-11, 9.43e-11, 9.43e-11, 9.43e-11, 1.238e-10, 1.783e-10, 2.692e-10}}; +double lookTrAxis_XNOR2_X1_A_ZN_fallingTransition(int iTr) {return trAxis_XNOR2_X1_A_ZN_fallingTransition[iTr];} +double lookCapAxis_XNOR2_X1_A_ZN_fallingTransition(int iCap) {return capAxis_XNOR2_X1_A_ZN_fallingTransition[iCap];} +double lookTable_XNOR2_X1_A_ZN_fallingTransition(int iTr, int iCap) {return table_XNOR2_X1_A_ZN_fallingTransition[iCap][iTr];} + +double trAxis_XNOR2_X1_B_ZN_risingDelay[8] = {7.5e-12, 1.5e-11, 3.0e-11, 6.0e-11, 1.2e-10, 2.4e-10, 4.8e-10, 9.6e-10}; +double capAxis_XNOR2_X1_B_ZN_risingDelay[6] = {4.0e-16, 8.0e-16, 1.6e-15, 3.2e-15, 6.4e-15, 1.28e-14}; +double table_XNOR2_X1_B_ZN_risingDelay[6][8] = {{8.550000000000001e-11, 8.81e-11, 9.24e-11, 9.900000000000001e-11, 1.055e-10, 1.351e-10, 1.861e-10, 2.712e-10}, {9.030000000000001e-11, 9.3e-11, 9.73e-11, 1.038e-10, 1.134e-10, 1.445e-10, 1.978e-10, 2.866e-10}, {9.990000000000001e-11, 1.027e-10, 1.0680000000000001e-10, 1.1350000000000001e-10, 1.286e-10, 1.626e-10, 2.198e-10, 3.1480000000000004e-10}, {1.192e-10, 1.22e-10, 1.2590000000000003e-10, 1.3400000000000003e-10, 1.567e-10, 1.9600000000000002e-10, 2.5990000000000005e-10, 3.651e-10}, {1.658e-10, 1.694e-10, 1.7580000000000003e-10, 1.8750000000000002e-10, 2.1010000000000003e-10, 2.5600000000000005e-10, 3.3100000000000005e-10, 4.5240000000000006e-10}, {2.719e-10, 2.756e-10, 2.822e-10, 2.939e-10, 3.1650000000000004e-10, 3.638e-10, 4.5550000000000003e-10, 6.013e-10}}; +double lookTrAxis_XNOR2_X1_B_ZN_risingDelay(int iTr) {return trAxis_XNOR2_X1_B_ZN_risingDelay[iTr];} +double lookCapAxis_XNOR2_X1_B_ZN_risingDelay(int iCap) {return capAxis_XNOR2_X1_B_ZN_risingDelay[iCap];} +double lookTable_XNOR2_X1_B_ZN_risingDelay(int iTr, int iCap) {return table_XNOR2_X1_B_ZN_risingDelay[iCap][iTr];} + +double trAxis_XNOR2_X1_B_ZN_fallingDelay[8] = {7.5e-12, 1.5e-11, 3.0e-11, 6.0e-11, 1.2e-10, 2.4e-10, 4.8e-10, 9.6e-10}; +double capAxis_XNOR2_X1_B_ZN_fallingDelay[6] = {4.0e-16, 8.0e-16, 1.6e-15, 3.2e-15, 6.4e-15, 1.28e-14}; +double table_XNOR2_X1_B_ZN_fallingDelay[6][8] = {{7.74e-11, 8.12e-11, 8.910000000000001e-11, 1.056e-10, 1.331e-10, 1.731e-10, 2.3420000000000003e-10, 3.344e-10}, {8.03e-11, 8.400000000000001e-11, 9.2e-11, 1.085e-10, 1.361e-10, 1.764e-10, 2.3790000000000003e-10, 3.389e-10}, {8.61e-11, 8.980000000000002e-11, 9.78e-11, 1.1430000000000001e-10, 1.421e-10, 1.8250000000000002e-10, 2.448e-10, 3.4730000000000003e-10}, {9.73e-11, 1.0100000000000001e-10, 1.0920000000000001e-10, 1.2559999999999999e-10, 1.536e-10, 1.944e-10, 2.5750000000000004e-10, 3.616e-10}, {1.19e-10, 1.228e-10, 1.311e-10, 1.475e-10, 1.755e-10, 2.171e-10, 2.8100000000000006e-10, 3.872e-10}, {1.626e-10, 1.6640000000000001e-10, 1.747e-10, 1.911e-10, 2.1920000000000003e-10, 2.6090000000000005e-10, 3.253e-10, 4.3330000000000004e-10}}; +double lookTrAxis_XNOR2_X1_B_ZN_fallingDelay(int iTr) {return trAxis_XNOR2_X1_B_ZN_fallingDelay[iTr];} +double lookCapAxis_XNOR2_X1_B_ZN_fallingDelay(int iCap) {return capAxis_XNOR2_X1_B_ZN_fallingDelay[iCap];} +double lookTable_XNOR2_X1_B_ZN_fallingDelay(int iTr, int iCap) {return table_XNOR2_X1_B_ZN_fallingDelay[iCap][iTr];} + +double trAxis_XNOR2_X1_B_ZN_risingTransition[8] = {7.5e-12, 1.5e-11, 3.0e-11, 6.0e-11, 1.2e-10, 2.4e-10, 4.8e-10, 9.6e-10}; +double capAxis_XNOR2_X1_B_ZN_risingTransition[6] = {4.0e-16, 8.0e-16, 1.6e-15, 3.2e-15, 6.4e-15, 1.28e-14}; +double table_XNOR2_X1_B_ZN_risingTransition[6][8] = {{4.14e-11, 4.14e-11, 4.14e-11, 4.18e-11, 5.0300000000000003e-11, 6.6e-11, 9.28e-11, 1.3930000000000003e-10}, {4.7100000000000004e-11, 4.7100000000000004e-11, 4.7100000000000004e-11, 4.760000000000001e-11, 5.56e-11, 7.16e-11, 9.86e-11, 1.459e-10}, {5.940000000000001e-11, 5.940000000000001e-11, 5.940000000000001e-11, 5.95e-11, 6.58e-11, 8.260000000000002e-11, 1.1020000000000002e-10, 1.586e-10}, {8.37e-11, 8.37e-11, 8.37e-11, 8.36e-11, 8.66e-11, 1.035e-10, 1.3270000000000002e-10, 1.8320000000000002e-10}, {1.3220000000000002e-10, 1.323e-10, 1.3220000000000002e-10, 1.3220000000000002e-10, 1.324e-10, 1.438e-10, 1.7630000000000003e-10, 2.301e-10}, {2.2930000000000003e-10, 2.2930000000000003e-10, 2.2930000000000003e-10, 2.2930000000000003e-10, 2.2930000000000003e-10, 2.3130000000000002e-10, 2.591e-10, 3.1990000000000005e-10}}; +double lookTrAxis_XNOR2_X1_B_ZN_risingTransition(int iTr) {return trAxis_XNOR2_X1_B_ZN_risingTransition[iTr];} +double lookCapAxis_XNOR2_X1_B_ZN_risingTransition(int iCap) {return capAxis_XNOR2_X1_B_ZN_risingTransition[iCap];} +double lookTable_XNOR2_X1_B_ZN_risingTransition(int iTr, int iCap) {return table_XNOR2_X1_B_ZN_risingTransition[iCap][iTr];} + +double trAxis_XNOR2_X1_B_ZN_fallingTransition[8] = {7.5e-12, 1.5e-11, 3.0e-11, 6.0e-11, 1.2e-10, 2.4e-10, 4.8e-10, 9.6e-10}; +double capAxis_XNOR2_X1_B_ZN_fallingTransition[6] = {4.0e-16, 8.0e-16, 1.6e-15, 3.2e-15, 6.4e-15, 1.28e-14}; +double table_XNOR2_X1_B_ZN_fallingTransition[6][8] = {{2.1200000000000002e-11, 2.1000000000000002e-11, 2.15e-11, 2.8100000000000002e-11, 4.05e-11, 6.07e-11, 9.460000000000001e-11, 1.528e-10}, {2.37e-11, 2.36e-11, 2.37e-11, 3.01e-11, 4.29e-11, 6.38e-11, 9.880000000000001e-11, 1.588e-10}, {2.8600000000000003e-11, 2.8500000000000002e-11, 2.8500000000000002e-11, 3.39e-11, 4.730000000000001e-11, 6.96e-11, 1.0650000000000001e-10, 1.697e-10}, {3.8000000000000004e-11, 3.8000000000000004e-11, 3.78e-11, 4.0700000000000006e-11, 5.52e-11, 7.97e-11, 1.1990000000000002e-10, 1.883e-10}, {5.67e-11, 5.67e-11, 5.67e-11, 5.7000000000000003e-11, 6.87e-11, 9.700000000000001e-11, 1.427e-10, 2.1890000000000001e-10}, {9.420000000000001e-11, 9.420000000000001e-11, 9.420000000000001e-11, 9.43e-11, 9.750000000000001e-11, 1.258e-10, 1.8010000000000003e-10, 2.6790000000000003e-10}}; +double lookTrAxis_XNOR2_X1_B_ZN_fallingTransition(int iTr) {return trAxis_XNOR2_X1_B_ZN_fallingTransition[iTr];} +double lookCapAxis_XNOR2_X1_B_ZN_fallingTransition(int iCap) {return capAxis_XNOR2_X1_B_ZN_fallingTransition[iCap];} +double lookTable_XNOR2_X1_B_ZN_fallingTransition(int iTr, int iCap) {return table_XNOR2_X1_B_ZN_fallingTransition[iCap][iTr];} + +double trAxis_XNOR2_X2_A_ZN_risingDelay[8] = {7.5e-12, 1.5e-11, 3.0e-11, 6.0e-11, 1.2e-10, 2.4e-10, 4.8e-10, 9.6e-10}; +double capAxis_XNOR2_X2_A_ZN_risingDelay[6] = {4.0e-16, 1.6e-15, 3.2e-15, 6.4e-15, 1.28e-14, 2.56e-14}; +double table_XNOR2_X2_A_ZN_risingDelay[6][8] = {{6.940000000000001e-11, 7.240000000000002e-11, 7.79e-11, 8.57e-11, 9.36e-11, 1.129e-10, 1.6450000000000003e-10, 2.5230000000000005e-10}, {7.630000000000001e-11, 7.93e-11, 8.490000000000001e-11, 9.270000000000001e-11, 1.0060000000000001e-10, 1.2920000000000003e-10, 1.85e-10, 2.7770000000000003e-10}, {8.560000000000001e-11, 8.860000000000001e-11, 9.420000000000001e-11, 1.02e-10, 1.099e-10, 1.491e-10, 2.098e-10, 3.091e-10}, {1.04e-10, 1.0680000000000001e-10, 1.123e-10, 1.206e-10, 1.3800000000000001e-10, 1.85e-10, 2.544e-10, 3.6470000000000004e-10}, {1.4030000000000002e-10, 1.431e-10, 1.4870000000000001e-10, 1.5900000000000002e-10, 1.881e-10, 2.463e-10, 3.319e-10, 4.6110000000000004e-10}, {2.4e-10, 2.429e-10, 2.49e-10, 2.62e-10, 2.8960000000000006e-10, 3.4870000000000005e-10, 4.613e-10, 6.238000000000001e-10}}; +double lookTrAxis_XNOR2_X2_A_ZN_risingDelay(int iTr) {return trAxis_XNOR2_X2_A_ZN_risingDelay[iTr];} +double lookCapAxis_XNOR2_X2_A_ZN_risingDelay(int iCap) {return capAxis_XNOR2_X2_A_ZN_risingDelay[iCap];} +double lookTable_XNOR2_X2_A_ZN_risingDelay(int iTr, int iCap) {return table_XNOR2_X2_A_ZN_risingDelay[iCap][iTr];} + +double trAxis_XNOR2_X2_A_ZN_fallingDelay[8] = {7.5e-12, 1.5e-11, 3.0e-11, 6.0e-11, 1.2e-10, 2.4e-10, 4.8e-10, 9.6e-10}; +double capAxis_XNOR2_X2_A_ZN_fallingDelay[6] = {4.0e-16, 1.6e-15, 3.2e-15, 6.4e-15, 1.28e-14, 2.56e-14}; +double table_XNOR2_X2_A_ZN_fallingDelay[6][8] = {{6.86e-11, 7.230000000000001e-11, 8.04e-11, 9.62e-11, 1.204e-10, 1.5540000000000003e-10, 2.0990000000000002e-10, 2.986e-10}, {7.3e-11, 7.68e-11, 8.480000000000001e-11, 1.0060000000000001e-10, 1.2509999999999999e-10, 1.606e-10, 2.1620000000000001e-10, 3.067e-10}, {7.870000000000001e-11, 8.250000000000001e-11, 9.06e-11, 1.064e-10, 1.311e-10, 1.671e-10, 2.239e-10, 3.159e-10}, {8.980000000000002e-11, 9.35e-11, 1.0170000000000001e-10, 1.175e-10, 1.4280000000000001e-10, 1.793e-10, 2.3730000000000005e-10, 3.3250000000000004e-10}, {1.1140000000000001e-10, 1.152e-10, 1.234e-10, 1.392e-10, 1.6480000000000002e-10, 2.021e-10, 2.613e-10, 3.6020000000000006e-10}, {1.5420000000000002e-10, 1.5800000000000002e-10, 1.662e-10, 1.8200000000000002e-10, 2.0770000000000002e-10, 2.456e-10, 3.0570000000000004e-10, 4.08e-10}}; +double lookTrAxis_XNOR2_X2_A_ZN_fallingDelay(int iTr) {return trAxis_XNOR2_X2_A_ZN_fallingDelay[iTr];} +double lookCapAxis_XNOR2_X2_A_ZN_fallingDelay(int iCap) {return capAxis_XNOR2_X2_A_ZN_fallingDelay[iCap];} +double lookTable_XNOR2_X2_A_ZN_fallingDelay(int iTr, int iCap) {return table_XNOR2_X2_A_ZN_fallingDelay[iCap][iTr];} + +double trAxis_XNOR2_X2_A_ZN_risingTransition[8] = {7.5e-12, 1.5e-11, 3.0e-11, 6.0e-11, 1.2e-10, 2.4e-10, 4.8e-10, 9.6e-10}; +double capAxis_XNOR2_X2_A_ZN_risingTransition[6] = {4.0e-16, 1.6e-15, 3.2e-15, 6.4e-15, 1.28e-14, 2.56e-14}; +double table_XNOR2_X2_A_ZN_risingTransition[6][8] = {{3.1600000000000006e-11, 3.1600000000000006e-11, 3.1600000000000006e-11, 3.5300000000000003e-11, 4.65e-11, 6.400000000000001e-11, 9.48e-11, 1.5160000000000002e-10}, {3.93e-11, 3.93e-11, 3.9e-11, 4.220000000000001e-11, 5.4500000000000006e-11, 7.360000000000001e-11, 1.054e-10, 1.635e-10}, {5.15e-11, 5.13e-11, 5.13e-11, 5.240000000000001e-11, 6.43e-11, 8.550000000000001e-11, 1.192e-10, 1.7890000000000002e-10}, {7.51e-11, 7.51e-11, 7.51e-11, 7.5e-11, 8.200000000000001e-11, 1.067e-10, 1.4460000000000002e-10, 2.08e-10}, {1.224e-10, 1.2250000000000002e-10, 1.2250000000000002e-10, 1.2250000000000002e-10, 1.2310000000000002e-10, 1.4280000000000001e-10, 1.901e-10, 2.6150000000000003e-10}, {2.1730000000000001e-10, 2.1730000000000001e-10, 2.1730000000000001e-10, 2.1730000000000001e-10, 2.1730000000000001e-10, 2.2090000000000003e-10, 2.657e-10, 3.56e-10}}; +double lookTrAxis_XNOR2_X2_A_ZN_risingTransition(int iTr) {return trAxis_XNOR2_X2_A_ZN_risingTransition[iTr];} +double lookCapAxis_XNOR2_X2_A_ZN_risingTransition(int iCap) {return capAxis_XNOR2_X2_A_ZN_risingTransition[iCap];} +double lookTable_XNOR2_X2_A_ZN_risingTransition(int iTr, int iCap) {return table_XNOR2_X2_A_ZN_risingTransition[iCap][iTr];} + +double trAxis_XNOR2_X2_A_ZN_fallingTransition[8] = {7.5e-12, 1.5e-11, 3.0e-11, 6.0e-11, 1.2e-10, 2.4e-10, 4.8e-10, 9.6e-10}; +double capAxis_XNOR2_X2_A_ZN_fallingTransition[6] = {4.0e-16, 1.6e-15, 3.2e-15, 6.4e-15, 1.28e-14, 2.56e-14}; +double table_XNOR2_X2_A_ZN_fallingTransition[6][8] = {{1.7600000000000003e-11, 1.7500000000000004e-11, 1.7600000000000003e-11, 2.2100000000000003e-11, 3.34e-11, 5.3000000000000004e-11, 8.730000000000001e-11, 1.491e-10}, {2.09e-11, 2.09e-11, 2.09e-11, 2.5300000000000002e-11, 3.72e-11, 5.79e-11, 9.400000000000001e-11, 1.581e-10}, {2.54e-11, 2.54e-11, 2.54e-11, 2.93e-11, 4.21e-11, 6.390000000000001e-11, 1.019e-10, 1.687e-10}, {3.4400000000000005e-11, 3.4500000000000004e-11, 3.4500000000000004e-11, 3.58e-11, 5.01e-11, 7.410000000000001e-11, 1.152e-10, 1.87e-10}, {5.240000000000001e-11, 5.240000000000001e-11, 5.240000000000001e-11, 5.240000000000001e-11, 6.400000000000001e-11, 9.160000000000001e-11, 1.3760000000000002e-10, 2.1680000000000002e-10}, {8.88e-11, 8.890000000000001e-11, 8.88e-11, 8.890000000000001e-11, 9.04e-11, 1.206e-10, 1.7410000000000002e-10, 2.64e-10}}; +double lookTrAxis_XNOR2_X2_A_ZN_fallingTransition(int iTr) {return trAxis_XNOR2_X2_A_ZN_fallingTransition[iTr];} +double lookCapAxis_XNOR2_X2_A_ZN_fallingTransition(int iCap) {return capAxis_XNOR2_X2_A_ZN_fallingTransition[iCap];} +double lookTable_XNOR2_X2_A_ZN_fallingTransition(int iTr, int iCap) {return table_XNOR2_X2_A_ZN_fallingTransition[iCap][iTr];} + +double trAxis_XNOR2_X2_B_ZN_risingDelay[8] = {7.5e-12, 1.5e-11, 3.0e-11, 6.0e-11, 1.2e-10, 2.4e-10, 4.8e-10, 9.6e-10}; +double capAxis_XNOR2_X2_B_ZN_risingDelay[6] = {4.0e-16, 1.6e-15, 3.2e-15, 6.4e-15, 1.28e-14, 2.56e-14}; +double table_XNOR2_X2_B_ZN_risingDelay[6][8] = {{7.69e-11, 7.960000000000001e-11, 8.39e-11, 9.100000000000001e-11, 9.880000000000001e-11, 1.151e-10, 1.6220000000000002e-10, 2.414e-10}, {8.39e-11, 8.66e-11, 9.100000000000001e-11, 9.800000000000001e-11, 1.0600000000000001e-10, 1.3000000000000002e-10, 1.812e-10, 2.658e-10}, {9.310000000000001e-11, 9.59e-11, 1.003e-10, 1.074e-10, 1.157e-10, 1.485e-10, 2.038e-10, 2.951e-10}, {1.1160000000000001e-10, 1.145e-10, 1.1870000000000001e-10, 1.26e-10, 1.44e-10, 1.8210000000000002e-10, 2.444e-10, 3.465e-10}, {1.5250000000000002e-10, 1.56e-10, 1.6210000000000001e-10, 1.735e-10, 1.963e-10, 2.419e-10, 3.154e-10, 4.3430000000000004e-10}, {2.561e-10, 2.596e-10, 2.66e-10, 2.774e-10, 3.001e-10, 3.479e-10, 4.386e-10, 5.822000000000001e-10}}; +double lookTrAxis_XNOR2_X2_B_ZN_risingDelay(int iTr) {return trAxis_XNOR2_X2_B_ZN_risingDelay[iTr];} +double lookCapAxis_XNOR2_X2_B_ZN_risingDelay(int iCap) {return capAxis_XNOR2_X2_B_ZN_risingDelay[iCap];} +double lookTable_XNOR2_X2_B_ZN_risingDelay(int iTr, int iCap) {return table_XNOR2_X2_B_ZN_risingDelay[iCap][iTr];} + +double trAxis_XNOR2_X2_B_ZN_fallingDelay[8] = {7.5e-12, 1.5e-11, 3.0e-11, 6.0e-11, 1.2e-10, 2.4e-10, 4.8e-10, 9.6e-10}; +double capAxis_XNOR2_X2_B_ZN_fallingDelay[6] = {4.0e-16, 1.6e-15, 3.2e-15, 6.4e-15, 1.28e-14, 2.56e-14}; +double table_XNOR2_X2_B_ZN_fallingDelay[6][8] = {{7.660000000000001e-11, 8.03e-11, 8.830000000000001e-11, 1.0470000000000001e-10, 1.334e-10, 1.749e-10, 2.37e-10, 3.388e-10}, {8.12e-11, 8.490000000000001e-11, 9.28e-11, 1.093e-10, 1.383e-10, 1.803e-10, 2.4330000000000003e-10, 3.466e-10}, {8.7e-11, 9.070000000000001e-11, 9.87e-11, 1.152e-10, 1.443e-10, 1.867e-10, 2.511e-10, 3.555e-10}, {9.810000000000002e-11, 1.0180000000000001e-10, 1.099e-10, 1.2640000000000002e-10, 1.558e-10, 1.989e-10, 2.643e-10, 3.71e-10}, {1.1990000000000002e-10, 1.2350000000000001e-10, 1.316e-10, 1.481e-10, 1.776e-10, 2.213e-10, 2.88e-10, 3.9720000000000003e-10}, {1.626e-10, 1.663e-10, 1.7440000000000001e-10, 1.909e-10, 2.2040000000000004e-10, 2.6440000000000004e-10, 3.318e-10, 4.43e-10}}; +double lookTrAxis_XNOR2_X2_B_ZN_fallingDelay(int iTr) {return trAxis_XNOR2_X2_B_ZN_fallingDelay[iTr];} +double lookCapAxis_XNOR2_X2_B_ZN_fallingDelay(int iCap) {return capAxis_XNOR2_X2_B_ZN_fallingDelay[iCap];} +double lookTable_XNOR2_X2_B_ZN_fallingDelay(int iTr, int iCap) {return table_XNOR2_X2_B_ZN_fallingDelay[iCap][iTr];} + +double trAxis_XNOR2_X2_B_ZN_risingTransition[8] = {7.5e-12, 1.5e-11, 3.0e-11, 6.0e-11, 1.2e-10, 2.4e-10, 4.8e-10, 9.6e-10}; +double capAxis_XNOR2_X2_B_ZN_risingTransition[6] = {4.0e-16, 1.6e-15, 3.2e-15, 6.4e-15, 1.28e-14, 2.56e-14}; +double table_XNOR2_X2_B_ZN_risingTransition[6][8] = {{3.15e-11, 3.15e-11, 3.1600000000000006e-11, 3.2800000000000006e-11, 4.1500000000000005e-11, 5.630000000000001e-11, 8.160000000000001e-11, 1.2620000000000001e-10}, {3.93e-11, 3.93e-11, 3.93e-11, 4.0700000000000006e-11, 4.9400000000000005e-11, 6.450000000000001e-11, 9.04e-11, 1.361e-10}, {5.1400000000000005e-11, 5.13e-11, 5.1400000000000005e-11, 5.19e-11, 5.970000000000001e-11, 7.55e-11, 1.021e-10, 1.491e-10}, {7.51e-11, 7.51e-11, 7.51e-11, 7.51e-11, 7.920000000000001e-11, 9.62e-11, 1.243e-10, 1.7360000000000003e-10}, {1.2250000000000002e-10, 1.2250000000000002e-10, 1.2250000000000002e-10, 1.2250000000000002e-10, 1.2300000000000001e-10, 1.359e-10, 1.674e-10, 2.201e-10}, {2.1730000000000001e-10, 2.1730000000000001e-10, 2.172e-10, 2.1730000000000001e-10, 2.1730000000000001e-10, 2.2000000000000002e-10, 2.491e-10, 3.085e-10}}; +double lookTrAxis_XNOR2_X2_B_ZN_risingTransition(int iTr) {return trAxis_XNOR2_X2_B_ZN_risingTransition[iTr];} +double lookCapAxis_XNOR2_X2_B_ZN_risingTransition(int iCap) {return capAxis_XNOR2_X2_B_ZN_risingTransition[iCap];} +double lookTable_XNOR2_X2_B_ZN_risingTransition(int iTr, int iCap) {return table_XNOR2_X2_B_ZN_risingTransition[iCap][iTr];} + +double trAxis_XNOR2_X2_B_ZN_fallingTransition[8] = {7.5e-12, 1.5e-11, 3.0e-11, 6.0e-11, 1.2e-10, 2.4e-10, 4.8e-10, 9.6e-10}; +double capAxis_XNOR2_X2_B_ZN_fallingTransition[6] = {4.0e-16, 1.6e-15, 3.2e-15, 6.4e-15, 1.28e-14, 2.56e-14}; +double table_XNOR2_X2_B_ZN_fallingTransition[6][8] = {{1.6000000000000003e-11, 1.5699999999999998e-11, 1.7600000000000003e-11, 2.4400000000000004e-11, 3.5700000000000003e-11, 5.44e-11, 8.6e-11, 1.41e-10}, {1.97e-11, 1.95e-11, 2.0500000000000004e-11, 2.7500000000000002e-11, 3.9500000000000006e-11, 5.940000000000001e-11, 9.29e-11, 1.5090000000000002e-10}, {2.43e-11, 2.42e-11, 2.4700000000000003e-11, 3.11e-11, 4.4200000000000006e-11, 6.54e-11, 1.011e-10, 1.625e-10}, {3.350000000000001e-11, 3.350000000000001e-11, 3.350000000000001e-11, 3.7600000000000005e-11, 5.2100000000000006e-11, 7.59e-11, 1.1490000000000001e-10, 1.819e-10}, {5.19e-11, 5.19e-11, 5.19e-11, 5.2900000000000006e-11, 6.57e-11, 9.340000000000001e-11, 1.3800000000000001e-10, 2.1300000000000001e-10}, {8.87e-11, 8.88e-11, 8.88e-11, 8.88e-11, 9.3e-11, 1.223e-10, 1.7560000000000002e-10, 2.621e-10}}; +double lookTrAxis_XNOR2_X2_B_ZN_fallingTransition(int iTr) {return trAxis_XNOR2_X2_B_ZN_fallingTransition[iTr];} +double lookCapAxis_XNOR2_X2_B_ZN_fallingTransition(int iCap) {return capAxis_XNOR2_X2_B_ZN_fallingTransition[iCap];} +double lookTable_XNOR2_X2_B_ZN_fallingTransition(int iTr, int iCap) {return table_XNOR2_X2_B_ZN_fallingTransition[iCap][iTr];} + +double trAxis_XOR2_X1_A_Z_risingDelay[8] = {7.5e-12, 1.5e-11, 3.0e-11, 6.0e-11, 1.2e-10, 2.4e-10, 4.8e-10, 9.6e-10}; +double capAxis_XOR2_X1_A_Z_risingDelay[6] = {4.0e-16, 8.0e-16, 1.6e-15, 3.2e-15, 6.4e-15, 1.28e-14}; +double table_XOR2_X1_A_Z_risingDelay[6][8] = {{1.0150000000000001e-10, 1.0470000000000001e-10, 1.104e-10, 1.176e-10, 1.2370000000000002e-10, 1.287e-10, 1.838e-10, 2.763e-10}, {1.0810000000000001e-10, 1.1140000000000001e-10, 1.172e-10, 1.244e-10, 1.308e-10, 1.39e-10, 1.973e-10, 2.928e-10}, {1.215e-10, 1.248e-10, 1.3050000000000001e-10, 1.3800000000000001e-10, 1.449e-10, 1.587e-10, 2.2160000000000002e-10, 3.236e-10}, {1.481e-10, 1.5110000000000003e-10, 1.5690000000000002e-10, 1.6470000000000004e-10, 1.722e-10, 1.9430000000000002e-10, 2.66e-10, 3.788e-10}, {2.009e-10, 2.0390000000000001e-10, 2.0990000000000002e-10, 2.1740000000000002e-10, 2.2530000000000001e-10, 2.552e-10, 3.4360000000000003e-10, 4.753e-10}, {3.066e-10, 3.097e-10, 3.157e-10, 3.233e-10, 3.313e-10, 3.5920000000000006e-10, 4.734e-10, 6.393000000000001e-10}}; +double lookTrAxis_XOR2_X1_A_Z_risingDelay(int iTr) {return trAxis_XOR2_X1_A_Z_risingDelay[iTr];} +double lookCapAxis_XOR2_X1_A_Z_risingDelay(int iCap) {return capAxis_XOR2_X1_A_Z_risingDelay[iCap];} +double lookTable_XOR2_X1_A_Z_risingDelay(int iTr, int iCap) {return table_XOR2_X1_A_Z_risingDelay[iCap][iTr];} + +double trAxis_XOR2_X1_A_Z_fallingDelay[8] = {7.5e-12, 1.5e-11, 3.0e-11, 6.0e-11, 1.2e-10, 2.4e-10, 4.8e-10, 9.6e-10}; +double capAxis_XOR2_X1_A_Z_fallingDelay[6] = {4.0e-16, 8.0e-16, 1.6e-15, 3.2e-15, 6.4e-15, 1.28e-14}; +double table_XOR2_X1_A_Z_fallingDelay[6][8] = {{7.710000000000001e-11, 8.04e-11, 8.75e-11, 1.02e-10, 1.2470000000000002e-10, 1.581e-10, 2.1060000000000003e-10, 2.966e-10}, {8.02e-11, 8.34e-11, 9.06e-11, 1.051e-10, 1.2790000000000002e-10, 1.615e-10, 2.145e-10, 3.014e-10}, {8.6e-11, 8.920000000000001e-11, 9.65e-11, 1.109e-10, 1.3400000000000003e-10, 1.6800000000000001e-10, 2.2220000000000002e-10, 3.1030000000000006e-10}, {9.71e-11, 1.0050000000000001e-10, 1.0770000000000001e-10, 1.22e-10, 1.4560000000000002e-10, 1.8e-10, 2.353e-10, 3.263e-10}, {1.18e-10, 1.213e-10, 1.286e-10, 1.4280000000000001e-10, 1.668e-10, 2.0190000000000002e-10, 2.588e-10, 3.538e-10}, {1.571e-10, 1.604e-10, 1.6760000000000002e-10, 1.819e-10, 2.0610000000000002e-10, 2.419e-10, 3.0030000000000004e-10, 4.002e-10}}; +double lookTrAxis_XOR2_X1_A_Z_fallingDelay(int iTr) {return trAxis_XOR2_X1_A_Z_fallingDelay[iTr];} +double lookCapAxis_XOR2_X1_A_Z_fallingDelay(int iCap) {return capAxis_XOR2_X1_A_Z_fallingDelay[iCap];} +double lookTable_XOR2_X1_A_Z_fallingDelay(int iTr, int iCap) {return table_XOR2_X1_A_Z_fallingDelay[iCap][iTr];} + +double trAxis_XOR2_X1_A_Z_risingTransition[8] = {7.5e-12, 1.5e-11, 3.0e-11, 6.0e-11, 1.2e-10, 2.4e-10, 4.8e-10, 9.6e-10}; +double capAxis_XOR2_X1_A_Z_risingTransition[6] = {4.0e-16, 8.0e-16, 1.6e-15, 3.2e-15, 6.4e-15, 1.28e-14}; +double table_XOR2_X1_A_Z_risingTransition[6][8] = {{5.0700000000000003e-11, 5.0700000000000003e-11, 5.0700000000000003e-11, 5.0700000000000003e-11, 5.5400000000000004e-11, 7.45e-11, 1.064e-10, 1.644e-10}, {5.680000000000001e-11, 5.680000000000001e-11, 5.680000000000001e-11, 5.680000000000001e-11, 6.05e-11, 8.07e-11, 1.1350000000000001e-10, 1.721e-10}, {6.92e-11, 6.92e-11, 6.92e-11, 6.92e-11, 7.01e-11, 9.25e-11, 1.2730000000000002e-10, 1.8780000000000001e-10}, {9.390000000000001e-11, 9.390000000000001e-11, 9.390000000000001e-11, 9.390000000000001e-11, 9.33e-11, 1.1350000000000001e-10, 1.528e-10, 2.171e-10}, {1.4280000000000001e-10, 1.4290000000000002e-10, 1.4290000000000002e-10, 1.4290000000000002e-10, 1.4290000000000002e-10, 1.503e-10, 1.9830000000000003e-10, 2.713e-10}, {2.405e-10, 2.405e-10, 2.405e-10, 2.405e-10, 2.405e-10, 2.395e-10, 2.7450000000000003e-10, 3.668e-10}}; +double lookTrAxis_XOR2_X1_A_Z_risingTransition(int iTr) {return trAxis_XOR2_X1_A_Z_risingTransition[iTr];} +double lookCapAxis_XOR2_X1_A_Z_risingTransition(int iCap) {return capAxis_XOR2_X1_A_Z_risingTransition[iCap];} +double lookTable_XOR2_X1_A_Z_risingTransition(int iTr, int iCap) {return table_XOR2_X1_A_Z_risingTransition[iCap][iTr];} + +double trAxis_XOR2_X1_A_Z_fallingTransition[8] = {7.5e-12, 1.5e-11, 3.0e-11, 6.0e-11, 1.2e-10, 2.4e-10, 4.8e-10, 9.6e-10}; +double capAxis_XOR2_X1_A_Z_fallingTransition[6] = {4.0e-16, 8.0e-16, 1.6e-15, 3.2e-15, 6.4e-15, 1.28e-14}; +double table_XOR2_X1_A_Z_fallingTransition[6][8] = {{2.48e-11, 2.4700000000000003e-11, 2.4700000000000003e-11, 2.49e-11, 3.6100000000000003e-11, 5.680000000000001e-11, 9.28e-11, 1.5690000000000002e-10}, {2.6800000000000004e-11, 2.6700000000000002e-11, 2.6700000000000002e-11, 2.6900000000000002e-11, 3.860000000000001e-11, 5.990000000000001e-11, 9.690000000000001e-11, 1.625e-10}, {3.0800000000000006e-11, 3.07e-11, 3.07e-11, 3.0900000000000004e-11, 4.33e-11, 6.560000000000001e-11, 1.045e-10, 1.7280000000000001e-10}, {3.87e-11, 3.860000000000001e-11, 3.860000000000001e-11, 3.87e-11, 5.13e-11, 7.56e-11, 1.1770000000000002e-10, 1.906e-10}, {5.4e-11, 5.4e-11, 5.4e-11, 5.4100000000000006e-11, 6.519999999999999e-11, 9.310000000000001e-11, 1.3980000000000002e-10, 2.201e-10}, {8.730000000000001e-11, 8.730000000000001e-11, 8.730000000000001e-11, 8.730000000000001e-11, 9.210000000000001e-11, 1.223e-10, 1.7660000000000002e-10, 2.6740000000000003e-10}}; +double lookTrAxis_XOR2_X1_A_Z_fallingTransition(int iTr) {return trAxis_XOR2_X1_A_Z_fallingTransition[iTr];} +double lookCapAxis_XOR2_X1_A_Z_fallingTransition(int iCap) {return capAxis_XOR2_X1_A_Z_fallingTransition[iCap];} +double lookTable_XOR2_X1_A_Z_fallingTransition(int iTr, int iCap) {return table_XOR2_X1_A_Z_fallingTransition[iCap][iTr];} + +double trAxis_XOR2_X1_B_Z_risingDelay[8] = {7.5e-12, 1.5e-11, 3.0e-11, 6.0e-11, 1.2e-10, 2.4e-10, 4.8e-10, 9.6e-10}; +double capAxis_XOR2_X1_B_Z_risingDelay[6] = {4.0e-16, 8.0e-16, 1.6e-15, 3.2e-15, 6.4e-15, 1.28e-14}; +double table_XOR2_X1_B_Z_risingDelay[6][8] = {{9.24e-11, 9.580000000000001e-11, 1.0240000000000002e-10, 1.127e-10, 1.243e-10, 1.567e-10, 2.2110000000000002e-10, 3.287e-10}, {9.930000000000001e-11, 1.026e-10, 1.093e-10, 1.195e-10, 1.31e-10, 1.659e-10, 2.333e-10, 3.433e-10}, {1.1260000000000002e-10, 1.161e-10, 1.226e-10, 1.33e-10, 1.445e-10, 1.8390000000000003e-10, 2.554e-10, 3.7130000000000005e-10}, {1.3960000000000001e-10, 1.43e-10, 1.491e-10, 1.596e-10, 1.7130000000000002e-10, 2.167e-10, 2.9680000000000005e-10, 4.2220000000000005e-10}, {1.926e-10, 1.9600000000000002e-10, 2.0200000000000003e-10, 2.1250000000000002e-10, 2.241e-10, 2.742e-10, 3.7019999999999997e-10, 5.131e-10}, {2.985e-10, 3.019e-10, 3.08e-10, 3.1850000000000004e-10, 3.302e-10, 3.767e-10, 4.948000000000001e-10, 6.707e-10}}; +double lookTrAxis_XOR2_X1_B_Z_risingDelay(int iTr) {return trAxis_XOR2_X1_B_Z_risingDelay[iTr];} +double lookCapAxis_XOR2_X1_B_Z_risingDelay(int iCap) {return capAxis_XOR2_X1_B_Z_risingDelay[iCap];} +double lookTable_XOR2_X1_B_Z_risingDelay(int iTr, int iCap) {return table_XOR2_X1_B_Z_risingDelay[iCap][iTr];} + +double trAxis_XOR2_X1_B_Z_fallingDelay[8] = {7.5e-12, 1.5e-11, 3.0e-11, 6.0e-11, 1.2e-10, 2.4e-10, 4.8e-10, 9.6e-10}; +double capAxis_XOR2_X1_B_Z_fallingDelay[6] = {4.0e-16, 8.0e-16, 1.6e-15, 3.2e-15, 6.4e-15, 1.28e-14}; +double table_XOR2_X1_B_Z_fallingDelay[6][8] = {{9.83e-11, 1.02e-10, 1.0840000000000001e-10, 1.1930000000000002e-10, 1.371e-10, 1.6430000000000002e-10, 2.1150000000000002e-10, 2.893e-10}, {1.0140000000000001e-10, 1.051e-10, 1.1140000000000001e-10, 1.224e-10, 1.4030000000000002e-10, 1.677e-10, 2.1540000000000003e-10, 2.939e-10}, {1.0710000000000001e-10, 1.1070000000000002e-10, 1.172e-10, 1.282e-10, 1.464e-10, 1.7430000000000003e-10, 2.23e-10, 3.029e-10}, {1.181e-10, 1.215e-10, 1.281e-10, 1.394e-10, 1.5790000000000002e-10, 1.866e-10, 2.3660000000000004e-10, 3.1850000000000004e-10}, {1.39e-10, 1.4240000000000002e-10, 1.488e-10, 1.601e-10, 1.7890000000000002e-10, 2.0870000000000001e-10, 2.606e-10, 3.4630000000000003e-10}, {1.779e-10, 1.813e-10, 1.8780000000000001e-10, 1.9910000000000002e-10, 2.181e-10, 2.49e-10, 3.03e-10, 3.938e-10}}; +double lookTrAxis_XOR2_X1_B_Z_fallingDelay(int iTr) {return trAxis_XOR2_X1_B_Z_fallingDelay[iTr];} +double lookCapAxis_XOR2_X1_B_Z_fallingDelay(int iCap) {return capAxis_XOR2_X1_B_Z_fallingDelay[iCap];} +double lookTable_XOR2_X1_B_Z_fallingDelay(int iTr, int iCap) {return table_XOR2_X1_B_Z_fallingDelay[iCap][iTr];} + +double trAxis_XOR2_X1_B_Z_risingTransition[8] = {7.5e-12, 1.5e-11, 3.0e-11, 6.0e-11, 1.2e-10, 2.4e-10, 4.8e-10, 9.6e-10}; +double capAxis_XOR2_X1_B_Z_risingTransition[6] = {4.0e-16, 8.0e-16, 1.6e-15, 3.2e-15, 6.4e-15, 1.28e-14}; +double table_XOR2_X1_B_Z_risingTransition[6][8] = {{5.0600000000000005e-11, 5.0600000000000005e-11, 5.0500000000000007e-11, 5.04e-11, 6.01e-11, 7.93e-11, 1.08e-10, 1.545e-10}, {5.680000000000001e-11, 5.680000000000001e-11, 5.680000000000001e-11, 5.64e-11, 6.500000000000001e-11, 8.58e-11, 1.1590000000000001e-10, 1.6380000000000002e-10}, {6.940000000000001e-11, 6.940000000000001e-11, 6.940000000000001e-11, 6.89e-11, 7.49e-11, 9.750000000000001e-11, 1.308e-10, 1.8210000000000002e-10}, {9.400000000000001e-11, 9.400000000000001e-11, 9.400000000000001e-11, 9.390000000000001e-11, 9.610000000000001e-11, 1.1830000000000002e-10, 1.5740000000000002e-10, 2.15e-10}, {1.4290000000000002e-10, 1.4290000000000002e-10, 1.4290000000000002e-10, 1.4280000000000001e-10, 1.426e-10, 1.56e-10, 2.032e-10, 2.731e-10}, {2.405e-10, 2.405e-10, 2.405e-10, 2.405e-10, 2.405e-10, 2.416e-10, 2.7950000000000007e-10, 3.7090000000000003e-10}}; +double lookTrAxis_XOR2_X1_B_Z_risingTransition(int iTr) {return trAxis_XOR2_X1_B_Z_risingTransition[iTr];} +double lookCapAxis_XOR2_X1_B_Z_risingTransition(int iCap) {return capAxis_XOR2_X1_B_Z_risingTransition[iCap];} +double lookTable_XOR2_X1_B_Z_risingTransition(int iTr, int iCap) {return table_XOR2_X1_B_Z_risingTransition[iCap][iTr];} + +double trAxis_XOR2_X1_B_Z_fallingTransition[8] = {7.5e-12, 1.5e-11, 3.0e-11, 6.0e-11, 1.2e-10, 2.4e-10, 4.8e-10, 9.6e-10}; +double capAxis_XOR2_X1_B_Z_fallingTransition[6] = {4.0e-16, 8.0e-16, 1.6e-15, 3.2e-15, 6.4e-15, 1.28e-14}; +double table_XOR2_X1_B_Z_fallingTransition[6][8] = {{2.46e-11, 2.46e-11, 2.46e-11, 2.4700000000000003e-11, 2.76e-11, 4.33e-11, 7.1e-11, 1.167e-10}, {2.66e-11, 2.66e-11, 2.66e-11, 2.6700000000000002e-11, 2.9700000000000005e-11, 4.5800000000000006e-11, 7.39e-11, 1.211e-10}, {3.06e-11, 3.06e-11, 3.06e-11, 3.07e-11, 3.39e-11, 5.0500000000000007e-11, 7.97e-11, 1.289e-10}, {3.860000000000001e-11, 3.860000000000001e-11, 3.85e-11, 3.860000000000001e-11, 4.1500000000000005e-11, 5.87e-11, 8.99e-11, 1.431e-10}, {5.390000000000001e-11, 5.390000000000001e-11, 5.390000000000001e-11, 5.390000000000001e-11, 5.7000000000000003e-11, 7.4e-11, 1.0770000000000001e-10, 1.667e-10}, {8.730000000000001e-11, 8.730000000000001e-11, 8.720000000000001e-11, 8.730000000000001e-11, 8.95e-11, 1.043e-10, 1.3910000000000002e-10, 2.05e-10}}; +double lookTrAxis_XOR2_X1_B_Z_fallingTransition(int iTr) {return trAxis_XOR2_X1_B_Z_fallingTransition[iTr];} +double lookCapAxis_XOR2_X1_B_Z_fallingTransition(int iCap) {return capAxis_XOR2_X1_B_Z_fallingTransition[iCap];} +double lookTable_XOR2_X1_B_Z_fallingTransition(int iTr, int iCap) {return table_XOR2_X1_B_Z_fallingTransition[iCap][iTr];} + +double trAxis_XOR2_X2_A_Z_risingDelay[8] = {7.5e-12, 1.5e-11, 3.0e-11, 6.0e-11, 1.2e-10, 2.4e-10, 4.8e-10, 9.6e-10}; +double capAxis_XOR2_X2_A_Z_risingDelay[6] = {4.0e-16, 1.6e-15, 3.2e-15, 6.4e-15, 1.28e-14, 2.56e-14}; +double table_XOR2_X2_A_Z_risingDelay[6][8] = {{8.57e-11, 8.890000000000001e-11, 9.47e-11, 1.027e-10, 1.1010000000000001e-10, 1.1500000000000002e-10, 1.593e-10, 2.456e-10}, {9.54e-11, 9.87e-11, 1.046e-10, 1.127e-10, 1.204e-10, 1.2559999999999999e-10, 1.8060000000000003e-10, 2.718e-10}, {1.0840000000000001e-10, 1.117e-10, 1.176e-10, 1.2590000000000003e-10, 1.341e-10, 1.46e-10, 2.057e-10, 3.0380000000000003e-10}, {1.341e-10, 1.373e-10, 1.433e-10, 1.517e-10, 1.606e-10, 1.824e-10, 2.51e-10, 3.6020000000000006e-10}, {1.8540000000000003e-10, 1.8870000000000003e-10, 1.9470000000000004e-10, 2.033e-10, 2.124e-10, 2.442e-10, 3.2910000000000003e-10, 4.574e-10}, {2.884e-10, 2.918e-10, 2.9790000000000003e-10, 3.066e-10, 3.1600000000000005e-10, 3.47e-10, 4.5900000000000007e-10, 6.208000000000001e-10}}; +double lookTrAxis_XOR2_X2_A_Z_risingDelay(int iTr) {return trAxis_XOR2_X2_A_Z_risingDelay[iTr];} +double lookCapAxis_XOR2_X2_A_Z_risingDelay(int iCap) {return capAxis_XOR2_X2_A_Z_risingDelay[iCap];} +double lookTable_XOR2_X2_A_Z_risingDelay(int iTr, int iCap) {return table_XOR2_X2_A_Z_risingDelay[iCap][iTr];} + +double trAxis_XOR2_X2_A_Z_fallingDelay[8] = {7.5e-12, 1.5e-11, 3.0e-11, 6.0e-11, 1.2e-10, 2.4e-10, 4.8e-10, 9.6e-10}; +double capAxis_XOR2_X2_A_Z_fallingDelay[6] = {4.0e-16, 1.6e-15, 3.2e-15, 6.4e-15, 1.28e-14, 2.56e-14}; +double table_XOR2_X2_A_Z_fallingDelay[6][8] = {{7.79e-11, 8.110000000000001e-11, 8.8e-11, 1.027e-10, 1.27e-10, 1.619e-10, 2.16e-10, 3.0320000000000005e-10}, {8.27e-11, 8.58e-11, 9.29e-11, 1.0760000000000001e-10, 1.32e-10, 1.6750000000000002e-10, 2.224e-10, 3.112e-10}, {8.87e-11, 9.19e-11, 9.89e-11, 1.1360000000000001e-10, 1.384e-10, 1.745e-10, 2.304e-10, 3.2029999999999997e-10}, {1.0000000000000002e-10, 1.032e-10, 1.104e-10, 1.249e-10, 1.5010000000000003e-10, 1.867e-10, 2.442e-10, 3.3710000000000006e-10}, {1.206e-10, 1.239e-10, 1.311e-10, 1.4560000000000002e-10, 1.7120000000000001e-10, 2.0870000000000001e-10, 2.678e-10, 3.651e-10}, {1.5890000000000001e-10, 1.6220000000000002e-10, 1.6930000000000003e-10, 1.838e-10, 2.095e-10, 2.4790000000000004e-10, 3.0880000000000006e-10, 4.1110000000000006e-10}}; +double lookTrAxis_XOR2_X2_A_Z_fallingDelay(int iTr) {return trAxis_XOR2_X2_A_Z_fallingDelay[iTr];} +double lookCapAxis_XOR2_X2_A_Z_fallingDelay(int iCap) {return capAxis_XOR2_X2_A_Z_fallingDelay[iCap];} +double lookTable_XOR2_X2_A_Z_fallingDelay(int iTr, int iCap) {return table_XOR2_X2_A_Z_fallingDelay[iCap][iTr];} + +double trAxis_XOR2_X2_A_Z_risingTransition[8] = {7.5e-12, 1.5e-11, 3.0e-11, 6.0e-11, 1.2e-10, 2.4e-10, 4.8e-10, 9.6e-10}; +double capAxis_XOR2_X2_A_Z_risingTransition[6] = {4.0e-16, 1.6e-15, 3.2e-15, 6.4e-15, 1.28e-14, 2.56e-14}; +double table_XOR2_X2_A_Z_risingTransition[6][8] = {{3.69e-11, 3.69e-11, 3.69e-11, 3.69e-11, 4.56e-11, 6.260000000000001e-11, 9.3e-11, 1.4940000000000002e-10}, {4.6e-11, 4.6e-11, 4.6e-11, 4.6e-11, 5.360000000000001e-11, 7.230000000000001e-11, 1.038e-10, 1.613e-10}, {5.8100000000000005e-11, 5.8100000000000005e-11, 5.8100000000000005e-11, 5.8100000000000005e-11, 6.370000000000001e-11, 8.45e-11, 1.1770000000000002e-10, 1.77e-10}, {8.21e-11, 8.22e-11, 8.21e-11, 8.21e-11, 8.15e-11, 1.059e-10, 1.4340000000000002e-10, 2.0630000000000003e-10}, {1.3000000000000002e-10, 1.2989999999999999e-10, 1.2989999999999999e-10, 1.2989999999999999e-10, 1.3000000000000002e-10, 1.425e-10, 1.8920000000000003e-10, 2.602e-10}, {2.2520000000000003e-10, 2.2520000000000003e-10, 2.2520000000000003e-10, 2.2520000000000003e-10, 2.2520000000000003e-10, 2.241e-10, 2.653e-10, 3.5510000000000005e-10}}; +double lookTrAxis_XOR2_X2_A_Z_risingTransition(int iTr) {return trAxis_XOR2_X2_A_Z_risingTransition[iTr];} +double lookCapAxis_XOR2_X2_A_Z_risingTransition(int iCap) {return capAxis_XOR2_X2_A_Z_risingTransition[iCap];} +double lookTable_XOR2_X2_A_Z_risingTransition(int iTr, int iCap) {return table_XOR2_X2_A_Z_risingTransition[iCap][iTr];} + +double trAxis_XOR2_X2_A_Z_fallingTransition[8] = {7.5e-12, 1.5e-11, 3.0e-11, 6.0e-11, 1.2e-10, 2.4e-10, 4.8e-10, 9.6e-10}; +double capAxis_XOR2_X2_A_Z_fallingTransition[6] = {4.0e-16, 1.6e-15, 3.2e-15, 6.4e-15, 1.28e-14, 2.56e-14}; +double table_XOR2_X2_A_Z_fallingTransition[6][8] = {{2.15e-11, 2.1400000000000002e-11, 2.1400000000000002e-11, 2.1600000000000002e-11, 3.17e-11, 5.1e-11, 8.490000000000001e-11, 1.4610000000000002e-10}, {2.4500000000000003e-11, 2.4500000000000003e-11, 2.4500000000000003e-11, 2.46e-11, 3.5600000000000005e-11, 5.600000000000001e-11, 9.17e-11, 1.5520000000000002e-10}, {2.8500000000000002e-11, 2.8400000000000003e-11, 2.8400000000000003e-11, 2.8500000000000002e-11, 4.05e-11, 6.210000000000001e-11, 9.97e-11, 1.661e-10}, {3.6100000000000003e-11, 3.6100000000000003e-11, 3.6100000000000003e-11, 3.620000000000001e-11, 4.86e-11, 7.240000000000002e-11, 1.134e-10, 1.8470000000000002e-10}, {5.0700000000000003e-11, 5.0700000000000003e-11, 5.0700000000000003e-11, 5.0700000000000003e-11, 6.25e-11, 9.0e-11, 1.358e-10, 2.1490000000000003e-10}, {8.27e-11, 8.27e-11, 8.27e-11, 8.27e-11, 8.860000000000001e-11, 1.192e-10, 1.726e-10, 2.623e-10}}; +double lookTrAxis_XOR2_X2_A_Z_fallingTransition(int iTr) {return trAxis_XOR2_X2_A_Z_fallingTransition[iTr];} +double lookCapAxis_XOR2_X2_A_Z_fallingTransition(int iCap) {return capAxis_XOR2_X2_A_Z_fallingTransition[iCap];} +double lookTable_XOR2_X2_A_Z_fallingTransition(int iTr, int iCap) {return table_XOR2_X2_A_Z_fallingTransition[iCap][iTr];} + +double trAxis_XOR2_X2_B_Z_risingDelay[8] = {7.5e-12, 1.5e-11, 3.0e-11, 6.0e-11, 1.2e-10, 2.4e-10, 4.8e-10, 9.6e-10}; +double capAxis_XOR2_X2_B_Z_risingDelay[6] = {4.0e-16, 1.6e-15, 3.2e-15, 6.4e-15, 1.28e-14, 2.56e-14}; +double table_XOR2_X2_B_Z_risingDelay[6][8] = {{8.000000000000001e-11, 8.33e-11, 9.0e-11, 1.0090000000000001e-10, 1.139e-10, 1.334e-10, 1.9220000000000002e-10, 2.933e-10}, {9.0e-11, 9.320000000000001e-11, 1.0000000000000002e-10, 1.109e-10, 1.238e-10, 1.483e-10, 2.1140000000000001e-10, 3.166e-10}, {1.031e-10, 1.0650000000000001e-10, 1.1310000000000002e-10, 1.2410000000000002e-10, 1.3700000000000002e-10, 1.6700000000000002e-10, 2.343e-10, 3.4560000000000003e-10}, {1.2920000000000003e-10, 1.326e-10, 1.389e-10, 1.5e-10, 1.63e-10, 2.009e-10, 2.7670000000000004e-10, 3.9770000000000003e-10}, {1.8090000000000002e-10, 1.8440000000000003e-10, 1.906e-10, 2.0180000000000002e-10, 2.1470000000000002e-10, 2.5950000000000003e-10, 3.51e-10, 4.894e-10}, {2.843e-10, 2.8770000000000005e-10, 2.941e-10, 3.053e-10, 3.1830000000000003e-10, 3.605e-10, 4.764e-10, 6.471000000000001e-10}}; +double lookTrAxis_XOR2_X2_B_Z_risingDelay(int iTr) {return trAxis_XOR2_X2_B_Z_risingDelay[iTr];} +double lookCapAxis_XOR2_X2_B_Z_risingDelay(int iCap) {return capAxis_XOR2_X2_B_Z_risingDelay[iCap];} +double lookTable_XOR2_X2_B_Z_risingDelay(int iTr, int iCap) {return table_XOR2_X2_B_Z_risingDelay[iCap][iTr];} + +double trAxis_XOR2_X2_B_Z_fallingDelay[8] = {7.5e-12, 1.5e-11, 3.0e-11, 6.0e-11, 1.2e-10, 2.4e-10, 4.8e-10, 9.6e-10}; +double capAxis_XOR2_X2_B_Z_fallingDelay[6] = {4.0e-16, 1.6e-15, 3.2e-15, 6.4e-15, 1.28e-14, 2.56e-14}; +double table_XOR2_X2_B_Z_fallingDelay[6][8] = {{9.900000000000001e-11, 1.027e-10, 1.0900000000000001e-10, 1.201e-10, 1.3860000000000002e-10, 1.668e-10, 2.1520000000000002e-10, 2.9490000000000004e-10}, {1.038e-10, 1.075e-10, 1.1380000000000001e-10, 1.249e-10, 1.437e-10, 1.7240000000000002e-10, 2.215e-10, 3.024e-10}, {1.098e-10, 1.134e-10, 1.1990000000000002e-10, 1.31e-10, 1.5010000000000003e-10, 1.7940000000000002e-10, 2.2960000000000001e-10, 3.1130000000000005e-10}, {1.21e-10, 1.245e-10, 1.31e-10, 1.4240000000000002e-10, 1.6160000000000002e-10, 1.918e-10, 2.432e-10, 3.277e-10}, {1.417e-10, 1.4510000000000002e-10, 1.5160000000000002e-10, 1.631e-10, 1.8260000000000002e-10, 2.1410000000000002e-10, 2.675e-10, 3.552e-10}, {1.798e-10, 1.8320000000000002e-10, 1.8970000000000003e-10, 2.0120000000000001e-10, 2.2090000000000003e-10, 2.536e-10, 3.092e-10, 4.0200000000000006e-10}}; +double lookTrAxis_XOR2_X2_B_Z_fallingDelay(int iTr) {return trAxis_XOR2_X2_B_Z_fallingDelay[iTr];} +double lookCapAxis_XOR2_X2_B_Z_fallingDelay(int iCap) {return capAxis_XOR2_X2_B_Z_fallingDelay[iCap];} +double lookTable_XOR2_X2_B_Z_fallingDelay(int iTr, int iCap) {return table_XOR2_X2_B_Z_fallingDelay[iCap][iTr];} + +double trAxis_XOR2_X2_B_Z_risingTransition[8] = {7.5e-12, 1.5e-11, 3.0e-11, 6.0e-11, 1.2e-10, 2.4e-10, 4.8e-10, 9.6e-10}; +double capAxis_XOR2_X2_B_Z_risingTransition[6] = {4.0e-16, 1.6e-15, 3.2e-15, 6.4e-15, 1.28e-14, 2.56e-14}; +double table_XOR2_X2_B_Z_risingTransition[6][8] = {{3.6800000000000005e-11, 3.6700000000000006e-11, 3.63e-11, 3.85e-11, 4.9400000000000005e-11, 6.59e-11, 9.130000000000001e-11, 1.3480000000000002e-10}, {4.6e-11, 4.6e-11, 4.5800000000000006e-11, 4.6600000000000006e-11, 5.73e-11, 7.600000000000001e-11, 1.037e-10, 1.4990000000000002e-10}, {5.83e-11, 5.83e-11, 5.8200000000000003e-11, 5.8100000000000005e-11, 6.690000000000001e-11, 8.82e-11, 1.191e-10, 1.685e-10}, {8.22e-11, 8.22e-11, 8.23e-11, 8.22e-11, 8.63e-11, 1.097e-10, 1.4630000000000003e-10, 2.017e-10}, {1.3000000000000002e-10, 1.3000000000000002e-10, 1.2989999999999999e-10, 1.2989999999999999e-10, 1.3000000000000002e-10, 1.465e-10, 1.9280000000000002e-10, 2.5990000000000005e-10}, {2.2520000000000003e-10, 2.2520000000000003e-10, 2.2520000000000003e-10, 2.2520000000000003e-10, 2.2520000000000003e-10, 2.2750000000000002e-10, 2.6889999999999997e-10, 3.576e-10}}; +double lookTrAxis_XOR2_X2_B_Z_risingTransition(int iTr) {return trAxis_XOR2_X2_B_Z_risingTransition[iTr];} +double lookCapAxis_XOR2_X2_B_Z_risingTransition(int iCap) {return capAxis_XOR2_X2_B_Z_risingTransition[iCap];} +double lookTable_XOR2_X2_B_Z_risingTransition(int iTr, int iCap) {return table_XOR2_X2_B_Z_risingTransition[iCap][iTr];} + +double trAxis_XOR2_X2_B_Z_fallingTransition[8] = {7.5e-12, 1.5e-11, 3.0e-11, 6.0e-11, 1.2e-10, 2.4e-10, 4.8e-10, 9.6e-10}; +double capAxis_XOR2_X2_B_Z_fallingTransition[6] = {4.0e-16, 1.6e-15, 3.2e-15, 6.4e-15, 1.28e-14, 2.56e-14}; +double table_XOR2_X2_B_Z_fallingTransition[6][8] = {{2.1200000000000002e-11, 2.1200000000000002e-11, 2.1200000000000002e-11, 2.13e-11, 2.4100000000000003e-11, 3.9e-11, 6.44e-11, 1.0680000000000001e-10}, {2.43e-11, 2.43e-11, 2.43e-11, 2.4400000000000004e-11, 2.7300000000000002e-11, 4.2800000000000003e-11, 6.940000000000001e-11, 1.139e-10}, {2.8300000000000002e-11, 2.8300000000000002e-11, 2.8300000000000002e-11, 2.8300000000000002e-11, 3.1300000000000004e-11, 4.760000000000001e-11, 7.56e-11, 1.2250000000000002e-10}, {3.5900000000000007e-11, 3.6e-11, 3.6e-11, 3.6e-11, 3.9e-11, 5.600000000000001e-11, 8.63e-11, 1.3750000000000002e-10}, {5.0600000000000005e-11, 5.0600000000000005e-11, 5.0600000000000005e-11, 5.0600000000000005e-11, 5.4e-11, 7.11e-11, 1.0440000000000001e-10, 1.618e-10}, {8.27e-11, 8.27e-11, 8.27e-11, 8.27e-11, 8.550000000000001e-11, 1.007e-10, 1.354e-10, 2.0050000000000003e-10}}; +double lookTrAxis_XOR2_X2_B_Z_fallingTransition(int iTr) {return trAxis_XOR2_X2_B_Z_fallingTransition[iTr];} +double lookCapAxis_XOR2_X2_B_Z_fallingTransition(int iCap) {return capAxis_XOR2_X2_B_Z_fallingTransition[iCap];} +double lookTable_XOR2_X2_B_Z_fallingTransition(int iTr, int iCap) {return table_XOR2_X2_B_Z_fallingTransition[iCap][iTr];} + diff --git a/Libs/Simple130nm/Lava.hs b/Libs/Simple130nm/Lava.hs deleted file mode 100644 --- a/Libs/Simple130nm/Lava.hs +++ /dev/null @@ -1,133 +0,0 @@ -{-# OPTIONS_GHC -fno-warn-missing-fields #-} - -module Libs.Simple130nm.Lava where - - - -import Data.Hardware.Internal -import Lava.Internal -import Lava - -import qualified Lava2000 as L -import qualified Lava2000.Arithmetic as L - - - -data Simple130nm - = IVHSP - | AN2HSP - | OR2HSP - | HA1HSP - | FA1HSP - deriving (Eq, Show) - - - -instance CellLibrary Simple130nm - where - numConsts _ = 2 - - numIns IVHSP = 1 - numIns AN2HSP = 2 - numIns OR2HSP = 2 - numIns HA1HSP = 2 - numIns FA1HSP = 2 - - numOuts IVHSP = 1 - numOuts AN2HSP = 1 - numOuts OR2HSP = 1 - numOuts HA1HSP = 2 - numOuts FA1HSP = 2 - - - - pinName IVHSP 0 = "Z" - pinName IVHSP 1 = "A" - - pinName AN2HSP 0 = "Z" - pinName AN2HSP 1 = "A" - pinName AN2HSP 2 = "B" - - pinName OR2HSP 0 = "Z" - pinName OR2HSP 1 = "A" - pinName OR2HSP 2 = "B" - - pinName HA1HSP 0 = "S" - pinName HA1HSP 1 = "CO" - pinName HA1HSP 2 = "A" - pinName HA1HSP 3 = "B" - - pinName FA1HSP 0 = "Z" - pinName FA1HSP 1 = "CO" - pinName FA1HSP 2 = "A" - pinName FA1HSP 3 = "B" - pinName FA1HSP 4 = "CI" - - - - pinId IVHSP "Z" = 0 - pinId IVHSP "A" = 1 - - pinId AN2HSP "Z" = 0 - pinId AN2HSP "A" = 1 - pinId AN2HSP "B" = 2 - - pinId OR2HSP "Z" = 0 - pinId OR2HSP "A" = 1 - pinId OR2HSP "B" = 2 - - pinId HA1HSP "S" = 0 - pinId HA1HSP "CO" = 1 - pinId HA1HSP "A" = 2 - pinId HA1HSP "B" = 3 - - pinId FA1HSP "Z" = 0 - pinId FA1HSP "CO" = 1 - pinId FA1HSP "A" = 2 - pinId FA1HSP "B" = 3 - pinId FA1HSP "CI" = 4 - - - - isFlop = const False - - lava2000Interp = Interp - { constants = [L.low, L.high] - , defaultVal = error "Undefined signal" - , propagator = prop - } - where - prop IVHSP = \[_,a] -> [Just (L.inv a), Nothing] - - prop AN2HSP = \[_,a,b] -> [Just (L.and2 (a,b)), Nothing, Nothing] - - prop OR2HSP = \[_,a,b] -> [Just (L.or2 (a,b)), Nothing, Nothing] - - prop HA1HSP = \[_,_,a,b] -> - let (s,co) = L.halfAdd (a,b) - in [Just s, Just co, Nothing, Nothing] - - prop FA1HSP = \[_,_,a,b,ci] -> - let (s,co) = L.fullAdd (a,(b,ci)) - in [Just s, Just co, Nothing, Nothing] - - - -low,high :: Signal -[low,high] = libraryConstants (T::TypeOf Simple130nm) - -inv :: MonadLava Simple130nm m => Signal -> m Signal -inv = cell IVHSP - -and2 :: MonadLava Simple130nm m => (Signal,Signal) -> m Signal -and2 = cell AN2HSP - -or2 :: MonadLava Simple130nm m => (Signal,Signal) -> m Signal -or2 = cell OR2HSP - -halfAdd :: MonadLava Simple130nm m => (Signal,Signal) -> m (Signal,Signal) -halfAdd = cell HA1HSP - -fullAdd :: MonadLava Simple130nm m => (Signal, (Signal,Signal)) -> m (Signal,Signal) -fullAdd = cell FA1HSP - diff --git a/Libs/Simple130nm/Wired.hs b/Libs/Simple130nm/Wired.hs deleted file mode 100644 --- a/Libs/Simple130nm/Wired.hs +++ /dev/null @@ -1,96 +0,0 @@ -module Libs.Simple130nm.Wired - ( Simple130nm (..) - , low - , high - , rowHeight - , guideN - , guideS - , guideW - , guideE - , Libs.Simple130nm.Wired.and2 - , Libs.Simple130nm.Wired.halfAdd - , Libs.Simple130nm.Wired.fullAdd - ) where - - - -import Data.Hardware.Internal -import Lava -import Wired.Model -import Wired -import Libs.Simple130nm.Lava as Lava - - - -instance WiredLibrary Simple130nm - where - lambda = const 65 - - - -rowHeight :: Height -rowHeight = 4920 - -guideLength :: Length -guideLength = 600 -- To satisfy minimum area of metal segments - - - -guide_ - :: PortStruct p Signal t - => Direction -> Layer -> Width -> (p -> Wired Simple130nm p) - -guide_ dir lay pitch - - | lay >= 6 = error - "Libs.Simple130nm.Wired.guide_: Only supporting layers 1-5" - -- Because layer 6 has different properties. - - | lay==1 = guide dir guideLength 1 pitch - - | Vertical <- directionAngle dir, odd lay = error $ - "Layer " ++ show (toInt lay) ++ " doesn't support vertical wires" - - | Horizontal <- directionAngle dir, even lay = error $ - "Layer " ++ show (toInt lay) ++ " doesn't support horizontal wires" - - | otherwise = guide dir guideLength lay pitch - - - -guideN, guideS, guideW, guideE - :: PortStruct p Signal t => Layer -> Width -> (p -> Wired Simple130nm p) - -guideN = guide_ Upwards -guideS = guide_ Downwards -guideW = guide_ Leftwards -guideE = guide_ Rightwards - - - -and2 :: (Signal,Signal) -> Wired Simple130nm Signal -and2 (a,b) = stacked $ do - guidePos Rightwards 0 1 (1000,2665) a - guidePos Rightwards 0 1 (1200,2255) b - mkCell "AN2HSP" 2050 4920 $ Lava.and2 (a,b) - >>= guidePos Rightwards 0 1 (200,1400) - -halfAdd :: (Signal,Signal) -> Wired Simple130nm (Signal,Signal) -halfAdd (a,b) = stacked $ do - guidePos Rightwards 0 1 (1345,3895) a - guidePos Rightwards 0 1 (1310,2255) b - (s,co) <- mkCell "HA1HSP" 4510 4920 $ Lava.halfAdd (a,b) - guidePos Rightwards 0 1 (4265,1500) s - guidePos Rightwards 0 1 (205,1500) co - return (s,co) - -fullAdd :: (Signal,(Signal,Signal)) -> Wired Simple130nm (Signal,Signal) -fullAdd (ci,(a,b)) = stacked $ do - guidePos Rightwards 0 1 (1310,2255) ci - guidePos Rightwards 0 1 (3800,2255) a - guidePos Rightwards 0 1 (1500,2665) b - (z,co) <- mkCell "FA1HSP" 7790 4920 $ Lava.fullAdd (ci,(a,b)) - guidePos Rightwards 0 1 (7560,1500) z - guidePos Rightwards 0 1 (205,1500) co - return (z,co) - diff --git a/Wired.cabal b/Wired.cabal --- a/Wired.cabal +++ b/Wired.cabal @@ -1,22 +1,66 @@ -name: Wired -version: 0.1.1 -homepage: http://www.cs.chalmers.se/~emax/wired/ -synopsis: Wire-aware hardware description +name: Wired +version: 0.2 +homepage: http://www.cs.chalmers.se/~emax/wired/ +synopsis: Wire-aware hardware description -description: An extension to the hardware description library Lava - targeting (not exclusively) semi-custom VLSI design. A - particular aim of Wired is to give the designer more - control over the routing wires' effects on performance. +description: + Wired is an extension to the hardware description library Lava targeting (not + exclusively) semi-custom VLSI design. A particular aim of Wired is to give the + designer more control over the routing wires' effects on performance. + . + The goal is a system with the following features: + . + * Convenient circuit description in monadic style. + . + * Layout/wiring expressed using optional annotations, allowing incremental + specification of physical aspects. + . + * Export designs to several formats: + . + (1) Lava (for e.g. verification) + . + (2) Postscript (for visualizing layout and wiring) + . + (3) Design Exchange Format (for interfacing to standard CAD tools) + . + * Accurate, wire-aware timing/power analysis within the system. + . + * Support for modern standard cell libraries. + . + * Automatic compilation of standard cell libraries. + . + We are not very far from this goal. The missing parts are power analysis and + cell library compilation, and sequential circuits are not yet fully supported. + Also, there is virtually no documentation. The best place to look for guidance + is in the @Examples@ directory. The following thesis + gives more + information about the background and some explanation of programming + techniques used in Wired. It should also be said that the library is still + quite unstable and has not yet been tested in any larger scale. + . + The standard cell library shipped with Wired ("Libs.Nangate45.Wired") is an + open-source 45nm library from Nangate () provided for + the purposes of testing and exploring EDA flows. It is not intended for + fabrication. More information is given in the license agreement + in "Libs.Nangate45.LICENSE". If anyone is interested in real cell libraries + (currently 130nm, 90nm and 65nm from STM), please contact the maintainer of + the Wired library. + . + Currently, Wired contains its own version of Lava which is a bit different + from the standard version (package @chalmers-lava2000@ on Hackage) To make + things more complicated, this version of Lava actually uses the standard + version for simulation and verification. Ideally there should only be /one/ + Lava library, independent of the Wired package. Hopefully, this will happen in + a not too distant future. -category: Hardware -license: BSD3 -license-file: LICENSE -copyright: (c) 2008. Emil Axelsson -author: Emil Axelsson -maintainer: Emil Axelsson -cabal-version: >= 1.2 -build-type: Simple -tested-with: GHC ==6.8.3 +category: Language, Hardware +license: BSD3 +license-file: LICENSE +copyright: (c) 2008. Emil Axelsson +author: Emil Axelsson +maintainer: Emil Axelsson +cabal-version: >= 1.2.3 +build-type: Simple data-files: .ghci @@ -29,33 +73,41 @@ exposed-modules: Data.Logical.Knot Data.Logical.Let + Data.Hardware.Internal + Data.Hardware + Lava.Patterns + Lava.Internal Lava + Layout.Internal Layout + Wired.Model Wired - Analysis.STA - Libs.Simple130nm.Lava - Libs.Simple130nm.Wired + Analysis.Timing.Library + Analysis.Timing + Export.DEF + Libs.Nangate45.LICENSE + Libs.Nangate45.Lava + Libs.Nangate45.Wired other-modules: - Data.Hardware.Internal - Data.Hardware Lava.Model - Lava.Patterns Lava.Loop Lava.Port Lava.Interpret - Lava.Internal + Lava.Misc Layout.Floorplan Layout.Postscript - Layout.Internal - Wired.Model - Analysis.STA.Library + Libs.Nangate45.Timing + c-sources: + Libs/Nangate45/timing.c + build-Depends: base, chalmers-lava2000, containers, mtl, QuickCheck extensions: FlexibleContexts FlexibleInstances + ForeignFunctionInterface FunctionalDependencies GeneralizedNewtypeDeriving MultiParamTypeClasses diff --git a/Wired.hs b/Wired.hs --- a/Wired.hs +++ b/Wired.hs @@ -3,9 +3,12 @@ , module Lava , module Layout , Wired - , stripLayout + , WiredLibrary (..) , renderWired + , renderWiredWithNetsCol , renderWiredWithNets + , wireN, wireS, wireW, wireE + , guide, guideN, guideS, guideW, guideE ) where diff --git a/Wired/Model.hs b/Wired/Model.hs --- a/Wired/Model.hs +++ b/Wired/Model.hs @@ -19,10 +19,19 @@ class CellLibrary lib => WiredLibrary lib where - lambda :: TypeOf lib -> Length + featureSize :: Res lib Length -- Half feature size -type Guide = (Signal, Layer, Direction, Length) + guideLength :: Layer -> Res lib Length + -- Minimal guide length + + rowHeight :: Res lib Height + + -- XXX Put more design rule information here (e.g. which rows are flipped)? + + + +type Guide = (Signal, Layer_, Direction, Length) -- A roting guide associated with a signal. type Wired lib = LayoutT Guide CellId (Lava lib) @@ -46,14 +55,9 @@ :: CellLibrary lib => Wired lib a -> (a, (DesignDB lib, Floorplan Guide CellId)) -runWired w = (a,(ds,fp)) +runWired w = (a,(db,fp)) where - ((a,fp),ds) = runLava $ runLayoutT w - - - -stripLayout :: MonadLava lib m => LayoutT s b m a -> m a -stripLayout = liftM fst . runLayoutT + ((a,fp),db) = runLava $ runLayoutT w @@ -70,28 +74,37 @@ tell fps return (a,decls) + toLava = toLava . liftM fst . runLayoutT + +instance Value Length + where + value (Length l) = fromIntegral l * 1e-10 + -- Distance is currently represented in units of 0.1nm. + + + convertGuide :: (Position, AbsBlock Guide CellId) - -> (Signal, (Layer,Position,Position)) + -> (Signal, (Layer_,Position,Position)) convertGuide bl = (sig,(lay,pos1,pos2)) where - ((x,y), Space _ (Just (sig,lay,dir,len))) = bl + (_, Space _ (Just (sig,lay,dir,len))) = bl - pos1 = blockCenter bl + pos1@(x,y) = blockCenter bl pos2 = case dir of - Rightwards -> (x + icast len, y) - Leftwards -> (x - icast len, y) - Upwards -> (x, y + icast len) - Downwards -> (x, y - icast len) + Rightwards -> (x+len, y) + Leftwards -> (x+len, y) + Upwards -> (x, y-len) + Downwards -> (x, y-len) mkGuideDB - :: Floorplan Guide CellId -> Map Signal [(Layer,Position,Position)] + :: Floorplan Guide CellId -> Map Signal [(Layer_,Position,Position)] mkGuideDB fp = Map.fromListWith (++) [ (sig,[g]) @@ -102,19 +115,24 @@ -renderWired :: forall lib a . WiredLibrary lib => String -> Wired lib a -> IO () -renderWired title w = renderFloorplan_ lam title fp [] +renderWired :: forall lib a . WiredLibrary lib => Name -> Wired lib a -> IO () +renderWired title w = renderFloorplan_ (feat`divLen`2) title fp [] where - lam = icast $ lambda (T::TypeOf lib) - fp = snd $ snd $ runWired w - -- Lambda is a reasonable scale for lines and names. + feat = result (featureSize :: Res lib Length) + fp = snd $ snd $ runWired w + -- feat/2 is a reasonable scale for lines and names. -fpToLines :: Floorplan Guide CellId -> [(Position,Position)] -fpToLines fp = concat - [ rectiSpanning [pos | (_,pos,_) <- guides] - | (_,guides) <- Map.toList $ mkGuideDB fp +fpToLines + :: (Signal -> Maybe Color) + -> Floorplan Guide CellId + -> [([(Position,Position)], Color)] +fpToLines sigCol fp = + [ (rectiSpanning [pos | (_,pos,_) <- guides], col) + | (sig,guides) <- Map.toList $ mkGuideDB fp + , Just col <- [sigCol sig] + , length guides >= 2 ] -- Returns the lines between the guides in the floorplan. Guides associated @@ -127,34 +145,89 @@ -renderWiredWithNets :: forall lib a . - WiredLibrary lib => String -> Wired lib a -> IO () +renderWiredWithNetsCol :: forall lib a . WiredLibrary lib => + Maybe Color -> (Tag -> Maybe Color) -> Name -> Wired lib a -> IO () -renderWiredWithNets title w = renderFloorplan_ lam title fp (fpToLines fp) +renderWiredWithNetsCol defaultCol tagCol title w = + renderFloorplan_ (feat`divLen`2) title fp (fpToLines sigCol fp) where - lam = icast $ lambda (T::TypeOf lib) - fp = snd $ snd $ runWired w + feat = result (featureSize :: Res lib Length) + (db,fp) = snd $ runWired w + sigCol sig = case totalLookup sig (sigTagDB db) of + t:_ -> tagCol t + _ -> defaultCol -guide +renderWiredWithNets :: forall lib a . + WiredLibrary lib => Name -> Wired lib a -> IO () +renderWiredWithNets = renderWiredWithNetsCol (Just black) (const Nothing) + + + +wire__ :: (MonadWired lib m, PortStruct p Signal t) + => Direction -> Length -> Layer_ -> Width -> (p -> m p) + +wire__ dir len lay pitch = mapPortM $ \sig -> do + space_ pitch (Just (sig,lay,dir,len)) + return sig + + + +wire_ + :: (MonadWired lib m, PortStruct p Signal t) => Direction -> Length -> Layer -> Width -> (p -> m p) -guide dir len lay pitch = mapPortM $ \sig -> do - space_ (icast pitch) (Just (sig,lay,dir,len)) +wire_ dir len lay wit = wire__ dir len (icast lay) wit + + + +wireN, wireS, wireW, wireE + :: (MonadWired lib m, PortStruct p Signal t) + => Length -> Layer -> Width -> (p -> m p) + +wireN = wire_ Upwards +wireS = wire_ Downwards +wireW = wire_ Leftwards +wireE = wire_ Rightwards + + + +guide__ :: forall lib m p t + . (MonadWired lib m, PortStruct p Signal t) + => Direction -> Layer_ -> Width -> (p -> m p) + +guide__ dir lay pitch = mapPortM $ \sig -> do + space_ + pitch + (Just (sig,lay,dir, result (guideLength (icast lay) :: Res lib Length))) return sig -guidePos +guide_ :: (MonadWired lib m, PortStruct p Signal t) - => Direction -> Length -> Layer -> Position -> (p -> m p) + => Direction -> Layer -> Width -> (p -> m p) -guidePos dir len lay (x,y) = translate x y . guide dir len lay 0 +guide_ dir lay pitch = guide__ dir (icast lay) pitch +guide, guideN, guideS, guideW, guideE + :: (MonadWired lib m, PortStruct p Signal t) + => Layer -> Width -> (p -> m p) + +-- | To be used when direction doesn't matter (e.g. when @guideLength = 0@). +guide = guide_ Downwards + +guideN = guide_ Upwards +guideS = guide_ Downwards +guideW = guide_ Leftwards +guideE = guide_ Rightwards + + + mkCell :: MonadWired lib m => Name @@ -166,46 +239,4 @@ mkCell nm x y ma = do (a, [Cell cid _ _]) <- listenDecls ma block x y nm cid a - - - -showOri :: IsString str => Orientation -> str -showOri (flipped,dir) = fromString $ - (if flipped then "F" else "") ++ showDir dir - where - showDir Rightwards = "E" - showDir Leftwards = "W" - showDir Upwards = "N" - showDir Downwards = "S" - - -- Uses the notion of orientation from the Cadence DEF format. - -- - -- .------, .------, - -- N: | #| FN: |# | - -- | #| |# | - -- | | | | - -- '------' '------' - -- - -- .------, .------, - -- S: | | FS: | | - -- |# | | #| - -- |# | | #| - -- '------' '------' - -- - -- .------, .------, - -- W: |### | FW: | ###| - -- | | | | - -- | | | | - -- '------' '------' - -- - -- .------, .------, - -- E: | | FE: | | - -- | | | | - -- | ###| |### | - -- '------' '------' - -- - -- So N is the standard orientation and S/W/E are rotations of the standard - -- orientation. FN/FS/FW/FE are simply flipped around the y-axis. - - -- *** Needed?