diff --git a/glsl.cabal b/glsl.cabal --- a/glsl.cabal +++ b/glsl.cabal @@ -1,5 +1,5 @@ name: glsl -version: 0.0.0.1 +version: 0.0.1.0 cabal-version: >= 1.10 build-type: Simple author: Pippijn van Steenhoven @@ -11,15 +11,21 @@ homepage: https://github.com/homectl/glsl synopsis: Parser and optimizer for a small subset of GLSL description: - Parser and optimizer for a small subset of GLSL. - - This package can parse a very small subset of GLSL, namely - exactly the subset emitted by GPipe-Core. It can evaluate the - code and return the computed result. This is useful for - debugging shaders generated by GPipe-Core. + Parser and optimizer for a small subset of GLSL. + . + This package can parse a very small subset of GLSL, namely exactly the subset + emitted by GPipe-Core. It can evaluate the code and return the computed + result. This is useful for debugging shaders generated by GPipe-Core. maintainer: Pippijn van Steenhoven data-files: CHANGELOG.md +extra-source-files: + test/data/large-shaders/lambdacnc.frag + test/data/large-shaders/lambdacnc.vert + test/data/large-shaders/small.vert + test/data/large-shaders/xax.frag + test/data/large-shaders/xax.vert + source-repository head type: git location: https://github.com/homectl/workspace @@ -29,22 +35,27 @@ default-language: Haskell2010 hs-source-dirs: src exposed-modules: + Language.GLSL.AST + Language.GLSL.BitCode Language.GLSL.ConstExpr Language.GLSL.Decls + Language.GLSL.Internal.Bits Language.GLSL.Optimizer.Deinline Language.GLSL.Optimizer.DFG Language.GLSL.Optimizer.FunctionGenerator Language.GLSL.Optimizer.Liveness Language.GLSL.Optimizer + Language.GLSL.Parser + Language.GLSL.PrettyPrint Language.GLSL.Runtime.Eval Language.GLSL.Runtime.Math Language.GLSL.Runtime.PrimFuns Language.GLSL.Runtime.Value Language.GLSL.StructuralEquality - Language.GLSL.Types build-depends: base >= 4.9 && < 5 , attoparsec >= 0.10 && < 0.15 + , binary >= 0.5 && < 0.11 , containers >= 0.5 && < 0.7 , fgl >= 5.3 && < 6 , graphviz >= 2999.10 && < 2999.21 @@ -62,9 +73,13 @@ type: exitcode-stdio-1.0 main-is: testsuite.hs other-modules: + Language.GLSL.BitCodeSpec + Language.GLSL.Internal.BitsSpec Language.GLSL.Optimizer.DeinlineSpec Language.GLSL.GLSLSpec + Language.GLSL.StructuralEqualitySpec Test.GLSL + Test.GLSL.Arbitrary ghc-options: -Wall -threaded @@ -72,11 +87,15 @@ hspec-discover:hspec-discover build-depends: base + , QuickCheck , attoparsec + , binary , bytestring + , directory , glsl , hspec , text + , vector executable optshader default-language: Haskell2010 diff --git a/src/Language/GLSL/AST.hs b/src/Language/GLSL/AST.hs new file mode 100644 --- /dev/null +++ b/src/Language/GLSL/AST.hs @@ -0,0 +1,243 @@ +{-# LANGUAGE DeriveFunctor #-} +{-# LANGUAGE DeriveGeneric #-} +{-# LANGUAGE DeriveTraversable #-} +{-# LANGUAGE OverloadedStrings #-} +{-# LANGUAGE StrictData #-} +module Language.GLSL.AST where + +import Control.Applicative (Applicative (..)) +import Data.Attoparsec.ByteString.Char8 (Parser) +import qualified Data.Text.Lazy.Builder as LTB +import GHC.Generics (Generic) + + +data GLSL a = GLSL Version [TopDecl a] + deriving (Generic, Show, Eq, Functor, Foldable, Traversable) + +newtype Version = Version Int + deriving (Generic, Show, Eq) + +data TopDecl a + = LayoutDecl LayoutSpec GlobalDecl + | GlobalDecl GlobalDecl + | ProcDecl ProcName [ParamDecl] [StmtAnnot a] + deriving (Generic, Show, Eq, Functor, Foldable, Traversable) + +data ProcName + = ProcMain + | ProcName NameId + deriving (Generic, Show, Eq) + +data LayoutSpec + = LayoutStd140 + | LayoutLocation Int + deriving (Generic, Show, Eq) + +data ParamDecl + = Param ParamKind LocalDecl + deriving (Generic, Show, Eq) + +data ParamKind + = PkIn + | PkOut + | PkInout + deriving (Generic, Show, Eq) + +data LocalDecl + = LDecl Type NameId (Maybe Expr) + deriving (Generic, Show, Eq) + +data GlobalDecl + = GDecl GDeclKind Type Name + deriving (Generic, Show, Eq) + +data GDeclKind + = GkIn + | GkOut + | GkUniform + deriving (Generic, Show, Eq) + +data Type + = TyBool + | TyFloat + | TySampler2D + | TyVec Int + | TyMat Int Int + | TyStruct NameId [(Type, NameId)] + deriving (Generic, Show, Eq) + +newtype NameId = NameId Int + deriving (Generic, Show, Eq) + +data Name + = Name Namespace NameId + deriving (Generic, Show, Eq) + +data Namespace + = NsT + | NsS + | NsU + | NsVF + | NsIn + | NsOut + deriving (Generic, Show, Eq) + +data FunName + = PrimAbs + | PrimAsin + | PrimAtan + | PrimCos + | PrimCross + | PrimDot + | PrimFloor + | PrimFract + | PrimLength + | PrimMat3x3 + | PrimMat4x4 + | PrimMod + | PrimNormalize + | PrimPow + | PrimSin + | PrimSmoothstep + | PrimSqrt + | PrimStep + | PrimTan + | PrimVec2 + | PrimVec3 + | PrimVec4 + deriving (Generic, Show, Eq) + +data Swizzle + = X | Y | Z | W + deriving (Generic, Show, Eq) + +data NameExpr + = NameExpr Name + | UniformExpr NameId NameId + deriving (Generic, Show, Eq) + +data Cast + = Cast + | NoCast + deriving (Generic, Show, Eq) + +data ExprAtom + = LitIntExpr Cast Int + | LitFloatExpr Cast Float + | IdentifierExpr NameExpr + | SwizzleExpr NameId Swizzle + | VecIndexExpr NameExpr Swizzle + | MatIndexExpr NameExpr Swizzle Swizzle + deriving (Generic, Show, Eq) + +data Expr + = UnaryExpr UnaryOp ExprAtom + | BinaryExpr ExprAtom BinaryOp ExprAtom + | FunCallExpr FunName [ExprAtom] + | TextureExpr ExprAtom ExprAtom ExprAtom + | AtomExpr ExprAtom + deriving (Generic, Show, Eq) + +data BinaryOp + = BOpPlus + | BOpMinus + | BOpMul + | BOpDiv + | BOpGE + | BOpGT + | BOpLE + | BOpLT + | BOpAnd + | BOpOr + deriving (Generic, Show, Eq) + +data UnaryOp + = UOpMinus + | UOpNot + deriving (Generic, Show, Eq) + +data StmtAnnot a = SA + { annot :: a + , unAnnot :: Stmt a + } + deriving (Generic, Show, Eq, Functor, Foldable, Traversable) + +instance Applicative StmtAnnot where + pure a = SA a (pure a) + liftA2 f a b = SA (f (annot a) (annot b)) $ liftA2 f (unAnnot a) (unAnnot b) + +data Stmt a + = AssignStmt Name Expr + | DeclStmt LocalDecl + | EmitStmt Emit + | IfStmt NameId [StmtAnnot a] [StmtAnnot a] + deriving (Generic, Show, Eq, Functor, Foldable, Traversable) + +instance Applicative Stmt where + -- Arbitrary decision because "pure" doesn't really make sense. + pure _ = EmitStmt EmitFragDepth + + liftA2 f (IfStmt n t1 e1) (IfStmt _ t2 e2) = IfStmt n + ((zipWith . liftA2) f t1 t2) + ((zipWith . liftA2) f e1 e2) + liftA2 _ (AssignStmt n e) _ = AssignStmt n e + liftA2 _ (DeclStmt d) _ = DeclStmt d + liftA2 _ (EmitStmt e) _ = EmitStmt e + liftA2 _ (IfStmt n _ _) _ = IfStmt n [] [] + + +data Emit + = EmitPosition Expr + | EmitFragDepth + deriving (Generic, Show, Eq) + + +class Annot a where + parseAnnot :: Parser a + ppAnnot :: a -> Maybe LTB.Builder + +instance Annot () where + parseAnnot = pure () + ppAnnot = const Nothing + +instance (Annot a, Annot b) => Annot (a, b) where + parseAnnot = error "not implemented" + ppAnnot (a, b) = do + ppA <- ppAnnot a + ppB <- ppAnnot b + return $ "(" <> ppA <> ", " <> ppB <> ")" + +---------------------------------- + +argCountForFunName :: FunName -> Int +argCountForFunName PrimAbs = 1 +argCountForFunName PrimAsin = 1 +argCountForFunName PrimAtan = 2 +argCountForFunName PrimCos = 1 +argCountForFunName PrimCross = 2 +argCountForFunName PrimDot = 2 +argCountForFunName PrimFloor = 1 +argCountForFunName PrimFract = 1 +argCountForFunName PrimLength = 1 +argCountForFunName PrimMat3x3 = 3 +argCountForFunName PrimMat4x4 = 4 +argCountForFunName PrimMod = 2 +argCountForFunName PrimNormalize = 1 +argCountForFunName PrimPow = 2 +argCountForFunName PrimSin = 1 +argCountForFunName PrimSmoothstep = 3 +argCountForFunName PrimSqrt = 1 +argCountForFunName PrimStep = 2 +argCountForFunName PrimTan = 1 +argCountForFunName PrimVec2 = 2 +argCountForFunName PrimVec3 = 3 +argCountForFunName PrimVec4 = 4 + +isLitExpr :: ExprAtom -> Bool +isLitExpr LitFloatExpr{} = True +isLitExpr LitIntExpr{} = True +isLitExpr _ = False + +isIdentifierExpr :: ExprAtom -> Bool +isIdentifierExpr IdentifierExpr{} = True +isIdentifierExpr _ = False diff --git a/src/Language/GLSL/BitCode.hs b/src/Language/GLSL/BitCode.hs new file mode 100644 --- /dev/null +++ b/src/Language/GLSL/BitCode.hs @@ -0,0 +1,295 @@ +{-# LANGUAGE BinaryLiterals #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE LambdaCase #-} +{-# LANGUAGE MultiParamTypeClasses #-} +{-# LANGUAGE OverloadedStrings #-} +{-# LANGUAGE TupleSections #-} +{-# LANGUAGE ViewPatterns #-} +{-# OPTIONS_GHC -Wno-missing-signatures #-} +module Language.GLSL.BitCode where + +import Data.Bits (shiftL, (.|.)) +import qualified Data.Text.Lazy as LT +import qualified Data.Text.Lazy.IO as IO +import Data.Word (Word64) +import Debug.Trace (trace) +import Language.GLSL.AST +import Language.GLSL.ConstExpr (ConstExprs) +import qualified Language.GLSL.ConstExpr as ConstExpr +import Language.GLSL.Internal.Bits (B (..), expand, flat, zero) +import Language.GLSL.Parser (parseShader) +import Language.GLSL.PrettyPrint + + +assemble :: BitsStmt -> Word64 +assemble bits = trace (show bits) $ + foldr (\(toInt -> a) b -> (a `shiftL` 1) .|. b) 0 $ flat bits + +toInt :: B -> Word64 +toInt O = 0 +toInt I = 1 + +type BitsStmt = ((B,B), (BitsType, B, BitsExpr)) +encodeStmt :: Maybe ConstExprs -> Stmt a -> [BitsStmt] +encodeStmt ce = \case + AssignStmt _ e -> + [(bitsAssignStmt, (zero, zero, encodeExpr ce e))] + DeclStmt d -> + [(bitsDeclStmt, encodeLocalDecl ce d)] + EmitStmt e -> + [(bitsEmitStmt, uncurry (zero,,) $ encodeEmit ce e)] + IfStmt _ t e -> do + [(bitsIfStmt, ((bitsThenStmt, zero), zero, zero))] + ++ concatMap (encodeStmt ce . unAnnot) t + ++ [(bitsIfStmt, ((bitsElseStmt, zero), zero, zero))] + ++ concatMap (encodeStmt ce . unAnnot) e + ++ [(bitsIfStmt, ((bitsEndifStmt, zero), zero, zero))] + where + -- 2 bits encode which statement this is. + bitsAssignStmt = (O,O) + bitsDeclStmt = (O,I) + bitsEmitStmt = (I,O) + bitsIfStmt = (I,I) + + -- For IfStmt, we need to know when "else" branch starts and when it's over. + -- We encode that in the next 2 bits for the IfStmt encoding. + bitsThenStmt = (O,O) + bitsElseStmt = (O,I) + bitsEndifStmt = (I,O) + +encodeLocalDecl :: Maybe ConstExprs -> LocalDecl -> (BitsType, B, BitsExpr) +encodeLocalDecl _ (LDecl ty _ Nothing) = + -- 1 bit encodes whether the declaration has an initialiser. + (encodeType ty, O, zero) +encodeLocalDecl ce (LDecl ty _ (Just e)) = + (encodeType ty, I, encodeExpr ce e) + +-- | 2 bits encode the type, then 2 bits encode the vec/mat size. +type BitsType = ((B,B), (B,B)) +encodeType :: Type -> BitsType +encodeType = \case + TyBool -> (bitsTyBool, (O,O)) + TyFloat -> (bitsTyFloat, (O,O)) + TyVec i -> (bitsTyVec, encodeVecSize i i) + TyMat i j -> (bitsTyMat, encodeVecSize i j) + TySampler2D -> error "no encoding for local sampler declarations" + TyStruct{} -> error "no encoding for local struct declarations" + where + -- 2 bits encode the type of a LocalDecl. + bitsTyBool = (O,O) + bitsTyFloat = (O,I) + bitsTyVec = (I,O) + bitsTyMat = (I,I) + +encodeVecSize :: Int -> Int -> (B,B) +encodeVecSize i j | i /= j = error "no encoding for non-square matrices" +encodeVecSize i _ = case i of + 2 -> bitsVecSize2 + 3 -> bitsVecSize3 + 4 -> bitsVecSize4 + _ -> error $ "no encoding for vec/mat size: " <> show i + where + -- 2 bits encode the size of TyVec/TyMat. We only allow square matrices, so + -- the size of mat2x2 has the same encoding as the size of vec2. + bitsVecSize2 = (O,O) + bitsVecSize3 = (O,I) + bitsVecSize4 = (I,O) + +encodeEmit :: Maybe ConstExprs -> Emit -> (B, BitsExpr) +encodeEmit _ EmitFragDepth = (O,zero) +encodeEmit ce (EmitPosition e) = (I,encodeExpr ce e) + +type BitsExpr = ((B,B), BitsFunName, BitsExprAtom, BitsExprAtom) +encodeExpr :: Maybe ConstExprs -> Expr -> BitsExpr +encodeExpr (Just ce) e | ConstExpr.isConstExpr ce e = + -- Constant expressions are encoded as atom expressions with the "constant + -- expression" operator 0b11. + ((O,O), expand (I,I), zero, zero) +encodeExpr _ expr = case expr of + UnaryExpr o e -> (bitsUnaryExpr, expand $ encodeUnaryOp o, encodeExprAtom e, zero) + BinaryExpr l o r -> (bitsBinaryExpr, expand $ encodeBinaryOp o, encodeExprAtom l, encodeExprAtom r) + TextureExpr t x y -> (bitsTextureExpr, zero, zero, zero) + FunCallExpr f args -> uncurry (bitsFunCallExpr, encodeFunName f,,) $ encodeArgs f args + AtomExpr e -> (bitsAtomExpr, expand bitsUOpIdentity, encodeExprAtom e, zero) + where + -- 2 bits encode the expression type. + bitsUnaryExpr = (O,O) + bitsBinaryExpr = (O,I) + bitsFunCallExpr = (I,O) + bitsTextureExpr = (I,I) + -- AtomExpr is a encoded as UnaryExpr with a zero operator. + bitsAtomExpr = bitsUnaryExpr + bitsUOpIdentity = (O,O) + +-- | Implements special encodings for functions with more than 2 args. + +-- Because we can't encode all the args individually, we take shortcuts where we +-- know something about how a function tends to be called. +encodeArgs :: FunName -> [ExprAtom] -> (BitsExprAtom, BitsExprAtom) +encodeArgs PrimSmoothstep [a,b,c] | isLitExpr a && isLitExpr b = + (encodeExprAtom c, zero) +encodeArgs PrimVec4 args@[a,_,_,d] | all isLitExpr args = + (encodeExprAtom a, encodeExprAtom d) +encodeArgs PrimVec4 [a,b,c,d] | all isIdentifierExpr [a,b,c] && isLitExpr d = + (encodeExprAtom a, encodeExprAtom d) +encodeArgs PrimVec4 args@[a,_,_,d] | all isIdentifierExpr args = + (encodeExprAtom a, encodeExprAtom d) +encodeArgs PrimMat4x4 args@[a,_,_,d] | all isIdentifierExpr args = + (encodeExprAtom a, encodeExprAtom d) + +encodeArgs _ [] = (zero, zero) +encodeArgs _ [a] = (encodeExprAtom a, zero) +encodeArgs _ [a,b] = (encodeExprAtom a, encodeExprAtom b) +encodeArgs f args = + error $ "unsupported argument list for '" <> pp ppFunName f <> "': " + <> pps ", " ppExprAtom args + +encodeUnaryOp :: UnaryOp -> (B,B) +encodeUnaryOp = \case + UOpMinus -> bitsUOpMinus + UOpNot -> bitsUOpNot + where + -- 2 bits encode encode the unary operator. 0 is AtomExpr (no operator or + -- unary "+", i.e. the identity operator). + bitsUOpMinus = (O,I) + bitsUOpNot = (I,O) + +-- | 4 bits encode the binary operator. +type BitsBinaryOp = (B,B,B,B) +encodeBinaryOp :: BinaryOp -> BitsBinaryOp +encodeBinaryOp = \case + BOpPlus -> bitsBOpPlus + BOpMinus -> bitsBOpMinus + BOpMul -> bitsBOpMul + BOpDiv -> bitsBOpDiv + BOpGE -> bitsBOpGE + BOpGT -> bitsBOpGT + BOpLE -> bitsBOpLE + BOpLT -> bitsBOpLT + BOpAnd -> bitsBOpAnd + BOpOr -> bitsBOpOr + where + bitsBOpPlus = (O,O,O,O) + bitsBOpMinus = (O,O,O,I) + bitsBOpMul = (O,O,I,O) + bitsBOpDiv = (O,O,I,I) + bitsBOpGE = (O,I,O,O) + bitsBOpGT = (O,I,O,I) + bitsBOpLE = (O,I,I,O) + bitsBOpLT = (O,I,I,I) + bitsBOpAnd = (I,O,O,O) + bitsBOpOr = (I,O,O,I) + +-- | 5 bits encode the function name for FunCallExpr. +type BitsFunName = (B,B,B,B,B) +encodeFunName :: FunName -> BitsFunName +encodeFunName = \case + PrimAbs -> bitsPrimAbs + PrimAsin -> bitsPrimAsin + PrimAtan -> bitsPrimAtan + PrimCos -> bitsPrimCos + PrimCross -> bitsPrimCross + PrimDot -> bitsPrimDot + PrimFloor -> bitsPrimFloor + PrimFract -> bitsPrimFract + PrimLength -> bitsPrimLength + PrimMat3x3 -> bitsPrimMat3x3 + PrimMat4x4 -> bitsPrimMat4x4 + PrimMod -> bitsPrimMod + PrimNormalize -> bitsPrimNormalize + PrimPow -> bitsPrimPow + PrimSin -> bitsPrimSin + PrimSmoothstep -> bitsPrimSmoothstep + PrimSqrt -> bitsPrimSqrt + PrimStep -> bitsPrimStep + PrimTan -> bitsPrimTan + PrimVec2 -> bitsPrimVec2 + PrimVec3 -> bitsPrimVec3 + PrimVec4 -> bitsPrimVec4 + where + bitsPrimAbs = (O,O,O,O,O) + bitsPrimAsin = (O,O,O,O,I) + bitsPrimAtan = (O,O,O,I,O) + bitsPrimCos = (O,O,O,I,I) + bitsPrimCross = (O,O,I,O,O) + bitsPrimDot = (O,O,I,O,I) + bitsPrimFloor = (O,O,I,I,O) + bitsPrimFract = (O,O,I,I,I) + bitsPrimLength = (O,I,O,O,O) + bitsPrimMat3x3 = (O,I,O,O,I) + bitsPrimMat4x4 = (O,I,O,I,O) + bitsPrimMod = (O,I,O,I,I) + bitsPrimNormalize = (O,I,I,O,O) + bitsPrimPow = (O,I,I,O,I) + bitsPrimSin = (O,I,I,I,O) + bitsPrimSmoothstep = (O,I,I,I,I) + bitsPrimSqrt = (I,O,O,O,O) + bitsPrimStep = (I,O,O,O,I) + bitsPrimTan = (I,O,O,I,O) + bitsPrimVec2 = (I,O,O,I,I) + bitsPrimVec3 = (I,O,I,O,O) + bitsPrimVec4 = (I,O,I,O,I) + +-- | ExprAtom type is encoded in 3 bits. +encodeExprAtomType :: ExprAtom -> (B,B,B) +encodeExprAtomType = \case + LitIntExpr{} -> bitsLitExpr + LitFloatExpr{} -> bitsLitExpr + IdentifierExpr{} -> bitsIdentifierExpr + SwizzleExpr{} -> bitsSwizzleExpr + VecIndexExpr{} -> bitsVecIndexExpr + MatIndexExpr{} -> bitsMatIndexExpr + where + -- Literals are encoded the same. + bitsLitExpr = (O,O,O) + bitsIdentifierExpr = (O,O,I) + bitsSwizzleExpr = (O,I,O) + bitsVecIndexExpr = (O,I,I) + bitsMatIndexExpr = (I,O,O) + +-- ExprAtom is encoded in 7 bits: 3 bits for type and 4 bits for arguments. +-- +-- We only need the full 4 bits for MatIndexExpr arguments which can be any of +-- the 16 positions in the matrix indexing operation. +type BitsExprAtom = ((B,B,B), ((B,B), (B,B))) +encodeExprAtom :: ExprAtom -> BitsExprAtom +encodeExprAtom e = (encodeExprAtomType e, encodeOperand e) + where + encodeOperand (SwizzleExpr _ i) = (encodeSwizzle i, (O,O)) + encodeOperand (VecIndexExpr _ i) = (encodeSwizzle i, (O,O)) + encodeOperand (MatIndexExpr _ i j) = (encodeSwizzle i, encodeSwizzle j) + encodeOperand _ = ((O,O),(O,O)) + +-- Swizzle/VecIndex is encoded in 2 bits. +encodeSwizzle :: Swizzle -> (B,B) +encodeSwizzle = \case + X -> bitsSwizzleX + Y -> bitsSwizzleY + Z -> bitsSwizzleZ + W -> bitsSwizzleW + where + bitsSwizzleX = (O,O) + bitsSwizzleY = (O,I) + bitsSwizzleZ = (I,O) + bitsSwizzleW = (I,I) + + +parse :: LT.Text -> Either String (GLSL ()) +parse = parseShader + +main :: IO () +main = do + putStrLn "Loading shader source..." + -- inText <- IO.readFile "../large-shaders/lambdacnc.frag" + -- inText <- IO.readFile "../large-shaders/lambdacnc.vert" + -- inText <- IO.readFile "../large-shaders/lambdaray.frag" + -- inText <- IO.readFile "../large-shaders/xax.frag" + -- inText <- IO.readFile "../large-shaders/xax.vert" + inText <- IO.readFile "../large-shaders/small.vert" + putStrLn "Parsing shader source..." + case parse inText of + Left err -> writeFile "../opt.glsl" $ "// Error\n" <> err + Right (GLSL _ (reverse -> (ProcDecl _ _ ss):_)) -> + mapM_ (print . encodeStmt Nothing . unAnnot) ss + Right _ -> + return () diff --git a/src/Language/GLSL/ConstExpr.hs b/src/Language/GLSL/ConstExpr.hs --- a/src/Language/GLSL/ConstExpr.hs +++ b/src/Language/GLSL/ConstExpr.hs @@ -2,13 +2,17 @@ ( ConstExprs , collectConstExprs , isConstExpr + , empty ) where -import qualified Data.IntSet as S -import Language.GLSL.Types +import qualified Data.IntSet as S +import Language.GLSL.AST newtype ConstExprs = ConstExprs S.IntSet + +empty :: ConstExprs +empty = ConstExprs S.empty collectConstExprs :: [StmtAnnot a] -> ConstExprs collectConstExprs = ConstExprs . foldr (add . unAnnot) S.empty diff --git a/src/Language/GLSL/Decls.hs b/src/Language/GLSL/Decls.hs --- a/src/Language/GLSL/Decls.hs +++ b/src/Language/GLSL/Decls.hs @@ -2,9 +2,9 @@ {-# LANGUAGE StrictData #-} module Language.GLSL.Decls where -import qualified Data.IntMap.Strict as M -import Language.GLSL.Types (Name (..), NameExpr (..), NameId (..), - Namespace (..)) +import qualified Data.IntMap.Strict as M +import Language.GLSL.AST (Name (..), NameExpr (..), NameId (..), + Namespace (..)) data Decls a = Decls diff --git a/src/Language/GLSL/Internal/Bits.hs b/src/Language/GLSL/Internal/Bits.hs new file mode 100644 --- /dev/null +++ b/src/Language/GLSL/Internal/Bits.hs @@ -0,0 +1,68 @@ +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE MultiParamTypeClasses #-} +module Language.GLSL.Internal.Bits where + +data B = O | I + deriving (Show, Eq) + +class Bits a where + fill :: B -> a + flat :: a -> [B] + unflat :: [B] -> Maybe (a, [B]) + +instance Bits B where + fill b = b + flat a = [a] + unflat (x:xs) = Just (x, xs) + unflat _ = Nothing +instance (Bits a,Bits b) => Bits (a,b) where + fill b = (fill b,fill b) + flat (a,b) = flat a ++ flat b + unflat xs = do + (a,xsa) <- unflat xs + (b,xsb) <- unflat xsa + return ((a,b),xsb) +instance (Bits a,Bits b,Bits c) => Bits (a,b,c) where + fill b = (fill b,fill b,fill b) + flat (a,b,c) = flat a ++ flat b ++ flat c + unflat xs = do + (a,xsa) <- unflat xs + (b,xsb) <- unflat xsa + (c,xsc) <- unflat xsb + return ((a,b,c),xsc) +instance (Bits a,Bits b,Bits c,Bits d) => Bits (a,b,c,d) where + fill b = (fill b,fill b,fill b,fill b) + flat (a,b,c,d) = flat a ++ flat b ++ flat c ++ flat d + unflat xs = do + (a,xsa) <- unflat xs + (b,xsb) <- unflat xsa + (c,xsc) <- unflat xsb + (d,xsd) <- unflat xsc + return ((a,b,c,d),xsd) +instance (Bits a,Bits b,Bits c,Bits d, Bits e) => Bits (a,b,c,d,e) where + fill b = (fill b,fill b,fill b,fill b,fill b) + flat (a,b,c,d,e) = flat a ++ flat b ++ flat c ++ flat d ++ flat e + unflat xs = do + (a,xsa) <- unflat xs + (b,xsb) <- unflat xsa + (c,xsc) <- unflat xsb + (d,xsd) <- unflat xsc + (e,xse) <- unflat xsd + return ((a,b,c,d,e),xse) + +zero, one :: Bits a => a +zero = fill O +one = fill I + +class Expandable a b where + expand :: a -> b + +instance Expandable a a where + expand x = x +-- TODO: can this be more generic? +instance Expandable (B,B) (B,B,B,B,B) where + expand (a,b) = expand (a,b,O) +instance Expandable (B,B,B) (B,B,B,B,B) where + expand (a,b,c) = expand (a,b,c,O) +instance Expandable (B,B,B,B) (B,B,B,B,B) where + expand (a,b,c,d) = expand (a,b,c,d,O) diff --git a/src/Language/GLSL/Optimizer.hs b/src/Language/GLSL/Optimizer.hs --- a/src/Language/GLSL/Optimizer.hs +++ b/src/Language/GLSL/Optimizer.hs @@ -6,11 +6,12 @@ import Data.Attoparsec.ByteString.Char8 (Parser) import qualified Data.Text.Lazy as LT import qualified Data.Text.Lazy.IO as IO +import Language.GLSL.AST (Annot, GLSL) import qualified Language.GLSL.Optimizer.Deinline as Deinline import qualified Language.GLSL.Optimizer.Liveness as Liveness -import Language.GLSL.Types (Annot, GLSL, parseGLSL, - parseShader, parseTest, - printShader) +import Language.GLSL.Parser (parseGLSL, parseShader, + parseTest) +import Language.GLSL.PrettyPrint (printShader) optimizeShader :: LT.Text -> Either String LT.Text diff --git a/src/Language/GLSL/Optimizer/DFG.hs b/src/Language/GLSL/Optimizer/DFG.hs --- a/src/Language/GLSL/Optimizer/DFG.hs +++ b/src/Language/GLSL/Optimizer/DFG.hs @@ -13,8 +13,9 @@ import qualified Data.GraphViz as GV import qualified Data.GraphViz.Printing as GV import qualified Data.Text.Lazy.IO as IO +import Language.GLSL.AST import Language.GLSL.Decls -import Language.GLSL.Types hiding (t) +import Language.GLSL.PrettyPrint (pp, ppName, ppNamespace) -------------------------------------------------------------------------------- diff --git a/src/Language/GLSL/Optimizer/Deinline.hs b/src/Language/GLSL/Optimizer/Deinline.hs --- a/src/Language/GLSL/Optimizer/Deinline.hs +++ b/src/Language/GLSL/Optimizer/Deinline.hs @@ -7,11 +7,12 @@ import qualified Data.List as List import Data.Maybe (listToMaybe) import Debug.Trace (trace) +import Language.GLSL.AST import Language.GLSL.ConstExpr (ConstExprs, collectConstExprs) import qualified Language.GLSL.Optimizer.FunctionGenerator as FunctionGenerator +import Language.GLSL.PrettyPrint (pp, ppTopDecl) import qualified Language.GLSL.StructuralEquality as StructuralEquality -import Language.GLSL.Types data Config = Config @@ -57,7 +58,7 @@ diStmts :: Annot a => Config -> [StmtAnnot a] -> [StmtAnnot a] diStmts config ss = - let ce = collectConstExprs ss in + let ce = Just (collectConstExprs ss) in case findBody config ce ss of Nothing -> ss Just body -> @@ -70,7 +71,7 @@ -- | Remove all occurrences of 'body' from 'ss'. -deleteBody :: ConstExprs -> [StmtAnnot a] -> [StmtAnnot a] -> [StmtAnnot a] +deleteBody :: Maybe ConstExprs -> [StmtAnnot a] -> [StmtAnnot a] -> [StmtAnnot a] deleteBody ce body = go [] where go acc [] = reverse acc @@ -80,7 +81,7 @@ else go (s:acc) ss -findBody :: Config -> ConstExprs -> [StmtAnnot a] -> Maybe [StmtAnnot a] +findBody :: Config -> Maybe ConstExprs -> [StmtAnnot a] -> Maybe [StmtAnnot a] findBody _ _ [] = Nothing findBody Config{..} _ (_:ss) | length ss < windowSize = Nothing findBody config@Config{..} ce (_:ss) = @@ -139,6 +140,6 @@ transpose = getZipList . traverse ZipList -- | Check for each statement whether it's structurally equal to the first one. -allEqual :: ConstExprs -> [StmtAnnot a] -> Bool +allEqual :: Maybe ConstExprs -> [StmtAnnot a] -> Bool allEqual _ [] = True allEqual ce (x:xs) = all (StructuralEquality.eqStmtAnnot ce x) xs diff --git a/src/Language/GLSL/Optimizer/FunctionGenerator.hs b/src/Language/GLSL/Optimizer/FunctionGenerator.hs --- a/src/Language/GLSL/Optimizer/FunctionGenerator.hs +++ b/src/Language/GLSL/Optimizer/FunctionGenerator.hs @@ -1,6 +1,6 @@ module Language.GLSL.Optimizer.FunctionGenerator where -import Language.GLSL.Types +import Language.GLSL.AST makeFunction :: [StmtAnnot a] -> TopDecl a diff --git a/src/Language/GLSL/Optimizer/Liveness.hs b/src/Language/GLSL/Optimizer/Liveness.hs --- a/src/Language/GLSL/Optimizer/Liveness.hs +++ b/src/Language/GLSL/Optimizer/Liveness.hs @@ -3,7 +3,7 @@ import qualified Data.IntSet as S import qualified Data.Text.Lazy.Builder as LTB -import Language.GLSL.Types hiding (t) +import Language.GLSL.AST newtype Liveness = Liveness { unLiveness :: S.IntSet } diff --git a/src/Language/GLSL/Parser.hs b/src/Language/GLSL/Parser.hs new file mode 100644 --- /dev/null +++ b/src/Language/GLSL/Parser.hs @@ -0,0 +1,306 @@ +{-# LANGUAGE DeriveFunctor #-} +{-# LANGUAGE DeriveTraversable #-} +{-# LANGUAGE OverloadedStrings #-} +{-# LANGUAGE StrictData #-} +{-# OPTIONS_GHC -Wno-name-shadowing #-} +{-# LANGUAGE DeriveGeneric #-} +module Language.GLSL.Parser where + +import Control.Applicative ((<|>)) +import Data.Attoparsec.ByteString.Char8 (IResult (..), Parser, char, + decimal, endOfInput, many1, + option, parse, parseOnly, + rational, scientific, sepBy1) +import qualified Data.Scientific as Sci +import qualified Data.Text.Encoding as T +import qualified Data.Text.Lazy as LT +import Language.GLSL.AST + + +parseShader :: Annot a => LT.Text -> Either String (GLSL a) +parseShader = parseOnly parseGLSL . T.encodeUtf8 . LT.toStrict + +-- | Parse GLSL + +parseGLSL :: Annot a => Parser (GLSL a) +parseGLSL = GLSL + <$> parseVersion + <*> ("\n" >> many1 parseTopDecl >>= (endOfInput >>) . pure) + +-- | Parse Version + +parseVersion :: Parser Version +parseVersion = Version <$> ("#version " >> decimal) + +-- | Parse TopDecl + +parseTopDecl :: Annot a => Parser (TopDecl a) +parseTopDecl = layoutDecl <|> globalDecl <|> procDecl + where + layoutDecl = LayoutDecl + <$> ("layout(" >> parseLayoutSpec) + <*> (") " >> parseGlobalDecl) + + globalDecl = GlobalDecl + <$> parseGlobalDecl + + procDecl = ProcDecl + <$> ("void " >> parseProcName) + <*> ("() " >> pure []) + -- <*> ("{\n" >> many1 parseStmtAnnot) + <*> ("{\n" >> many1 parseStmtAnnot >>= ("}\n" >>) . pure) + +-- | Parse ProcName + +parseProcName :: Parser ProcName +parseProcName = + ("main" >> pure ProcMain) + <|> ("p" >> ProcName <$> parseNameId) + +-- | Parse LayoutSpec + +parseLayoutSpec :: Parser LayoutSpec +parseLayoutSpec = + ("std140" >> pure LayoutStd140) + <|> ("location = " >> LayoutLocation <$> decimal) + +-- | Parse ParamDecl + +parseParamDecl :: Parser ParamDecl +parseParamDecl = Param + <$> parseParamKind + <*> (" " >> parseLocalDecl) + +-- | Parse ParamKind + +parseParamKind :: Parser ParamKind +parseParamKind = (char ' ' <|> pure ' ') >> + ("in" >> return PkIn) <|> + ("out" >> return PkOut) <|> + ("inout" >> return PkInout) + +-- | Parse LocalDecl + +parseLocalDecl :: Parser LocalDecl +parseLocalDecl = LDecl + <$> parseType + <*> (" t" >> parseNameId) + <*> (option Nothing (" = " >> Just <$> parseExpr) >>= (";\n" >>) . pure) + +-- | Parse GlobalDecl + +parseGlobalDecl :: Parser GlobalDecl +parseGlobalDecl = GDecl + <$> parseGDeclKind + <*> (" " >> parseType) + <*> (" " >> parseName >>= (";\n" >>) . pure) + +-- | Parse GDeclKind + +parseGDeclKind :: Parser GDeclKind +parseGDeclKind = + ("in" >> return GkIn) <|> + ("out" >> return GkOut) <|> + ("uniform" >> return GkUniform) + +-- | Parse Type + +parseType :: Parser Type +parseType = + ("bool" >> return TyBool) + <|> ("float" >> return TyFloat) + <|> ("sampler2D" >> return TySampler2D) + <|> ("vec" >> TyVec <$> decimal) + <|> ("mat" >> TyMat <$> decimal <*> ("x" >> decimal)) + <|> tyStruct + where + tyStruct = TyStruct + <$> ("uBlock" >> parseNameId) + <*> (" {\n" >> many1 parseStructMember >>= ("}" >>) . pure) + + parseStructMember :: Parser (Type, NameId) + parseStructMember = (,) + <$> parseType + <*> (" u" >> parseNameId >>= (";\n" >>) . pure) + +-- | Parse NameId + +parseNameId :: Parser NameId +parseNameId = NameId + <$> decimal + +-- | Parse Name + +parseName :: Parser Name +parseName = Name + <$> parseNamespace + <*> parseNameId + +-- | Parse Namespace + +parseNamespace :: Parser Namespace +parseNamespace = + ("in" >> pure NsIn) + <|> ("out" >> pure NsOut) + <|> ("vf" >> pure NsVF) + <|> (char 't' >> pure NsT) + <|> (char 'u' >> pure NsU) + <|> (char 's' >> pure NsS) + +-- | Parse FunName + +parseFunName :: Parser FunName +parseFunName = + ("abs" >> pure PrimAbs) + <|> ("asin" >> pure PrimAsin) + <|> ("atan" >> pure PrimAtan) + <|> ("cos" >> pure PrimCos) + <|> ("cross" >> pure PrimCross) + <|> ("dot" >> pure PrimDot) + <|> ("floor" >> pure PrimFloor) + <|> ("fract" >> pure PrimFract) + <|> ("length" >> pure PrimLength) + <|> ("mat3x3" >> pure PrimMat3x3) + <|> ("mat4x4" >> pure PrimMat4x4) + <|> ("mod" >> pure PrimMod) + <|> ("normalize" >> pure PrimNormalize) + <|> ("pow" >> pure PrimPow) + <|> ("sin" >> pure PrimSin) + <|> ("smoothstep" >> pure PrimSmoothstep) + <|> ("sqrt" >> pure PrimSqrt) + <|> ("step" >> pure PrimStep) + <|> ("tan" >> pure PrimTan) + <|> ("vec2" >> pure PrimVec2) + <|> ("vec3" >> pure PrimVec3) + <|> ("vec4" >> pure PrimVec4) + +-- | Parse Swizzle + +parseSwizzle :: Parser Swizzle +parseSwizzle = + (char 'x' >> pure X) + <|> (char 'y' >> pure Y) + <|> (char 'z' >> pure Z) + <|> (char 'w' >> pure W) + +-- | Parse VecIndex (Swizzle) + +parseVecIndex :: Parser Swizzle +parseVecIndex = + (char '0' >> pure X) + <|> (char '1' >> pure Y) + <|> (char '2' >> pure Z) + <|> (char '3' >> pure W) + +-- | Parse NameExpr + +parseNameExpr :: Parser NameExpr +parseNameExpr = + UniformExpr <$> (char 'u' >> parseNameId) <*> (".u" >> parseNameId) + <|> NameExpr <$> parseName + +-- | Parse ExprAtom + +parseExprAtom :: Parser ExprAtom +parseExprAtom = + litNumber <$> scientific + <|> LitIntExpr Cast <$> ("int(" >> decimal >>= (")" >>) . pure) + <|> LitFloatExpr Cast <$> ("float(" >> rational >>= (")" >>) . pure) + <|> SwizzleExpr <$> (char 't' >> parseNameId) <*> (char '.' >> parseSwizzle) + <|> MatIndexExpr <$> parseNameExpr <*> ("[" >> parseVecIndex) <*> ("][" >> parseVecIndex >>= ("]" >>) . pure) + <|> VecIndexExpr <$> parseNameExpr <*> ("[" >> parseVecIndex >>= ("]" >>) . pure) + <|> IdentifierExpr <$> parseNameExpr + where + litNumber s = + let e = Sci.base10Exponent s + c = Sci.coefficient s + in if e >= 0 + then LitIntExpr NoCast (fromInteger (c * 10 ^ e)) + else LitFloatExpr NoCast (Sci.toRealFloat s) + +-- | Parse Expr + +parseExpr :: Parser Expr +parseExpr = + (char '(' >> operatorExpr >>= (char ')' >>) . pure) + <|> textureExpr + <|> funCallExpr + <|> AtomExpr <$> parseExprAtom + + where + operatorExpr = + BinaryExpr <$> parseExprAtom <*> parseBinaryOp <*> parseExprAtom + <|> UnaryExpr <$> parseUnaryOp <*> parseExprAtom + + textureExpr = TextureExpr + <$> ("texture(" >> parseExprAtom) + <*> (",vec2(" >> parseExprAtom) + <*> ("," >> parseExprAtom >>= ("))" >>) . pure) + + funCallExpr = FunCallExpr + <$> parseFunName + <*> (char '(' >> sepBy1 parseExprAtom (char ',') >>= (char ')' >>) . pure) + +-- | Parse BinaryOp + +parseBinaryOp :: Parser BinaryOp +parseBinaryOp = + (char '+' >> pure BOpPlus) + <|> (char '-' >> pure BOpMinus) + <|> (char '*' >> pure BOpMul) + <|> (char '/' >> pure BOpDiv) + <|> (">=" >> pure BOpGE) + <|> (">" >> pure BOpGT) + <|> ("<=" >> pure BOpLE) + <|> ("<" >> pure BOpLT) + <|> ("&&" >> pure BOpAnd) + <|> ("||" >> pure BOpOr) + +-- | Parse UnaryOp + +parseUnaryOp :: Parser UnaryOp +parseUnaryOp = + (char '-' >> pure UOpMinus) + <|> (char '!' >> pure UOpMinus) + +-- | Parse StmtAnnot + +parseStmtAnnot :: Annot a => Parser (StmtAnnot a) +parseStmtAnnot = SA <$> parseAnnot <*> parseStmt + +-- | Parse Stmt + +parseStmt :: Annot a => Parser (Stmt a) +parseStmt = + IfStmt <$> ("if(t" >> parseNameId >>= ("){\n" >>) . pure) + <*> many1 parseStmtAnnot + <*> ("} else {\n" >> many1 parseStmtAnnot >>= ("}\n" >>) . pure) + <|> AssignStmt <$> parseName <*> (" = " >> parseExpr >>= (";\n" >>) . pure) + <|> DeclStmt <$> parseLocalDecl + <|> EmitStmt <$> parseEmit + +-- | Parse Emit + +parseEmit :: Parser Emit +parseEmit = + EmitPosition <$> ("gl_Position = " >> parseExpr >>= (";\n" >>) . pure) + <|> ("gl_FragDepth = gl_FragCoord[2];\n" >> pure EmitFragDepth) + +------------------ + +parseTest :: Show a => Parser a -> LT.Text -> IO () +parseTest p input = + let r = show . fromPartial . parse p . T.encodeUtf8 . LT.toStrict $ input in + if length r > 600 + then + let start = take 500 r + end = reverse $ take 100 $ reverse r + in + putStrLn $ start <> " ... " <> end + else putStrLn r + where + fromPartial (Partial cont) = cont mempty + fromPartial r = r + +t :: Show a => Parser a -> String -> IO () +t p = parseTest p . LT.pack diff --git a/src/Language/GLSL/PrettyPrint.hs b/src/Language/GLSL/PrettyPrint.hs new file mode 100644 --- /dev/null +++ b/src/Language/GLSL/PrettyPrint.hs @@ -0,0 +1,261 @@ +{-# LANGUAGE OverloadedStrings #-} +{-# LANGUAGE StrictData #-} +module Language.GLSL.PrettyPrint where + +import Data.List (intersperse) +import qualified Data.Text.Lazy as LT +import qualified Data.Text.Lazy.Builder as LTB +import qualified Data.Text.Lazy.Builder.Int as LTB +import qualified Data.Text.Lazy.Builder.RealFloat as LTB +import Language.GLSL.AST + + +printShader :: Annot a => GLSL a -> LT.Text +printShader = LTB.toLazyText . ppGLSL + +-- | Pretty-print GLSL + +ppGLSL :: Annot a => GLSL a -> LTB.Builder +ppGLSL (GLSL v decls) = + ppVersion v + <> "\n" <> ppL ppTopDecl decls + +-- | Pretty-print Version + +ppVersion :: Version -> LTB.Builder +ppVersion (Version v) = "#version " <> ppInt v + +-- | Pretty-print TopDecl + +ppTopDecl :: Annot a => TopDecl a -> LTB.Builder +ppTopDecl (LayoutDecl e d) = "layout(" <> ppLayoutSpec e <> ") " <> ppGlobalDecl d +ppTopDecl (GlobalDecl d) = ppGlobalDecl d +ppTopDecl (ProcDecl n a b) = + "void " <> ppProcName n + <> "(" <> ppS "," ppParamDecl a <> ") {\n" + <> ppL ppStmtAnnot b + <> "}\n" + +-- | Pretty-print ProcName + +ppProcName :: ProcName -> LTB.Builder +ppProcName ProcMain = "main" +ppProcName (ProcName n) = "p" <> ppNameId n + +-- | Pretty-print LayoutSpec + +ppLayoutSpec :: LayoutSpec -> LTB.Builder +ppLayoutSpec LayoutStd140 = "std140" +ppLayoutSpec (LayoutLocation l) = "location = " <> ppInt l + +-- | Pretty-print ParamDecl + +ppParamDecl :: ParamDecl -> LTB.Builder +ppParamDecl (Param k d) = + ppParamKind k <> " " <> ppLocalDecl d + +-- | Pretty-print ParamKind + +ppParamKind :: ParamKind -> LTB.Builder +ppParamKind PkIn = "in" +ppParamKind PkOut = "out" +ppParamKind PkInout = "inout" + +-- | Pretty-print LocalDecl + +ppLocalDecl :: LocalDecl -> LTB.Builder +ppLocalDecl (LDecl t n Nothing) = + ppType t + <> " t" <> ppNameId n <> ";\n" +ppLocalDecl (LDecl t n (Just e)) = + ppType t + <> " t" <> ppNameId n + <> " = " <> ppExpr e <> ";\n" + +-- | Pretty-print GlobalDecl + +ppGlobalDecl :: GlobalDecl -> LTB.Builder +ppGlobalDecl (GDecl k t n) = + ppGDeclKind k + <> " " <> ppType t + <> " " <> ppName n <> ";\n" + +-- | Pretty-print GDeclKind + +ppGDeclKind :: GDeclKind -> LTB.Builder +ppGDeclKind GkIn = "in" +ppGDeclKind GkOut = "out" +ppGDeclKind GkUniform = "uniform" + +-- | Pretty-print Type + +ppType :: Type -> LTB.Builder +ppType TyBool = "bool" +ppType TyFloat = "float" +ppType TySampler2D = "sampler2D" +ppType (TyVec n) = "vec" <> ppInt n +ppType (TyMat n m) = "mat" <> ppInt n <> "x" <> ppInt m +ppType (TyStruct n ms) = + "uBlock" <> ppNameId n + <> " {\n" <> ppL ppStructMember ms <> "}" + where ppStructMember (t, m) = ppType t <> " u" <> ppNameId m <> ";\n" + +-- | Pretty-print NameId + +ppNameId :: NameId -> LTB.Builder +ppNameId (NameId n) = ppInt n + +-- | Pretty-print Name + +ppName :: Name -> LTB.Builder +ppName (Name ns n) = ppNamespace ns <> ppNameId n + +-- | Pretty-print Namespace + +ppNamespace :: Namespace -> LTB.Builder +ppNamespace NsT = "t" +ppNamespace NsS = "s" +ppNamespace NsU = "u" +ppNamespace NsVF = "vf" +ppNamespace NsIn = "in" +ppNamespace NsOut = "out" + +-- | Pretty-print FunName + +ppFunName :: FunName -> LTB.Builder +ppFunName PrimAbs = "abs" +ppFunName PrimAsin = "asin" +ppFunName PrimAtan = "atan" +ppFunName PrimCos = "cos" +ppFunName PrimCross = "cross" +ppFunName PrimDot = "dot" +ppFunName PrimFloor = "floor" +ppFunName PrimFract = "fract" +ppFunName PrimLength = "length" +ppFunName PrimMat3x3 = "mat3x3" +ppFunName PrimMat4x4 = "mat4x4" +ppFunName PrimMod = "mod" +ppFunName PrimNormalize = "normalize" +ppFunName PrimPow = "pow" +ppFunName PrimSin = "sin" +ppFunName PrimSmoothstep = "smoothstep" +ppFunName PrimSqrt = "sqrt" +ppFunName PrimStep = "step" +ppFunName PrimTan = "tan" +ppFunName PrimVec2 = "vec2" +ppFunName PrimVec3 = "vec3" +ppFunName PrimVec4 = "vec4" + +-- | Pretty-print Swizzle + +ppSwizzle :: Swizzle -> LTB.Builder +ppSwizzle X = "x" +ppSwizzle Y = "y" +ppSwizzle Z = "z" +ppSwizzle W = "w" + +-- | Pretty-print VecIndex (Swizzle) + +ppVecIndex :: Swizzle -> LTB.Builder +ppVecIndex X = "0" +ppVecIndex Y = "1" +ppVecIndex Z = "2" +ppVecIndex W = "3" + +-- | Pretty-print NameExpr + +ppNameExpr :: NameExpr -> LTB.Builder +ppNameExpr (NameExpr n) = ppName n +ppNameExpr (UniformExpr n m) = "u" <> ppNameId n <> ".u" <> ppNameId m + +-- | Pretty-print ExprAtom + +ppExprAtom :: ExprAtom -> LTB.Builder +ppExprAtom (LitIntExpr Cast i) = "int(" <> ppInt i <> ")" +ppExprAtom (LitIntExpr NoCast i) = ppInt i +ppExprAtom (LitFloatExpr Cast n) = "float(" <> ppFloat n <> ")" +ppExprAtom (LitFloatExpr NoCast r) = ppFloat r +ppExprAtom (IdentifierExpr n) = ppNameExpr n +ppExprAtom (SwizzleExpr n m) = "t" <> ppNameId n <> "." <> ppSwizzle m +ppExprAtom (VecIndexExpr n i) = ppNameExpr n <> "[" <> ppVecIndex i <> "]" +ppExprAtom (MatIndexExpr n i j) = ppNameExpr n <> "[" <> ppVecIndex i <> "]" <> "[" <> ppVecIndex j <> "]" + +-- | Pretty-print Expr + +ppExpr :: Expr -> LTB.Builder +ppExpr (AtomExpr e) = ppExprAtom e +ppExpr (UnaryExpr o e) = "(" <> ppUnaryOp o <> ppExprAtom e <> ")" +ppExpr (BinaryExpr l o r) = "(" <> ppExprAtom l <> ppBinaryOp o <> ppExprAtom r <> ")" +ppExpr (FunCallExpr n args) = ppFunName n <> "(" <> ppS "," ppExprAtom args <> ")" +ppExpr (TextureExpr t x y) = "texture(" <> ppExprAtom t <> ",vec2(" <> ppExprAtom x <> "," <> ppExprAtom y <> "))" + +-- | Pretty-print BinaryOp + +ppBinaryOp :: BinaryOp -> LTB.Builder +ppBinaryOp BOpPlus = "+" +ppBinaryOp BOpMinus = "-" +ppBinaryOp BOpMul = "*" +ppBinaryOp BOpDiv = "/" +ppBinaryOp BOpGE = ">=" +ppBinaryOp BOpGT = ">" +ppBinaryOp BOpLE = "<=" +ppBinaryOp BOpLT = "<" +ppBinaryOp BOpAnd = "&&" +ppBinaryOp BOpOr = "||" + +-- | Pretty-print UnaryOp + +ppUnaryOp :: UnaryOp -> LTB.Builder +ppUnaryOp UOpMinus = "-" +ppUnaryOp UOpNot = "!" + +-- | Pretty-print StmtAnnot + +ppStmtAnnot :: Annot a => StmtAnnot a -> LTB.Builder +ppStmtAnnot (SA a s) = + maybe "" (\ltb -> "// " <> ltb <> "\n") (ppAnnot a) <> ppStmt s + +-- | Pretty-print Stmt + +ppStmt :: Annot a => Stmt a -> LTB.Builder +ppStmt (AssignStmt n e) = ppName n <> " = " <> ppExpr e <> ";\n" +ppStmt (DeclStmt d) = ppLocalDecl d +ppStmt (EmitStmt e) = ppEmit e +ppStmt (IfStmt c t e) = + "if(t" <> ppNameId c <> "){\n" + <> ppL ppStmtAnnot t + <> "} else {\n" + <> ppL ppStmtAnnot e + <> "}\n" + +-- | Pretty-print Emit + +ppEmit :: Emit -> LTB.Builder +ppEmit (EmitPosition e) = "gl_Position = " <> ppExpr e <> ";\n" +ppEmit EmitFragDepth = "gl_FragDepth = gl_FragCoord[2];\n" + +-- | Pretty-printing utility + +ppInt :: Int -> LTB.Builder +ppInt = LTB.decimal + +ppFloat :: Float -> LTB.Builder +ppFloat = LTB.realFloat + +ppL :: (a -> LTB.Builder) -> [a] -> LTB.Builder +ppL printer = mconcat . map printer + +ppS :: LTB.Builder -> (a -> LTB.Builder) -> [a] -> LTB.Builder +ppS sep printer = mconcat . intersperse sep . map printer + +---------------------------------- +-- Pretty-printing to String + +pp :: (a -> LTB.Builder) -> a -> String +pp printer = LT.unpack . LTB.toLazyText . printer + +ppl :: (a -> LTB.Builder) -> [a] -> String +ppl printer = LT.unpack . LTB.toLazyText . ppL printer + +pps :: LTB.Builder -> (a -> LTB.Builder) -> [a] -> String +pps sep printer = LT.unpack . LTB.toLazyText . ppS sep printer diff --git a/src/Language/GLSL/Runtime/Eval.hs b/src/Language/GLSL/Runtime/Eval.hs --- a/src/Language/GLSL/Runtime/Eval.hs +++ b/src/Language/GLSL/Runtime/Eval.hs @@ -15,9 +15,14 @@ import qualified Data.Text.Lazy as LT import qualified Data.Text.Lazy.IO as IO import qualified Debug.Trace as Trace +import Language.GLSL.AST import Language.GLSL.Decls (addDecl, addDeclN, addDeclNE, emptyDecls, getDeclNE, toUniformId) +import Language.GLSL.Parser (parseShader) +import Language.GLSL.PrettyPrint (pp, ppExpr, ppGlobalDecl, + ppNameExpr, ppSwizzle, + ppVecIndex) import qualified Language.GLSL.Runtime.PrimFuns as PrimFuns import Language.GLSL.Runtime.Value (Eval, EvalResult (..), EvalState (..), Proc (..), @@ -25,7 +30,6 @@ evalBinaryOp, evalCoerce, evalUnaryOp, isNaNValue, roundValue) -import Language.GLSL.Types import Linear (R1 (..), R2 (..), R3 (..), R4 (..)) diff --git a/src/Language/GLSL/Runtime/PrimFuns.hs b/src/Language/GLSL/Runtime/PrimFuns.hs --- a/src/Language/GLSL/Runtime/PrimFuns.hs +++ b/src/Language/GLSL/Runtime/PrimFuns.hs @@ -1,11 +1,11 @@ module Language.GLSL.Runtime.PrimFuns where import Control.Monad ((>=>)) +import Language.GLSL.AST (FunName (..), Type (..)) +import Language.GLSL.PrettyPrint (pp, ppFunName) import Language.GLSL.Runtime.Math (floor, fract, mod, smoothstep, step) import Language.GLSL.Runtime.Value (Eval, Value (..), evalCoerce) -import Language.GLSL.Types (FunName (..), Type (..), pp, - ppFunName) import Linear import Prelude hiding (floor, mod) diff --git a/src/Language/GLSL/Runtime/Value.hs b/src/Language/GLSL/Runtime/Value.hs --- a/src/Language/GLSL/Runtime/Value.hs +++ b/src/Language/GLSL/Runtime/Value.hs @@ -4,8 +4,11 @@ import Control.Monad.Trans.State.Strict (StateT) import qualified Data.IntMap as M +import Language.GLSL.AST (BinaryOp (..), ParamDecl, + StmtAnnot, Type (..), + UnaryOp (..)) import Language.GLSL.Decls (Decls) -import Language.GLSL.Types +import Language.GLSL.PrettyPrint (pp, ppType) import Linear (M44, V2, V3, V4, (!*!), (!*)) data Proc diff --git a/src/Language/GLSL/StructuralEquality.hs b/src/Language/GLSL/StructuralEquality.hs --- a/src/Language/GLSL/StructuralEquality.hs +++ b/src/Language/GLSL/StructuralEquality.hs @@ -1,46 +1,53 @@ -- | Structural equality, ignoring the variable names. module Language.GLSL.StructuralEquality where +import Language.GLSL.AST import Language.GLSL.ConstExpr (ConstExprs, isConstExpr) -import Language.GLSL.Types -eqStmtAnnots :: ConstExprs -> [(StmtAnnot a, StmtAnnot a)] -> Bool +eqStmtAnnots :: Maybe ConstExprs -> [(StmtAnnot a, StmtAnnot a)] -> Bool eqStmtAnnots ce = all (uncurry (eqStmtAnnot ce)) -eqStmtAnnot :: ConstExprs -> StmtAnnot a -> StmtAnnot a -> Bool +eqStmtAnnot :: Maybe ConstExprs -> StmtAnnot a -> StmtAnnot a -> Bool eqStmtAnnot ce (SA _ a) (SA _ b) = eqStmt ce a b -eqStmt :: ConstExprs -> Stmt a -> Stmt a -> Bool +eqStmt :: Maybe ConstExprs -> Stmt a -> Stmt a -> Bool eqStmt ce (AssignStmt _ ea) (AssignStmt _ eb) = - -- We consider constant expressions to be equal, since we can just pass that - -- constant into the function as an argument. Most of the time, it's small - -- things like 1.0 or (-1.0) (possibly in a t-var, hence the ConstExprs set). - isConstExpr ce ea && isConstExpr ce eb || - eqExpr ea eb -eqStmt _ (DeclStmt da) (DeclStmt db) = - eqLocalDecl da db -eqStmt _ (EmitStmt ea) (EmitStmt eb) = - eqEmit ea eb + eqExpr ce ea eb +eqStmt ce (DeclStmt da) (DeclStmt db) = + eqLocalDecl ce da db +eqStmt ce (EmitStmt ea) (EmitStmt eb) = + eqEmit ce ea eb eqStmt ce (IfStmt _ ta ea) (IfStmt _ tb eb) = + length ta == length tb && + length ea == length eb && eqStmtAnnots ce (zip ta tb) && eqStmtAnnots ce (zip ea eb) eqStmt _ _ _ = False -eqExpr :: Expr -> Expr -> Bool -eqExpr (AtomExpr ea) (AtomExpr eb) = +eqExpr :: Maybe ConstExprs -> Expr -> Expr -> Bool +-- We consider constant expressions to be equal, since we can just pass that +-- constant into the function as an argument. Most of the time, it's small +-- things like 1.0 or (-1.0) (possibly in a t-var, hence the ConstExprs set). +eqExpr (Just ce) a b | isConstExpr ce a && isConstExpr ce b = True +eqExpr _ (AtomExpr ea) (AtomExpr eb) = eqExprAtom ea eb -eqExpr (UnaryExpr ua ea) (UnaryExpr ub eb) = - ua == ub && eqExprAtom ea eb -eqExpr (FunCallExpr fa aa) (FunCallExpr fb ab) = - fa == fb && all (uncurry eqExprAtom) (zip aa ab) -eqExpr (TextureExpr ta xa ya) (TextureExpr tb xb yb) = +eqExpr _ (UnaryExpr ua ea) (UnaryExpr ub eb) = + ua == ub && + eqExprAtom ea eb +eqExpr _ (FunCallExpr fa aa) (FunCallExpr fb ab) = + fa == fb && + length aa == length ab && + all (uncurry eqExprAtom) (zip aa ab) +eqExpr _ (TextureExpr ta xa ya) (TextureExpr tb xb yb) = all (uncurry eqExprAtom) [(ta, tb), (xa, xb), (ya, yb)] -eqExpr (BinaryExpr la oa ra) (BinaryExpr lb ob rb) = - oa == ob && eqExprAtom la lb && eqExprAtom ra rb -eqExpr _ _ = +eqExpr _ (BinaryExpr la oa ra) (BinaryExpr lb ob rb) = + oa == ob && + eqExprAtom la lb && + eqExprAtom ra rb +eqExpr _ _ _ = False @@ -64,24 +71,24 @@ -- this is rare enough so it won't increase the average function parameter -- list length too much. eqNameExpr :: NameExpr -> NameExpr -> Bool -eqNameExpr (UniformExpr na ma) (UniformExpr nb mb) = na == nb && ma == mb +-- eqNameExpr (UniformExpr na ma) (UniformExpr nb mb) = na == nb && ma == mb -- eqName (Name NsT _) (Name NsT _) = True -- eqName (Name nsa na) (Name nsb nb) = nsa == nsb && na == nb eqNameExpr _ _ = True -eqLocalDecl :: LocalDecl -> LocalDecl -> Bool -eqLocalDecl (LDecl tya _ ea) (LDecl tyb _ eb) = - eqType tya tyb && eqMaybe eqExpr ea eb +eqLocalDecl :: Maybe ConstExprs -> LocalDecl -> LocalDecl -> Bool +eqLocalDecl ce (LDecl tya _ ea) (LDecl tyb _ eb) = + eqType tya tyb && eqMaybe (eqExpr ce) ea eb eqType :: Type -> Type -> Bool eqType = (==) -eqEmit :: Emit -> Emit -> Bool -eqEmit (EmitPosition a) (EmitPosition b) = eqExpr a b -eqEmit EmitFragDepth EmitFragDepth = True -eqEmit _ _ = False +eqEmit :: Maybe ConstExprs -> Emit -> Emit -> Bool +eqEmit ce (EmitPosition a) (EmitPosition b) = eqExpr ce a b +eqEmit _ EmitFragDepth EmitFragDepth = True +eqEmit _ _ _ = False eqMaybe :: (a -> a -> Bool) -> Maybe a -> Maybe a -> Bool diff --git a/src/Language/GLSL/Types.hs b/src/Language/GLSL/Types.hs deleted file mode 100644 --- a/src/Language/GLSL/Types.hs +++ /dev/null @@ -1,650 +0,0 @@ -{-# LANGUAGE DeriveFunctor #-} -{-# LANGUAGE DeriveTraversable #-} -{-# LANGUAGE OverloadedStrings #-} -{-# LANGUAGE StrictData #-} -{-# OPTIONS_GHC -Wno-name-shadowing #-} -module Language.GLSL.Types where - -import Control.Applicative (Applicative (..), (<|>)) -import Data.Attoparsec.ByteString.Char8 (IResult (Partial), Parser, - char, decimal, endOfInput, - many1, option, parse, - parseOnly, rational, - scientific, sepBy1) -import Data.List (intersperse) -import qualified Data.Scientific as Sci -import qualified Data.Text.Encoding as T -import qualified Data.Text.Lazy as LT -import qualified Data.Text.Lazy.Builder as LTB -import qualified Data.Text.Lazy.Builder.Int as LTB -import qualified Data.Text.Lazy.Builder.RealFloat as LTB - - -parseShader :: Annot a => LT.Text -> Either String (GLSL a) -parseShader = parseOnly parseGLSL . T.encodeUtf8 . LT.toStrict - -printShader :: Annot a => GLSL a -> LT.Text -printShader = LTB.toLazyText . ppGLSL - - -data GLSL a = GLSL Version [TopDecl a] - deriving (Show, Functor, Foldable, Traversable) - -parseGLSL :: Annot a => Parser (GLSL a) -parseGLSL = GLSL - <$> parseVersion - <*> ("\n" >> many1 parseTopDecl >>= (endOfInput >>) . pure) - -ppGLSL :: Annot a => GLSL a -> LTB.Builder -ppGLSL (GLSL v decls) = - ppVersion v - <> "\n" <> ppL ppTopDecl decls - -newtype Version = Version Int - deriving (Show) - -parseVersion :: Parser Version -parseVersion = Version <$> ("#version " >> decimal) - -ppVersion :: Version -> LTB.Builder -ppVersion (Version v) = "#version " <> ppInt v - -data TopDecl a - = LayoutDecl LayoutSpec GlobalDecl - | GlobalDecl GlobalDecl - | ProcDecl ProcName [ParamDecl] [StmtAnnot a] - deriving (Show, Functor, Foldable, Traversable) - -parseTopDecl :: Annot a => Parser (TopDecl a) -parseTopDecl = layoutDecl <|> globalDecl <|> procDecl - where - layoutDecl = LayoutDecl - <$> ("layout(" >> parseLayoutSpec) - <*> (") " >> parseGlobalDecl) - - globalDecl = GlobalDecl - <$> parseGlobalDecl - - procDecl = ProcDecl - <$> ("void " >> parseProcName) - <*> ("() " >> pure []) - -- <*> ("{\n" >> many1 parseStmtAnnot) - <*> ("{\n" >> many1 parseStmtAnnot >>= ("}\n" >>) . pure) - -ppTopDecl :: Annot a => TopDecl a -> LTB.Builder -ppTopDecl (LayoutDecl e d) = "layout(" <> ppLayoutSpec e <> ") " <> ppGlobalDecl d -ppTopDecl (GlobalDecl d) = ppGlobalDecl d -ppTopDecl (ProcDecl n a b) = - "void " <> ppProcName n - <> "(" <> ppS "," ppParamDecl a <> ") {\n" - <> ppL ppStmtAnnot b - <> "}\n" - -data ProcName - = ProcMain - | ProcName NameId - deriving (Show) - -parseProcName :: Parser ProcName -parseProcName = - ("main" >> pure ProcMain) - <|> ("p" >> ProcName <$> parseNameId) - -ppProcName :: ProcName -> LTB.Builder -ppProcName ProcMain = "main" -ppProcName (ProcName n) = "p" <> ppNameId n - -data LayoutSpec - = LayoutStd140 - | LayoutLocation Int - deriving (Show) - -parseLayoutSpec :: Parser LayoutSpec -parseLayoutSpec = - ("std140" >> pure LayoutStd140) - <|> ("location = " >> LayoutLocation <$> decimal) - -ppLayoutSpec :: LayoutSpec -> LTB.Builder -ppLayoutSpec LayoutStd140 = "std140" -ppLayoutSpec (LayoutLocation l) = "location = " <> ppInt l - -data ParamDecl - = Param ParamKind LocalDecl - deriving (Show) - -parseParamDecl :: Parser ParamDecl -parseParamDecl = Param - <$> parseParamKind - <*> (" " >> parseLocalDecl) - -ppParamDecl :: ParamDecl -> LTB.Builder -ppParamDecl (Param k d) = - ppParamKind k <> " " <> ppLocalDecl d - -data ParamKind - = PkIn - | PkOut - | PkInout - deriving (Show) - -parseParamKind :: Parser ParamKind -parseParamKind = (char ' ' <|> pure ' ') >> - ("in" >> return PkIn) <|> - ("out" >> return PkOut) <|> - ("inout" >> return PkInout) - -ppParamKind :: ParamKind -> LTB.Builder -ppParamKind PkIn = "in" -ppParamKind PkOut = "out" -ppParamKind PkInout = "inout" - -data LocalDecl - = LDecl Type NameId (Maybe Expr) - deriving (Show) - -parseLocalDecl :: Parser LocalDecl -parseLocalDecl = LDecl - <$> parseType - <*> (" t" >> parseNameId) - <*> (option Nothing (" = " >> Just <$> parseExpr) >>= (";\n" >>) . pure) - -ppLocalDecl :: LocalDecl -> LTB.Builder -ppLocalDecl (LDecl t n Nothing) = - ppType t - <> " t" <> ppNameId n <> ";\n" -ppLocalDecl (LDecl t n (Just e)) = - ppType t - <> " t" <> ppNameId n - <> " = " <> ppExpr e <> ";\n" - -data GlobalDecl - = GDecl GDeclKind Type Name - deriving (Show) - -parseGlobalDecl :: Parser GlobalDecl -parseGlobalDecl = GDecl - <$> parseGDeclKind - <*> (" " >> parseType) - <*> (" " >> parseName >>= (";\n" >>) . pure) - -ppGlobalDecl :: GlobalDecl -> LTB.Builder -ppGlobalDecl (GDecl k t n) = - ppGDeclKind k - <> " " <> ppType t - <> " " <> ppName n <> ";\n" - -data GDeclKind - = GkIn - | GkOut - | GkUniform - deriving (Show) - -parseGDeclKind :: Parser GDeclKind -parseGDeclKind = - ("in" >> return GkIn) <|> - ("out" >> return GkOut) <|> - ("uniform" >> return GkUniform) - -ppGDeclKind :: GDeclKind -> LTB.Builder -ppGDeclKind GkIn = "in" -ppGDeclKind GkOut = "out" -ppGDeclKind GkUniform = "uniform" - -data Type - = TyBool - | TyFloat - | TySampler2D - | TyVec Int - | TyMat Int Int - | TyStruct NameId [(Type, NameId)] - deriving (Show, Eq) - -parseType :: Parser Type -parseType = - ("bool" >> return TyBool) - <|> ("float" >> return TyFloat) - <|> ("sampler2D" >> return TySampler2D) - <|> ("vec" >> TyVec <$> decimal) - <|> ("mat" >> TyMat <$> decimal <*> ("x" >> decimal)) - <|> tyStruct - where - tyStruct = TyStruct - <$> ("uBlock" >> parseNameId) - <*> (" {\n" >> many1 parseStructMember >>= ("}" >>) . pure) - - parseStructMember :: Parser (Type, NameId) - parseStructMember = (,) - <$> parseType - <*> (" u" >> parseNameId >>= (";\n" >>) . pure) - -ppType :: Type -> LTB.Builder -ppType TyBool = "bool" -ppType TyFloat = "float" -ppType TySampler2D = "sampler2D" -ppType (TyVec n) = "vec" <> ppInt n -ppType (TyMat n m) = "mat" <> ppInt n <> "x" <> ppInt m -ppType (TyStruct n ms) = - "uBlock" <> ppNameId n - <> " {\n" <> ppL ppStructMember ms <> "}" - where ppStructMember (t, n) = ppType t <> " u" <> ppNameId n <> ";\n" - -newtype NameId = NameId Int - deriving (Show, Eq) - -parseNameId :: Parser NameId -parseNameId = NameId - <$> decimal - -ppNameId :: NameId -> LTB.Builder -ppNameId (NameId n) = ppInt n - -data Name - = Name Namespace NameId - deriving (Show) - -parseName :: Parser Name -parseName = Name - <$> parseNamespace - <*> parseNameId - -ppName :: Name -> LTB.Builder -ppName (Name ns n) = ppNamespace ns <> ppNameId n - -data Namespace - = NsT - | NsS - | NsU - | NsVF - | NsIn - | NsOut - deriving (Show, Eq) - -parseNamespace :: Parser Namespace -parseNamespace = - ("in" >> pure NsIn) - <|> ("out" >> pure NsOut) - <|> ("vf" >> pure NsVF) - <|> (char 't' >> pure NsT) - <|> (char 'u' >> pure NsU) - <|> (char 's' >> pure NsS) - -ppNamespace :: Namespace -> LTB.Builder -ppNamespace NsT = "t" -ppNamespace NsS = "s" -ppNamespace NsU = "u" -ppNamespace NsVF = "vf" -ppNamespace NsIn = "in" -ppNamespace NsOut = "out" - -data FunName - = PrimMain - | PrimMat3x3 - | PrimMat4x4 - | PrimVec2 - | PrimVec3 - | PrimVec4 - | PrimPow - | PrimDot - | PrimCos - | PrimAtan - | PrimMod - | PrimAbs - | PrimCross - | PrimLength - | PrimAsin - | PrimSmoothstep - | PrimStep - | PrimFract - | PrimFloor - | PrimSin - | PrimTan - | PrimSqrt - | PrimNormalize - deriving (Show, Eq) - -parseFunName :: Parser FunName -parseFunName = - ("main" >> pure PrimMain) - <|> ("mat3x3" >> pure PrimMat3x3) - <|> ("mat4x4" >> pure PrimMat4x4) - <|> ("vec2" >> pure PrimVec2) - <|> ("vec3" >> pure PrimVec3) - <|> ("vec4" >> pure PrimVec4) - <|> ("pow" >> pure PrimPow) - <|> ("dot" >> pure PrimDot) - <|> ("cos" >> pure PrimCos) - <|> ("atan" >> pure PrimAtan) - <|> ("mod" >> pure PrimMod) - <|> ("abs" >> pure PrimAbs) - <|> ("cross" >> pure PrimCross) - <|> ("length" >> pure PrimLength) - <|> ("asin" >> pure PrimAsin) - <|> ("smoothstep" >> pure PrimSmoothstep) - <|> ("step" >> pure PrimStep) - <|> ("fract" >> pure PrimFract) - <|> ("floor" >> pure PrimFloor) - <|> ("sin" >> pure PrimSin) - <|> ("tan" >> pure PrimTan) - <|> ("sqrt" >> pure PrimSqrt) - <|> ("normalize" >> pure PrimNormalize) - -ppFunName :: FunName -> LTB.Builder -ppFunName PrimMain = "main" -ppFunName PrimMat3x3 = "mat3x3" -ppFunName PrimMat4x4 = "mat4x4" -ppFunName PrimVec2 = "vec2" -ppFunName PrimVec3 = "vec3" -ppFunName PrimVec4 = "vec4" -ppFunName PrimPow = "pow" -ppFunName PrimDot = "dot" -ppFunName PrimCos = "cos" -ppFunName PrimAtan = "atan" -ppFunName PrimMod = "mod" -ppFunName PrimAbs = "abs" -ppFunName PrimCross = "cross" -ppFunName PrimLength = "length" -ppFunName PrimAsin = "asin" -ppFunName PrimSmoothstep = "smoothstep" -ppFunName PrimStep = "step" -ppFunName PrimFract = "fract" -ppFunName PrimFloor = "floor" -ppFunName PrimSin = "sin" -ppFunName PrimTan = "tan" -ppFunName PrimSqrt = "sqrt" -ppFunName PrimNormalize = "normalize" - -data Swizzle - = X | Y | Z | W - deriving (Show, Eq) - -parseSwizzle :: Parser Swizzle -parseSwizzle = - (char 'x' >> pure X) - <|> (char 'y' >> pure Y) - <|> (char 'z' >> pure Z) - <|> (char 'w' >> pure W) - -ppSwizzle :: Swizzle -> LTB.Builder -ppSwizzle X = "x" -ppSwizzle Y = "y" -ppSwizzle Z = "z" -ppSwizzle W = "w" - -parseVecIndex :: Parser Swizzle -parseVecIndex = - (char '0' >> pure X) - <|> (char '1' >> pure Y) - <|> (char '2' >> pure Z) - <|> (char '3' >> pure W) - -ppVecIndex :: Swizzle -> LTB.Builder -ppVecIndex X = "0" -ppVecIndex Y = "1" -ppVecIndex Z = "2" -ppVecIndex W = "3" - -data NameExpr - = NameExpr Name - | UniformExpr NameId NameId - deriving (Show) - -parseNameExpr :: Parser NameExpr -parseNameExpr = - UniformExpr <$> (char 'u' >> parseNameId) <*> (".u" >> parseNameId) - <|> NameExpr <$> parseName - -ppNameExpr :: NameExpr -> LTB.Builder -ppNameExpr (NameExpr n) = ppName n -ppNameExpr (UniformExpr n m) = "u" <> ppNameId n <> ".u" <> ppNameId m - -data Cast - = Cast - | NoCast - deriving (Show) - -data ExprAtom - = LitIntExpr Cast Int - | LitFloatExpr Cast Float - | IdentifierExpr NameExpr - | SwizzleExpr NameId Swizzle - | VecIndexExpr NameExpr Swizzle - | MatIndexExpr NameExpr Swizzle Swizzle - deriving (Show) - -parseExprAtom :: Parser ExprAtom -parseExprAtom = - litNumber <$> scientific - <|> LitIntExpr Cast <$> ("int(" >> decimal >>= (")" >>) . pure) - <|> LitFloatExpr Cast <$> ("float(" >> rational >>= (")" >>) . pure) - <|> SwizzleExpr <$> (char 't' >> parseNameId) <*> (char '.' >> parseSwizzle) - <|> MatIndexExpr <$> parseNameExpr <*> ("[" >> parseVecIndex) <*> ("][" >> parseVecIndex >>= ("]" >>) . pure) - <|> VecIndexExpr <$> parseNameExpr <*> ("[" >> parseVecIndex >>= ("]" >>) . pure) - <|> IdentifierExpr <$> parseNameExpr - where - litNumber s = - let e = Sci.base10Exponent s - c = Sci.coefficient s - in if e >= 0 - then LitIntExpr NoCast (fromInteger (c * 10 ^ e)) - else LitFloatExpr NoCast (Sci.toRealFloat s) - -ppExprAtom :: ExprAtom -> LTB.Builder -ppExprAtom (LitIntExpr Cast i) = "int(" <> ppInt i <> ")" -ppExprAtom (LitIntExpr NoCast i) = ppInt i -ppExprAtom (LitFloatExpr Cast n) = "float(" <> ppFloat n <> ")" -ppExprAtom (LitFloatExpr NoCast r) = ppFloat r -ppExprAtom (IdentifierExpr n) = ppNameExpr n -ppExprAtom (SwizzleExpr n m) = "t" <> ppNameId n <> "." <> ppSwizzle m -ppExprAtom (VecIndexExpr n i) = ppNameExpr n <> "[" <> ppVecIndex i <> "]" -ppExprAtom (MatIndexExpr n i j) = ppNameExpr n <> "[" <> ppVecIndex i <> "]" <> "[" <> ppVecIndex j <> "]" - -data Expr - = UnaryExpr UnaryOp ExprAtom - | BinaryExpr ExprAtom BinaryOp ExprAtom - | FunCallExpr FunName [ExprAtom] - | TextureExpr ExprAtom ExprAtom ExprAtom - | AtomExpr ExprAtom - deriving (Show) - -parseExpr :: Parser Expr -parseExpr = - (char '(' >> operatorExpr >>= (char ')' >>) . pure) - <|> textureExpr - <|> funCallExpr - <|> AtomExpr <$> parseExprAtom - - where - operatorExpr = - BinaryExpr <$> parseExprAtom <*> parseBinaryOp <*> parseExprAtom - <|> UnaryExpr <$> parseUnaryOp <*> parseExprAtom - - textureExpr = TextureExpr - <$> ("texture(" >> parseExprAtom) - <*> (",vec2(" >> parseExprAtom) - <*> ("," >> parseExprAtom >>= ("))" >>) . pure) - - funCallExpr = FunCallExpr - <$> parseFunName - <*> (char '(' >> sepBy1 parseExprAtom (char ',') >>= (char ')' >>) . pure) - -ppExpr :: Expr -> LTB.Builder -ppExpr (AtomExpr e) = ppExprAtom e -ppExpr (UnaryExpr o e) = "(" <> ppUnaryOp o <> ppExprAtom e <> ")" -ppExpr (BinaryExpr l o r) = "(" <> ppExprAtom l <> ppBinaryOp o <> ppExprAtom r <> ")" -ppExpr (FunCallExpr n args) = ppFunName n <> "(" <> ppS "," ppExprAtom args <> ")" -ppExpr (TextureExpr t x y) = "texture(" <> ppExprAtom t <> ",vec2(" <> ppExprAtom x <> "," <> ppExprAtom y <> "))" - -data BinaryOp - = BOpPlus - | BOpMinus - | BOpMul - | BOpDiv - | BOpGE - | BOpGT - | BOpLE - | BOpLT - | BOpAnd - | BOpOr - deriving (Show, Eq) - -parseBinaryOp :: Parser BinaryOp -parseBinaryOp = - (char '+' >> pure BOpPlus) - <|> (char '-' >> pure BOpMinus) - <|> (char '*' >> pure BOpMul) - <|> (char '/' >> pure BOpDiv) - <|> (">=" >> pure BOpGE) - <|> (">" >> pure BOpGT) - <|> ("<=" >> pure BOpLE) - <|> ("<" >> pure BOpLT) - <|> ("&&" >> pure BOpAnd) - <|> ("||" >> pure BOpOr) - -ppBinaryOp :: BinaryOp -> LTB.Builder -ppBinaryOp BOpPlus = "+" -ppBinaryOp BOpMinus = "-" -ppBinaryOp BOpMul = "*" -ppBinaryOp BOpDiv = "/" -ppBinaryOp BOpGE = ">=" -ppBinaryOp BOpGT = ">" -ppBinaryOp BOpLE = "<=" -ppBinaryOp BOpLT = "<" -ppBinaryOp BOpAnd = "&&" -ppBinaryOp BOpOr = "||" - -data UnaryOp - = UOpMinus - | UOpNot - deriving (Show, Eq) - -parseUnaryOp :: Parser UnaryOp -parseUnaryOp = - (char '-' >> pure UOpMinus) - <|> (char '!' >> pure UOpMinus) - -ppUnaryOp :: UnaryOp -> LTB.Builder -ppUnaryOp UOpMinus = "-" -ppUnaryOp UOpNot = "!" - -data StmtAnnot a = SA - { annot :: a - , unAnnot :: Stmt a - } - deriving (Show, Functor, Foldable, Traversable) - -instance Applicative StmtAnnot where - pure a = SA a (pure a) - liftA2 f a b = SA (f (annot a) (annot b)) $ liftA2 f (unAnnot a) (unAnnot b) - -parseStmtAnnot :: Annot a => Parser (StmtAnnot a) -parseStmtAnnot = SA <$> parseAnnot <*> parseStmt - -ppStmtAnnot :: Annot a => StmtAnnot a -> LTB.Builder -ppStmtAnnot (SA a s) = - maybe "" (\ltb -> "// " <> ltb <> "\n") (ppAnnot a) <> ppStmt s - -data Stmt a - = AssignStmt Name Expr - | DeclStmt LocalDecl - | EmitStmt Emit - | IfStmt NameId [StmtAnnot a] [StmtAnnot a] - deriving (Show, Functor, Foldable, Traversable) - -instance Applicative Stmt where - -- Arbitrary decision because "pure" doesn't really make sense. - pure _ = EmitStmt EmitFragDepth - - liftA2 f (IfStmt n t1 e1) (IfStmt _ t2 e2) = IfStmt n - ((zipWith . liftA2) f t1 t2) - ((zipWith . liftA2) f e1 e2) - liftA2 _ (AssignStmt n e) _ = AssignStmt n e - liftA2 _ (DeclStmt d) _ = DeclStmt d - liftA2 _ (EmitStmt e) _ = EmitStmt e - liftA2 _ (IfStmt n _ _) _ = IfStmt n [] [] - - -parseStmt :: Annot a => Parser (Stmt a) -parseStmt = - IfStmt <$> ("if(t" >> parseNameId >>= ("){\n" >>) . pure) - <*> many1 parseStmtAnnot - <*> ("} else {\n" >> many1 parseStmtAnnot >>= ("}\n" >>) . pure) - <|> AssignStmt <$> parseName <*> (" = " >> parseExpr >>= (";\n" >>) . pure) - <|> DeclStmt <$> parseLocalDecl - <|> EmitStmt <$> parseEmit - -ppStmt :: Annot a => Stmt a -> LTB.Builder -ppStmt (AssignStmt n e) = ppName n <> " = " <> ppExpr e <> ";\n" -ppStmt (DeclStmt d) = ppLocalDecl d -ppStmt (EmitStmt e) = ppEmit e -ppStmt (IfStmt c t e) = - "if(t" <> ppNameId c <> "){\n" - <> ppL ppStmtAnnot t - <> "} else {\n" - <> ppL ppStmtAnnot e - <> "}\n" - -data Emit - = EmitPosition Expr - | EmitFragDepth - deriving (Show) - -parseEmit :: Parser Emit -parseEmit = - EmitPosition <$> ("gl_Position = " >> parseExpr >>= (";\n" >>) . pure) - <|> ("gl_FragDepth = gl_FragCoord[2];\n" >> pure EmitFragDepth) - -ppEmit :: Emit -> LTB.Builder -ppEmit (EmitPosition e) = "gl_Position = " <> ppExpr e <> ";\n" -ppEmit EmitFragDepth = "gl_FragDepth = gl_FragCoord[2];\n" - -ppInt :: Int -> LTB.Builder -ppInt = LTB.decimal - -ppFloat :: Float -> LTB.Builder -ppFloat = LTB.realFloat - -ppL :: (a -> LTB.Builder) -> [a] -> LTB.Builder -ppL printer = mconcat . map printer - -ppS :: LTB.Builder -> (a -> LTB.Builder) -> [a] -> LTB.Builder -ppS sep printer = mconcat . intersperse sep . map printer - -class Annot a where - parseAnnot :: Parser a - ppAnnot :: a -> Maybe LTB.Builder - -instance Annot () where - parseAnnot = pure () - ppAnnot = const Nothing - -instance (Annot a, Annot b) => Annot (a, b) where - parseAnnot = error "not implemented" - ppAnnot (a, b) = do - ppA <- ppAnnot a - ppB <- ppAnnot b - return $ "(" <> ppA <> ", " <> ppB <> ")" - ----------------------------------- - -parseTest :: Show a => Parser a -> LT.Text -> IO () -parseTest p input = - let r = show . fromPartial . parse p . T.encodeUtf8 . LT.toStrict $ input in - if length r > 600 - then - let start = take 500 r - end = reverse $ take 100 $ reverse r - in - putStrLn $ start <> " ... " <> end - else putStrLn r - where - fromPartial (Partial cont) = cont mempty - fromPartial r = r - -t :: Show a => Parser a -> String -> IO () -t p = parseTest p . LT.pack - -pp :: (a -> LTB.Builder) -> a -> String -pp printer = LT.unpack . LTB.toLazyText . printer - -ppl :: (a -> LTB.Builder) -> [a] -> String -ppl printer = LT.unpack . LTB.toLazyText . ppL printer diff --git a/test/Language/GLSL/BitCodeSpec.hs b/test/Language/GLSL/BitCodeSpec.hs new file mode 100644 --- /dev/null +++ b/test/Language/GLSL/BitCodeSpec.hs @@ -0,0 +1,108 @@ +{-# LANGUAGE OverloadedStrings #-} +{-# LANGUAGE ScopedTypeVariables #-} +{-# LANGUAGE ViewPatterns #-} +module Language.GLSL.BitCodeSpec where + +import Test.GLSL.Arbitrary () +import Test.Hspec (Spec, describe, it, runIO, + shouldBe, shouldNotBe) +import Test.Hspec.QuickCheck (prop) +import Test.QuickCheck (forAllShrink, shrink) +import qualified Test.QuickCheck.Gen as Gen + +import Control.Monad (forM_, unless, when) +import qualified Data.Text.Lazy.IO as IO +import qualified Data.Vector as V +import Language.GLSL.AST +import Language.GLSL.BitCode (encodeStmt) +import qualified Language.GLSL.ConstExpr as ConstExpr +import Language.GLSL.Parser (parseShader) +import Language.GLSL.StructuralEquality (eqStmt) +import qualified System.Directory as Dir + +-- Run an exhaustive n^2 test comparing every line to every other line in the +-- test file. This takes around 13 seconds on my laptop. +exhaustive :: Bool +exhaustive = False + +getStatements :: FilePath -> IO (V.Vector (Stmt ())) +getStatements path = do + inTopDir <- Dir.doesDirectoryExist "glsl" + when inTopDir $ Dir.setCurrentDirectory "glsl" + glsl <- parseShader <$> IO.readFile path + case glsl of + Left err -> + fail err + Right (GLSL _ (reverse -> (ProcDecl _ _ ss):_)) -> + return . V.fromList . map unAnnot $ ss + Right _ -> + fail "test file does not end with a main function" + + +encodeStmtSpec :: Maybe ConstExpr.ConstExprs -> Spec +encodeStmtSpec ce = do + prop "should produce the same encoding for structurally equal statements" $ + \(s1 :: Stmt ()) (s2 :: Stmt ()) -> + let enc1 = encodeStmt ce s1 + enc2 = encodeStmt ce s2 + in + when (eqStmt ce s1 s2) $ + enc1 `shouldBe` enc2 + + prop "should produce different encoding for structurally different statements" $ + \(s1 :: Stmt ()) (s2 :: Stmt ()) -> + let enc1 = encodeStmt ce s1 + enc2 = encodeStmt ce s2 + in + unless (eqStmt ce s1 s2) $ + enc1 `shouldNotBe` enc2 + + +testFileSpec :: FilePath -> Spec +testFileSpec filename = do + stmts <- runIO $ getStatements $ "test/data/large-shaders/" <> filename + let forAllStmt p = forAllShrink ( + (stmts V.!) <$> Gen.chooseBoundedIntegral (0, V.length stmts - 1)) + shrink p + + it ("should be able to encode all statements from " <> filename) $ do + forM_ stmts $ \s -> + encodeStmt Nothing s + `shouldBe` + encodeStmt Nothing s + + prop ("should obey (a = b) => enc a = enc b for all pairs in " <> filename) $ + forAllStmt $ \s1 -> forAllStmt $ \s2 -> + let enc1 = encodeStmt Nothing s1 + enc2 = encodeStmt Nothing s2 + in + if eqStmt Nothing s1 s2 + then enc1 `shouldBe` enc2 + else enc1 `shouldNotBe` enc2 + + when exhaustive $ + it ("should obey (a = b) => enc a = enc b for every single pair in " <> filename) $ + forM_ [0..V.length stmts - 1] $ \i -> forM_ [i..V.length stmts - 1] $ \j -> + let s1 = stmts V.! i + s2 = stmts V.! j + enc1 = encodeStmt Nothing s1 + enc2 = encodeStmt Nothing s2 + in + if eqStmt Nothing s1 s2 + then enc1 `shouldBe` enc2 + else enc1 `shouldNotBe` enc2 + + + +spec :: Spec +spec = do + describe "encodeStmt" $ do + encodeStmtSpec Nothing + + describe "encodeStmt with ConstExpr" $ do + encodeStmtSpec $ Just ConstExpr.empty + + -- testFileSpec "lambdacnc.frag" + -- testFileSpec "lambdacnc.vert" + testFileSpec "xax.frag" + -- testFileSpec "xax.vert" diff --git a/test/Language/GLSL/GLSLSpec.hs b/test/Language/GLSL/GLSLSpec.hs --- a/test/Language/GLSL/GLSLSpec.hs +++ b/test/Language/GLSL/GLSLSpec.hs @@ -5,7 +5,8 @@ import Control.Applicative (liftA2) import Data.Attoparsec.ByteString.Char8 (decimal) -import qualified Language.GLSL.Types as GLSL +import qualified Language.GLSL.AST as GLSL +import qualified Language.GLSL.PrettyPrint as GLSL import Test.GLSL (Transform, shouldTransformTo, with) diff --git a/test/Language/GLSL/Internal/BitsSpec.hs b/test/Language/GLSL/Internal/BitsSpec.hs new file mode 100644 --- /dev/null +++ b/test/Language/GLSL/Internal/BitsSpec.hs @@ -0,0 +1,20 @@ +{-# LANGUAGE OverloadedStrings #-} +module Language.GLSL.Internal.BitsSpec where + +import Test.Hspec (Spec, describe, it, shouldBe) + +import Language.GLSL.Internal.Bits (B (I, O), flat, unflat) + +spec :: Spec +spec = do + describe "flat" $ do + it "should preserve the order of the input" $ + flat ((O,I),I,(I,O,O,I)) + `shouldBe` + [O,I,I,I,O,O,I] + + describe "unflat" $ do + it "should preserve the order of the input and consume all input" $ + unflat [O,I,I,I,O,O,I] + `shouldBe` + Just (((O,I),I,(I,O,O,I)),[]) diff --git a/test/Language/GLSL/StructuralEqualitySpec.hs b/test/Language/GLSL/StructuralEqualitySpec.hs new file mode 100644 --- /dev/null +++ b/test/Language/GLSL/StructuralEqualitySpec.hs @@ -0,0 +1,46 @@ +{-# LANGUAGE OverloadedStrings #-} +{-# LANGUAGE ScopedTypeVariables #-} +module Language.GLSL.StructuralEqualitySpec where + +import Test.GLSL.Arbitrary () +import Test.Hspec (Spec, describe, it, shouldBe) +import Test.Hspec.QuickCheck (prop) + +import Control.Monad (when) +import Language.GLSL.AST +import qualified Language.GLSL.ConstExpr as ConstExpr +import Language.GLSL.StructuralEquality (eqStmt) + +ce :: Maybe ConstExpr.ConstExprs +ce = Just ConstExpr.empty + +spec :: Spec +spec = do + describe "eqStmt" $ do + prop "should obey (a = b) & (b = c) => (a = c)" $ + \(a :: Stmt ()) (b :: Stmt ()) (c :: Stmt ()) -> + when (eqStmt ce a b && eqStmt ce b c) $ + eqStmt ce a c `shouldBe` True + + prop "should obey (a = b) & (b != c) => (a != c)" $ + \(a :: Stmt ()) (b :: Stmt ()) (c :: Stmt ()) -> + when (eqStmt ce a b && not (eqStmt ce b c)) $ + eqStmt ce a c `shouldBe` False + + prop "should be True for (a == b)" $ + \(a :: Stmt ()) -> + eqStmt ce a a `shouldBe` True + + it "should differentiate constant expressions if we pass no ConstExpr" $ + let n = Name NsT (NameId 0) + a = AssignStmt n (UnaryExpr UOpMinus (LitIntExpr NoCast 0)) + b = AssignStmt n (FunCallExpr PrimAsin []) + in + eqStmt Nothing a b `shouldBe` False + + it "should treat constant expressions as equal if we pass ConstExpr" $ + let n = Name NsT (NameId 0) + a = AssignStmt n (UnaryExpr UOpMinus (LitIntExpr NoCast 0)) + b = AssignStmt n (FunCallExpr PrimAsin []) + in + eqStmt ce a b `shouldBe` True diff --git a/test/Test/GLSL.hs b/test/Test/GLSL.hs --- a/test/Test/GLSL.hs +++ b/test/Test/GLSL.hs @@ -1,14 +1,16 @@ {-# LANGUAGE OverloadedStrings #-} module Test.GLSL where -import Test.Hspec (Expectation, shouldBe) +import Test.Hspec (Expectation, shouldBe) -import Data.Attoparsec.ByteString.Char8 (many1, parseOnly) -import qualified Data.ByteString.Char8 as BS -import Data.String (fromString) -import qualified Data.Text.Lazy as LT -import qualified Data.Text.Lazy.Builder as LTB -import qualified Language.GLSL.Types as GLSL +import Data.Attoparsec.ByteString.Char8 (many1, parseOnly) +import qualified Data.ByteString.Char8 as BS +import Data.String (fromString) +import qualified Data.Text.Lazy as LT +import qualified Data.Text.Lazy.Builder as LTB +import qualified Language.GLSL.AST as GLSL +import qualified Language.GLSL.Parser as GLSL +import qualified Language.GLSL.PrettyPrint as GLSL type Transform a b = [GLSL.StmtAnnot a] -> [GLSL.StmtAnnot b] diff --git a/test/Test/GLSL/Arbitrary.hs b/test/Test/GLSL/Arbitrary.hs new file mode 100644 --- /dev/null +++ b/test/Test/GLSL/Arbitrary.hs @@ -0,0 +1,111 @@ +{-# OPTIONS_GHC -Wno-orphans #-} +module Test.GLSL.Arbitrary where + +import Language.GLSL.AST +import Test.QuickCheck.Arbitrary (Arbitrary (..), genericShrink) +import qualified Test.QuickCheck.Gen as Gen + + +instance Arbitrary a => Arbitrary (Stmt a) where + shrink = genericShrink + arbitrary = Gen.sized $ \sz -> Gen.oneof + [ AssignStmt <$> arbitrary <*> arbitrary + , DeclStmt <$> arbitrary + , EmitStmt <$> arbitrary + , IfStmt <$> arbitrary + <*> Gen.resize (sz`div`4) arbitrary + <*> Gen.resize (sz`div`4) arbitrary + ] + +instance Arbitrary ExprAtom where + shrink = genericShrink + arbitrary = Gen.oneof + [ LitIntExpr NoCast <$> arbitrary + , IdentifierExpr <$> arbitrary + , SwizzleExpr <$> arbitrary <*> arbitrary + , VecIndexExpr <$> arbitrary <*> arbitrary + , MatIndexExpr <$> arbitrary <*> arbitrary <*> arbitrary + ] + +instance Arbitrary Expr where + shrink = filter isValidExpr . genericShrink + arbitrary = Gen.oneof + [ UnaryExpr <$> arbitrary <*> arbitrary + , BinaryExpr <$> arbitrary <*> arbitrary <*> arbitrary + , FunCallExpr <$> arbitrary <*> arbArgs + -- , TextureExpr <$> arbitrary <*> arbitrary <*> arbitrary + , AtomExpr <$> arbitrary + ] + where + arbArgs :: Gen.Gen [ExprAtom] + arbArgs = pure [] + +isValidExpr :: Expr -> Bool +isValidExpr (FunCallExpr f args) = length args == argCountForFunName f +isValidExpr _ = True + +instance Arbitrary Emit where + shrink = genericShrink + arbitrary = Gen.oneof + [ pure EmitFragDepth + , EmitPosition <$> arbitrary + ] + + + +instance Arbitrary a => Arbitrary (StmtAnnot a) where + shrink = genericShrink + arbitrary = SA <$> arbitrary <*> arbitrary + +instance Arbitrary LocalDecl where + shrink = genericShrink + arbitrary = LDecl <$> arbitrary <*> arbitrary <*> arbitrary + +instance Arbitrary Type where + arbitrary = Gen.elements + [ TyBool + , TyFloat + , TyVec 4 + , TyMat 4 4 + ] + +instance Arbitrary NameId where + shrink = genericShrink + arbitrary = NameId <$> arbitrary + +instance Arbitrary Namespace where + arbitrary = pure NsT + +instance Arbitrary Name where + shrink = genericShrink + arbitrary = Name <$> arbitrary <*> arbitrary + +instance Arbitrary FunName where + arbitrary = Gen.elements + [ PrimAbs + , PrimAsin + ] + +instance Arbitrary UnaryOp where + arbitrary = Gen.elements + [ UOpMinus + , UOpNot + ] + +instance Arbitrary BinaryOp where + arbitrary = Gen.elements + [ BOpPlus + , BOpMinus + ] + +instance Arbitrary Cast where + shrink = genericShrink + arbitrary = Gen.elements [NoCast, Cast] + +instance Arbitrary NameExpr where + shrink = genericShrink + arbitrary = NameExpr <$> arbitrary + +instance Arbitrary Swizzle where + shrink = genericShrink + arbitrary = Gen.elements [X, Y, Z, W] diff --git a/test/data/large-shaders/lambdacnc.frag b/test/data/large-shaders/lambdacnc.frag new file mode 100644 --- /dev/null +++ b/test/data/large-shaders/lambdacnc.frag @@ -0,0 +1,956 @@ +#version 450 +layout(location = 0) out vec4 out0; +layout(location = 1) out vec4 out1; +layout(std140) uniform uBlock5 { +float u0; +float u4; +float u8; +float u12; +float u16; +float u20; +float u24; +} u5; +layout(std140) uniform uBlock6 { +float u0; +float u4; +float u8; +float u12; +float u16; +float u20; +float u24; +float u28; +} u6; +layout(std140) uniform uBlock7 { +float u0; +float u4; +float u8; +float u12; +float u16; +float u20; +} u7; +layout(std140) uniform uBlock8 { +float u0; +float u4; +float u8; +float u12; +float u16; +float u20; +} u8; +uniform sampler2D s10; +uniform sampler2D s11; +uniform sampler2D s12; +in float vf0; +in float vf1; +in float vf2; +in float vf3; +in float vf4; +in float vf5; +in float vf6; +in float vf7; +in float vf8; +in float vf9; +in float vf10; +in float vf11; +in float vf12; +in float vf13; +in float vf14; +in float vf15; +in float vf16; +in float vf17; +void main() { +vec4 t0 = vec4(u7.u0,u7.u4,u7.u8,1); +float t1 = (u5.u0/2); +float t2 = cos(t1); +float t3 = sin(t1); +float t4 = (-t3); +vec4 t5 = vec4(t2,t4,0,0); +float t6 = sin(t1); +vec4 t7 = vec4(t6,t2,0,0); +vec4 t8 = vec4(0,0,1,0); +vec4 t9 = vec4(0,0,0,1); +mat4x4 t10 = mat4x4(t5,t7,t8,t9); +vec4 t11 = (t0*t10); +float t12 = (t11[0]-vf2); +float t13 = (t12*t12); +float t14 = (t11[1]-vf3); +float t15 = (t14*t14); +float t16 = (t13+t15); +float t17 = (t11[2]-vf4); +float t18 = (t17*t17); +float t19 = (t16+t18); +float t20 = (t11[3]-vf5); +float t21 = (t20*t20); +float t22 = (t19+t21); +float t23 = sqrt(t22); +float t24 = (t12/t23); +float t25 = (vf6*t24); +float t26 = (t14/t23); +float t27 = (vf7*t26); +float t28 = (t25+t27); +float t29 = (t17/t23); +float t30 = (vf8*t29); +float t31 = (t28+t30); +float t32 = (t20/t23); +float t33 = (vf9*t32); +float t34 = (t31+t33); +bool t35 = (t34>=0); +float t36; +if(t35){ +t36 = t34; +} else { +t36 = 0; +} +float t37 = (u7.u12*t36); +float t38 = (vf12/vf13); +float t39 = (t38*float(0.5)); +float t40 = (t39+float(0.5)); +vec4 t41 = vec4(vf6,vf7,vf8,vf9); +float t42 = (t11[0]-vf2); +float t43 = (t11[1]-vf3); +float t44 = (t11[2]-vf4); +float t45 = (t11[3]-vf5); +vec4 t46 = vec4(t42,t43,t44,t45); +vec4 t47 = normalize(t46); +vec4 t48 = vec4(t47[0],t47[1],t47[2],t47[3]); +float t49 = dot(t41,t48); +float t50 = (float(1.0)-t49); +float t51 = (float(5.0e-4)*t50); +bool t52 = (t51>=float(5.0e-5)); +float t53; +if(t52){ +t53 = t51; +} else { +t53 = float(5.0e-5); +} +float t54 = (t40-t53); +float t55 = (vf10/vf13); +float t56 = (t55*float(0.5)); +float t57 = (t56+float(0.5)); +float t58 = (float(1.0)/600); +float t59 = (0*t58); +float t60 = (t57+t59); +float t61 = (vf11/vf13); +float t62 = (t61*float(0.5)); +float t63 = (t62+float(0.5)); +float t64 = (0*t58); +float t65 = (t63+t64); +vec4 t66 = texture(s10,vec2(t60,t65)); +bool t67 = (t54>t66.x); +float t68; +if(t67){ +t68 = float(0.1); +} else { +t68 = float(1.0); +} +float t69 = (0+t68); +float t70 = (vf12/vf13); +float t71 = (t70*float(0.5)); +float t72 = (t71+float(0.5)); +vec4 t73 = vec4(vf6,vf7,vf8,vf9); +float t74 = (t11[0]-vf2); +float t75 = (t11[1]-vf3); +float t76 = (t11[2]-vf4); +float t77 = (t11[3]-vf5); +vec4 t78 = vec4(t74,t75,t76,t77); +vec4 t79 = normalize(t78); +vec4 t80 = vec4(t79[0],t79[1],t79[2],t79[3]); +float t81 = dot(t73,t80); +float t82 = (float(1.0)-t81); +float t83 = (float(5.0e-4)*t82); +bool t84 = (t83>=float(5.0e-5)); +float t85; +if(t84){ +t85 = t83; +} else { +t85 = float(5.0e-5); +} +float t86 = (t72-t85); +float t87 = (vf10/vf13); +float t88 = (t87*float(0.5)); +float t89 = (t88+float(0.5)); +float t90 = (-1); +float t91 = (t90*t58); +float t92 = (t89+t91); +float t93 = (vf11/vf13); +float t94 = (t93*float(0.5)); +float t95 = (t94+float(0.5)); +float t96 = (t90*t58); +float t97 = (t95+t96); +vec4 t98 = texture(s10,vec2(t92,t97)); +bool t99 = (t86>t98.x); +float t100; +if(t99){ +t100 = float(0.1); +} else { +t100 = float(1.0); +} +float t101 = (t69+t100); +float t102 = (vf12/vf13); +float t103 = (t102*float(0.5)); +float t104 = (t103+float(0.5)); +vec4 t105 = vec4(vf6,vf7,vf8,vf9); +float t106 = (t11[0]-vf2); +float t107 = (t11[1]-vf3); +float t108 = (t11[2]-vf4); +float t109 = (t11[3]-vf5); +vec4 t110 = vec4(t106,t107,t108,t109); +vec4 t111 = normalize(t110); +vec4 t112 = vec4(t111[0],t111[1],t111[2],t111[3]); +float t113 = dot(t105,t112); +float t114 = (float(1.0)-t113); +float t115 = (float(5.0e-4)*t114); +bool t116 = (t115>=float(5.0e-5)); +float t117; +if(t116){ +t117 = t115; +} else { +t117 = float(5.0e-5); +} +float t118 = (t104-t117); +float t119 = (vf10/vf13); +float t120 = (t119*float(0.5)); +float t121 = (t120+float(0.5)); +float t122 = (-1); +float t123 = (t122*t58); +float t124 = (t121+t123); +float t125 = (vf11/vf13); +float t126 = (t125*float(0.5)); +float t127 = (t126+float(0.5)); +float t128 = (0*t58); +float t129 = (t127+t128); +vec4 t130 = texture(s10,vec2(t124,t129)); +bool t131 = (t118>t130.x); +float t132; +if(t131){ +t132 = float(0.1); +} else { +t132 = float(1.0); +} +float t133 = (t101+t132); +float t134 = (vf12/vf13); +float t135 = (t134*float(0.5)); +float t136 = (t135+float(0.5)); +vec4 t137 = vec4(vf6,vf7,vf8,vf9); +float t138 = (t11[0]-vf2); +float t139 = (t11[1]-vf3); +float t140 = (t11[2]-vf4); +float t141 = (t11[3]-vf5); +vec4 t142 = vec4(t138,t139,t140,t141); +vec4 t143 = normalize(t142); +vec4 t144 = vec4(t143[0],t143[1],t143[2],t143[3]); +float t145 = dot(t137,t144); +float t146 = (float(1.0)-t145); +float t147 = (float(5.0e-4)*t146); +bool t148 = (t147>=float(5.0e-5)); +float t149; +if(t148){ +t149 = t147; +} else { +t149 = float(5.0e-5); +} +float t150 = (t136-t149); +float t151 = (vf10/vf13); +float t152 = (t151*float(0.5)); +float t153 = (t152+float(0.5)); +float t154 = (-1); +float t155 = (t154*t58); +float t156 = (t153+t155); +float t157 = (vf11/vf13); +float t158 = (t157*float(0.5)); +float t159 = (t158+float(0.5)); +float t160 = (1*t58); +float t161 = (t159+t160); +vec4 t162 = texture(s10,vec2(t156,t161)); +bool t163 = (t150>t162.x); +float t164; +if(t163){ +t164 = float(0.1); +} else { +t164 = float(1.0); +} +float t165 = (t133+t164); +float t166 = (vf12/vf13); +float t167 = (t166*float(0.5)); +float t168 = (t167+float(0.5)); +vec4 t169 = vec4(vf6,vf7,vf8,vf9); +float t170 = (t11[0]-vf2); +float t171 = (t11[1]-vf3); +float t172 = (t11[2]-vf4); +float t173 = (t11[3]-vf5); +vec4 t174 = vec4(t170,t171,t172,t173); +vec4 t175 = normalize(t174); +vec4 t176 = vec4(t175[0],t175[1],t175[2],t175[3]); +float t177 = dot(t169,t176); +float t178 = (float(1.0)-t177); +float t179 = (float(5.0e-4)*t178); +bool t180 = (t179>=float(5.0e-5)); +float t181; +if(t180){ +t181 = t179; +} else { +t181 = float(5.0e-5); +} +float t182 = (t168-t181); +float t183 = (vf10/vf13); +float t184 = (t183*float(0.5)); +float t185 = (t184+float(0.5)); +float t186 = (0*t58); +float t187 = (t185+t186); +float t188 = (vf11/vf13); +float t189 = (t188*float(0.5)); +float t190 = (t189+float(0.5)); +float t191 = (-1); +float t192 = (t191*t58); +float t193 = (t190+t192); +vec4 t194 = texture(s10,vec2(t187,t193)); +bool t195 = (t182>t194.x); +float t196; +if(t195){ +t196 = float(0.1); +} else { +t196 = float(1.0); +} +float t197 = (t165+t196); +float t198 = (vf12/vf13); +float t199 = (t198*float(0.5)); +float t200 = (t199+float(0.5)); +vec4 t201 = vec4(vf6,vf7,vf8,vf9); +float t202 = (t11[0]-vf2); +float t203 = (t11[1]-vf3); +float t204 = (t11[2]-vf4); +float t205 = (t11[3]-vf5); +vec4 t206 = vec4(t202,t203,t204,t205); +vec4 t207 = normalize(t206); +vec4 t208 = vec4(t207[0],t207[1],t207[2],t207[3]); +float t209 = dot(t201,t208); +float t210 = (float(1.0)-t209); +float t211 = (float(5.0e-4)*t210); +bool t212 = (t211>=float(5.0e-5)); +float t213; +if(t212){ +t213 = t211; +} else { +t213 = float(5.0e-5); +} +float t214 = (t200-t213); +float t215 = (vf10/vf13); +float t216 = (t215*float(0.5)); +float t217 = (t216+float(0.5)); +float t218 = (0*t58); +float t219 = (t217+t218); +float t220 = (vf11/vf13); +float t221 = (t220*float(0.5)); +float t222 = (t221+float(0.5)); +float t223 = (1*t58); +float t224 = (t222+t223); +vec4 t225 = texture(s10,vec2(t219,t224)); +bool t226 = (t214>t225.x); +float t227; +if(t226){ +t227 = float(0.1); +} else { +t227 = float(1.0); +} +float t228 = (t197+t227); +float t229 = (vf12/vf13); +float t230 = (t229*float(0.5)); +float t231 = (t230+float(0.5)); +vec4 t232 = vec4(vf6,vf7,vf8,vf9); +float t233 = (t11[0]-vf2); +float t234 = (t11[1]-vf3); +float t235 = (t11[2]-vf4); +float t236 = (t11[3]-vf5); +vec4 t237 = vec4(t233,t234,t235,t236); +vec4 t238 = normalize(t237); +vec4 t239 = vec4(t238[0],t238[1],t238[2],t238[3]); +float t240 = dot(t232,t239); +float t241 = (float(1.0)-t240); +float t242 = (float(5.0e-4)*t241); +bool t243 = (t242>=float(5.0e-5)); +float t244; +if(t243){ +t244 = t242; +} else { +t244 = float(5.0e-5); +} +float t245 = (t231-t244); +float t246 = (vf10/vf13); +float t247 = (t246*float(0.5)); +float t248 = (t247+float(0.5)); +float t249 = (1*t58); +float t250 = (t248+t249); +float t251 = (vf11/vf13); +float t252 = (t251*float(0.5)); +float t253 = (t252+float(0.5)); +float t254 = (-1); +float t255 = (t254*t58); +float t256 = (t253+t255); +vec4 t257 = texture(s10,vec2(t250,t256)); +bool t258 = (t245>t257.x); +float t259; +if(t258){ +t259 = float(0.1); +} else { +t259 = float(1.0); +} +float t260 = (t228+t259); +float t261 = (vf12/vf13); +float t262 = (t261*float(0.5)); +float t263 = (t262+float(0.5)); +vec4 t264 = vec4(vf6,vf7,vf8,vf9); +float t265 = (t11[0]-vf2); +float t266 = (t11[1]-vf3); +float t267 = (t11[2]-vf4); +float t268 = (t11[3]-vf5); +vec4 t269 = vec4(t265,t266,t267,t268); +vec4 t270 = normalize(t269); +vec4 t271 = vec4(t270[0],t270[1],t270[2],t270[3]); +float t272 = dot(t264,t271); +float t273 = (float(1.0)-t272); +float t274 = (float(5.0e-4)*t273); +bool t275 = (t274>=float(5.0e-5)); +float t276; +if(t275){ +t276 = t274; +} else { +t276 = float(5.0e-5); +} +float t277 = (t263-t276); +float t278 = (vf10/vf13); +float t279 = (t278*float(0.5)); +float t280 = (t279+float(0.5)); +float t281 = (1*t58); +float t282 = (t280+t281); +float t283 = (vf11/vf13); +float t284 = (t283*float(0.5)); +float t285 = (t284+float(0.5)); +float t286 = (0*t58); +float t287 = (t285+t286); +vec4 t288 = texture(s10,vec2(t282,t287)); +bool t289 = (t277>t288.x); +float t290; +if(t289){ +t290 = float(0.1); +} else { +t290 = float(1.0); +} +float t291 = (t260+t290); +float t292 = (vf12/vf13); +float t293 = (t292*float(0.5)); +float t294 = (t293+float(0.5)); +vec4 t295 = vec4(vf6,vf7,vf8,vf9); +float t296 = (t11[0]-vf2); +float t297 = (t11[1]-vf3); +float t298 = (t11[2]-vf4); +float t299 = (t11[3]-vf5); +vec4 t300 = vec4(t296,t297,t298,t299); +vec4 t301 = normalize(t300); +vec4 t302 = vec4(t301[0],t301[1],t301[2],t301[3]); +float t303 = dot(t295,t302); +float t304 = (float(1.0)-t303); +float t305 = (float(5.0e-4)*t304); +bool t306 = (t305>=float(5.0e-5)); +float t307; +if(t306){ +t307 = t305; +} else { +t307 = float(5.0e-5); +} +float t308 = (t294-t307); +float t309 = (vf10/vf13); +float t310 = (t309*float(0.5)); +float t311 = (t310+float(0.5)); +float t312 = (1*t58); +float t313 = (t311+t312); +float t314 = (vf11/vf13); +float t315 = (t314*float(0.5)); +float t316 = (t315+float(0.5)); +float t317 = (1*t58); +float t318 = (t316+t317); +vec4 t319 = texture(s10,vec2(t313,t318)); +bool t320 = (t308>t319.x); +float t321; +if(t320){ +t321 = float(0.1); +} else { +t321 = float(1.0); +} +float t322 = (t291+t321); +float t323 = (t322/9); +float t324 = (t37*t323); +vec4 t325 = vec4(u8.u0,u8.u4,u8.u8,1); +vec4 t326 = vec4(t2,t4,0,0); +vec4 t327 = vec4(t6,t2,0,0); +vec4 t328 = vec4(0,0,1,0); +vec4 t329 = vec4(0,0,0,1); +mat4x4 t330 = mat4x4(t326,t327,t328,t329); +vec4 t331 = (t325*t330); +float t332 = (t331[0]-vf2); +float t333 = (t332*t332); +float t334 = (t331[1]-vf3); +float t335 = (t334*t334); +float t336 = (t333+t335); +float t337 = (t331[2]-vf4); +float t338 = (t337*t337); +float t339 = (t336+t338); +float t340 = (t331[3]-vf5); +float t341 = (t340*t340); +float t342 = (t339+t341); +float t343 = sqrt(t342); +float t344 = (t332/t343); +float t345 = (vf6*t344); +float t346 = (t334/t343); +float t347 = (vf7*t346); +float t348 = (t345+t347); +float t349 = (t337/t343); +float t350 = (vf8*t349); +float t351 = (t348+t350); +float t352 = (t340/t343); +float t353 = (vf9*t352); +float t354 = (t351+t353); +bool t355 = (t354>=0); +float t356; +if(t355){ +t356 = t354; +} else { +t356 = 0; +} +float t357 = (u8.u12*t356); +float t358 = (vf16/vf17); +float t359 = (t358*float(0.5)); +float t360 = (t359+float(0.5)); +vec4 t361 = vec4(vf6,vf7,vf8,vf9); +float t362 = (t331[0]-vf2); +float t363 = (t331[1]-vf3); +float t364 = (t331[2]-vf4); +float t365 = (t331[3]-vf5); +vec4 t366 = vec4(t362,t363,t364,t365); +vec4 t367 = normalize(t366); +vec4 t368 = vec4(t367[0],t367[1],t367[2],t367[3]); +float t369 = dot(t361,t368); +float t370 = (float(1.0)-t369); +float t371 = (float(5.0e-4)*t370); +bool t372 = (t371>=float(5.0e-5)); +float t373; +if(t372){ +t373 = t371; +} else { +t373 = float(5.0e-5); +} +float t374 = (t360-t373); +float t375 = (vf14/vf17); +float t376 = (t375*float(0.5)); +float t377 = (t376+float(0.5)); +float t378 = (0*t58); +float t379 = (t377+t378); +float t380 = (vf15/vf17); +float t381 = (t380*float(0.5)); +float t382 = (t381+float(0.5)); +float t383 = (0*t58); +float t384 = (t382+t383); +vec4 t385 = texture(s11,vec2(t379,t384)); +bool t386 = (t374>t385.x); +float t387; +if(t386){ +t387 = float(0.1); +} else { +t387 = float(1.0); +} +float t388 = (0+t387); +float t389 = (vf16/vf17); +float t390 = (t389*float(0.5)); +float t391 = (t390+float(0.5)); +vec4 t392 = vec4(vf6,vf7,vf8,vf9); +float t393 = (t331[0]-vf2); +float t394 = (t331[1]-vf3); +float t395 = (t331[2]-vf4); +float t396 = (t331[3]-vf5); +vec4 t397 = vec4(t393,t394,t395,t396); +vec4 t398 = normalize(t397); +vec4 t399 = vec4(t398[0],t398[1],t398[2],t398[3]); +float t400 = dot(t392,t399); +float t401 = (float(1.0)-t400); +float t402 = (float(5.0e-4)*t401); +bool t403 = (t402>=float(5.0e-5)); +float t404; +if(t403){ +t404 = t402; +} else { +t404 = float(5.0e-5); +} +float t405 = (t391-t404); +float t406 = (vf14/vf17); +float t407 = (t406*float(0.5)); +float t408 = (t407+float(0.5)); +float t409 = (t90*t58); +float t410 = (t408+t409); +float t411 = (vf15/vf17); +float t412 = (t411*float(0.5)); +float t413 = (t412+float(0.5)); +float t414 = (t90*t58); +float t415 = (t413+t414); +vec4 t416 = texture(s11,vec2(t410,t415)); +bool t417 = (t405>t416.x); +float t418; +if(t417){ +t418 = float(0.1); +} else { +t418 = float(1.0); +} +float t419 = (t388+t418); +float t420 = (vf16/vf17); +float t421 = (t420*float(0.5)); +float t422 = (t421+float(0.5)); +vec4 t423 = vec4(vf6,vf7,vf8,vf9); +float t424 = (t331[0]-vf2); +float t425 = (t331[1]-vf3); +float t426 = (t331[2]-vf4); +float t427 = (t331[3]-vf5); +vec4 t428 = vec4(t424,t425,t426,t427); +vec4 t429 = normalize(t428); +vec4 t430 = vec4(t429[0],t429[1],t429[2],t429[3]); +float t431 = dot(t423,t430); +float t432 = (float(1.0)-t431); +float t433 = (float(5.0e-4)*t432); +bool t434 = (t433>=float(5.0e-5)); +float t435; +if(t434){ +t435 = t433; +} else { +t435 = float(5.0e-5); +} +float t436 = (t422-t435); +float t437 = (vf14/vf17); +float t438 = (t437*float(0.5)); +float t439 = (t438+float(0.5)); +float t440 = (t122*t58); +float t441 = (t439+t440); +float t442 = (vf15/vf17); +float t443 = (t442*float(0.5)); +float t444 = (t443+float(0.5)); +float t445 = (0*t58); +float t446 = (t444+t445); +vec4 t447 = texture(s11,vec2(t441,t446)); +bool t448 = (t436>t447.x); +float t449; +if(t448){ +t449 = float(0.1); +} else { +t449 = float(1.0); +} +float t450 = (t419+t449); +float t451 = (vf16/vf17); +float t452 = (t451*float(0.5)); +float t453 = (t452+float(0.5)); +vec4 t454 = vec4(vf6,vf7,vf8,vf9); +float t455 = (t331[0]-vf2); +float t456 = (t331[1]-vf3); +float t457 = (t331[2]-vf4); +float t458 = (t331[3]-vf5); +vec4 t459 = vec4(t455,t456,t457,t458); +vec4 t460 = normalize(t459); +vec4 t461 = vec4(t460[0],t460[1],t460[2],t460[3]); +float t462 = dot(t454,t461); +float t463 = (float(1.0)-t462); +float t464 = (float(5.0e-4)*t463); +bool t465 = (t464>=float(5.0e-5)); +float t466; +if(t465){ +t466 = t464; +} else { +t466 = float(5.0e-5); +} +float t467 = (t453-t466); +float t468 = (vf14/vf17); +float t469 = (t468*float(0.5)); +float t470 = (t469+float(0.5)); +float t471 = (t154*t58); +float t472 = (t470+t471); +float t473 = (vf15/vf17); +float t474 = (t473*float(0.5)); +float t475 = (t474+float(0.5)); +float t476 = (1*t58); +float t477 = (t475+t476); +vec4 t478 = texture(s11,vec2(t472,t477)); +bool t479 = (t467>t478.x); +float t480; +if(t479){ +t480 = float(0.1); +} else { +t480 = float(1.0); +} +float t481 = (t450+t480); +float t482 = (vf16/vf17); +float t483 = (t482*float(0.5)); +float t484 = (t483+float(0.5)); +vec4 t485 = vec4(vf6,vf7,vf8,vf9); +float t486 = (t331[0]-vf2); +float t487 = (t331[1]-vf3); +float t488 = (t331[2]-vf4); +float t489 = (t331[3]-vf5); +vec4 t490 = vec4(t486,t487,t488,t489); +vec4 t491 = normalize(t490); +vec4 t492 = vec4(t491[0],t491[1],t491[2],t491[3]); +float t493 = dot(t485,t492); +float t494 = (float(1.0)-t493); +float t495 = (float(5.0e-4)*t494); +bool t496 = (t495>=float(5.0e-5)); +float t497; +if(t496){ +t497 = t495; +} else { +t497 = float(5.0e-5); +} +float t498 = (t484-t497); +float t499 = (vf14/vf17); +float t500 = (t499*float(0.5)); +float t501 = (t500+float(0.5)); +float t502 = (0*t58); +float t503 = (t501+t502); +float t504 = (vf15/vf17); +float t505 = (t504*float(0.5)); +float t506 = (t505+float(0.5)); +float t507 = (t191*t58); +float t508 = (t506+t507); +vec4 t509 = texture(s11,vec2(t503,t508)); +bool t510 = (t498>t509.x); +float t511; +if(t510){ +t511 = float(0.1); +} else { +t511 = float(1.0); +} +float t512 = (t481+t511); +float t513 = (vf16/vf17); +float t514 = (t513*float(0.5)); +float t515 = (t514+float(0.5)); +vec4 t516 = vec4(vf6,vf7,vf8,vf9); +float t517 = (t331[0]-vf2); +float t518 = (t331[1]-vf3); +float t519 = (t331[2]-vf4); +float t520 = (t331[3]-vf5); +vec4 t521 = vec4(t517,t518,t519,t520); +vec4 t522 = normalize(t521); +vec4 t523 = vec4(t522[0],t522[1],t522[2],t522[3]); +float t524 = dot(t516,t523); +float t525 = (float(1.0)-t524); +float t526 = (float(5.0e-4)*t525); +bool t527 = (t526>=float(5.0e-5)); +float t528; +if(t527){ +t528 = t526; +} else { +t528 = float(5.0e-5); +} +float t529 = (t515-t528); +float t530 = (vf14/vf17); +float t531 = (t530*float(0.5)); +float t532 = (t531+float(0.5)); +float t533 = (0*t58); +float t534 = (t532+t533); +float t535 = (vf15/vf17); +float t536 = (t535*float(0.5)); +float t537 = (t536+float(0.5)); +float t538 = (1*t58); +float t539 = (t537+t538); +vec4 t540 = texture(s11,vec2(t534,t539)); +bool t541 = (t529>t540.x); +float t542; +if(t541){ +t542 = float(0.1); +} else { +t542 = float(1.0); +} +float t543 = (t512+t542); +float t544 = (vf16/vf17); +float t545 = (t544*float(0.5)); +float t546 = (t545+float(0.5)); +vec4 t547 = vec4(vf6,vf7,vf8,vf9); +float t548 = (t331[0]-vf2); +float t549 = (t331[1]-vf3); +float t550 = (t331[2]-vf4); +float t551 = (t331[3]-vf5); +vec4 t552 = vec4(t548,t549,t550,t551); +vec4 t553 = normalize(t552); +vec4 t554 = vec4(t553[0],t553[1],t553[2],t553[3]); +float t555 = dot(t547,t554); +float t556 = (float(1.0)-t555); +float t557 = (float(5.0e-4)*t556); +bool t558 = (t557>=float(5.0e-5)); +float t559; +if(t558){ +t559 = t557; +} else { +t559 = float(5.0e-5); +} +float t560 = (t546-t559); +float t561 = (vf14/vf17); +float t562 = (t561*float(0.5)); +float t563 = (t562+float(0.5)); +float t564 = (1*t58); +float t565 = (t563+t564); +float t566 = (vf15/vf17); +float t567 = (t566*float(0.5)); +float t568 = (t567+float(0.5)); +float t569 = (t254*t58); +float t570 = (t568+t569); +vec4 t571 = texture(s11,vec2(t565,t570)); +bool t572 = (t560>t571.x); +float t573; +if(t572){ +t573 = float(0.1); +} else { +t573 = float(1.0); +} +float t574 = (t543+t573); +float t575 = (vf16/vf17); +float t576 = (t575*float(0.5)); +float t577 = (t576+float(0.5)); +vec4 t578 = vec4(vf6,vf7,vf8,vf9); +float t579 = (t331[0]-vf2); +float t580 = (t331[1]-vf3); +float t581 = (t331[2]-vf4); +float t582 = (t331[3]-vf5); +vec4 t583 = vec4(t579,t580,t581,t582); +vec4 t584 = normalize(t583); +vec4 t585 = vec4(t584[0],t584[1],t584[2],t584[3]); +float t586 = dot(t578,t585); +float t587 = (float(1.0)-t586); +float t588 = (float(5.0e-4)*t587); +bool t589 = (t588>=float(5.0e-5)); +float t590; +if(t589){ +t590 = t588; +} else { +t590 = float(5.0e-5); +} +float t591 = (t577-t590); +float t592 = (vf14/vf17); +float t593 = (t592*float(0.5)); +float t594 = (t593+float(0.5)); +float t595 = (1*t58); +float t596 = (t594+t595); +float t597 = (vf15/vf17); +float t598 = (t597*float(0.5)); +float t599 = (t598+float(0.5)); +float t600 = (0*t58); +float t601 = (t599+t600); +vec4 t602 = texture(s11,vec2(t596,t601)); +bool t603 = (t591>t602.x); +float t604; +if(t603){ +t604 = float(0.1); +} else { +t604 = float(1.0); +} +float t605 = (t574+t604); +float t606 = (vf16/vf17); +float t607 = (t606*float(0.5)); +float t608 = (t607+float(0.5)); +vec4 t609 = vec4(vf6,vf7,vf8,vf9); +float t610 = (t331[0]-vf2); +float t611 = (t331[1]-vf3); +float t612 = (t331[2]-vf4); +float t613 = (t331[3]-vf5); +vec4 t614 = vec4(t610,t611,t612,t613); +vec4 t615 = normalize(t614); +vec4 t616 = vec4(t615[0],t615[1],t615[2],t615[3]); +float t617 = dot(t609,t616); +float t618 = (float(1.0)-t617); +float t619 = (float(5.0e-4)*t618); +bool t620 = (t619>=float(5.0e-5)); +float t621; +if(t620){ +t621 = t619; +} else { +t621 = float(5.0e-5); +} +float t622 = (t608-t621); +float t623 = (vf14/vf17); +float t624 = (t623*float(0.5)); +float t625 = (t624+float(0.5)); +float t626 = (1*t58); +float t627 = (t625+t626); +float t628 = (vf15/vf17); +float t629 = (t628*float(0.5)); +float t630 = (t629+float(0.5)); +float t631 = (1*t58); +float t632 = (t630+t631); +vec4 t633 = texture(s11,vec2(t627,t632)); +bool t634 = (t622>t633.x); +float t635; +if(t634){ +t635 = float(0.1); +} else { +t635 = float(1.0); +} +float t636 = (t605+t635); +float t637 = (t636/9); +float t638 = (t357*t637); +float t639 = (0+0); +float t640 = (0+t639); +float t641 = (0+t640); +float t642 = (0+t641); +float t643 = (0+t642); +float t644 = (0+t643); +float t645 = (0+t644); +float t646 = (t638+t645); +float t647 = (t324+t646); +float t648 = (u5.u24*t647); +float t649 = (vf0/100000); +float t650 = (vf1/100000); +vec4 t651 = texture(s12,vec2(t649,t650)); +float t652 = (u6.u12*t651.x); +float t653 = (t648*t652); +float t654 = (u7.u16*t36); +float t655 = (t654*t323); +float t656 = (u8.u16*t356); +float t657 = (t656*t637); +float t658 = (0+0); +float t659 = (0+t658); +float t660 = (0+t659); +float t661 = (0+t660); +float t662 = (0+t661); +float t663 = (0+t662); +float t664 = (0+t663); +float t665 = (t657+t664); +float t666 = (t655+t665); +float t667 = (u5.u24*t666); +float t668 = (u6.u16*t651.x); +float t669 = (t667*t668); +float t670 = (u7.u20*t36); +float t671 = (t670*t323); +float t672 = (u8.u20*t356); +float t673 = (t672*t637); +float t674 = (0+0); +float t675 = (0+t674); +float t676 = (0+t675); +float t677 = (0+t676); +float t678 = (0+t677); +float t679 = (0+t678); +float t680 = (0+t679); +float t681 = (t673+t680); +float t682 = (t671+t681); +float t683 = (u5.u24*t682); +float t684 = (u6.u20*t651.x); +float t685 = (t683*t684); +out0 = vec4(t653,t669,t685,1); +vec3 t686 = vec3(t653,t669,t685); +vec3 t687 = vec3(float(0.2126),float(0.7152),float(7.22e-2)); +float t688 = dot(t686,t687); +bool t689 = (t688>float(1.0)); +float t690; +float t691; +float t692; +if(t689){ +t690 = t653; +t691 = t669; +t692 = t685; +} else { +t690 = 0; +t691 = 0; +t692 = 0; +} +out1 = vec4(t690,t691,t692,1); +gl_FragDepth = gl_FragCoord[2]; +} diff --git a/test/data/large-shaders/lambdacnc.vert b/test/data/large-shaders/lambdacnc.vert new file mode 100644 --- /dev/null +++ b/test/data/large-shaders/lambdacnc.vert @@ -0,0 +1,757 @@ +#version 450 +out float vf0; +out float vf1; +out float vf2; +out float vf3; +out float vf4; +out float vf5; +out float vf6; +out float vf7; +out float vf8; +out float vf9; +out float vf10; +out float vf11; +out float vf12; +out float vf13; +out float vf14; +out float vf15; +out float vf16; +out float vf17; +layout(std140) uniform uBlock1 { +float u0; +float u4; +float u8; +float u12; +float u16; +float u20; +float u24; +} u1; +layout(std140) uniform uBlock2 { +float u0; +float u4; +float u8; +float u12; +float u16; +float u20; +float u24; +float u28; +} u2; +layout(std140) uniform uBlock3 { +float u0; +float u4; +float u8; +float u12; +float u16; +float u20; +} u3; +layout(std140) uniform uBlock4 { +float u0; +float u4; +float u8; +float u12; +float u16; +float u20; +} u4; +in vec3 in0; +in vec3 in1; +void main() { +vec3 t0 = in0; +vf0 = t0.x; +vf1 = t0.y; +float t1 = (t0.x+u2.u0); +float t2 = (t0.y+u2.u4); +float t3 = (t0.z+u2.u8); +float t4 = (1+0); +vec4 t5 = vec4(t1,t2,t3,t4); +float t6 = (3.1415927/2); +float t7 = cos(t6); +float t8 = sin(t6); +float t9 = (-t8); +vec4 t10 = vec4(t7,t9,0,0); +vec4 t11 = vec4(t8,t7,0,0); +vec4 t12 = vec4(0,0,1,0); +vec4 t13 = vec4(0,0,0,1); +mat4x4 t14 = mat4x4(t10,t11,t12,t13); +vec4 t15 = (t5*t14); +vf2 = t15[0]; +vf3 = t15[1]; +vf4 = t15[2]; +vf5 = t15[3]; +vec3 t16 = in1; +vec4 t17 = vec4(t16.x,t16.y,t16.z,1); +vec4 t18 = vec4(t7,t9,0,0); +vec4 t19 = vec4(t8,t7,0,0); +vec4 t20 = vec4(0,0,1,0); +vec4 t21 = vec4(0,0,0,1); +mat4x4 t22 = mat4x4(t18,t19,t20,t21); +vec4 t23 = (t17*t22); +vf6 = t23[0]; +vf7 = t23[1]; +vf8 = t23[2]; +vf9 = t23[3]; +vec4 t24 = vec4(t15[0],t15[1],t15[2],t15[3]); +float t25 = (-80000); +float t26 = (t25-80000); +float t27 = (1/t26); +float t28 = (2*t27); +float t29 = (-t28); +vec4 t30 = vec4(u3.u0,u3.u4,u3.u8,1); +float t31 = (u1.u0/2); +float t32 = cos(t31); +float t33 = sin(t31); +float t34 = (-t33); +vec4 t35 = vec4(t32,t34,0,0); +float t36 = sin(t31); +vec4 t37 = vec4(t36,t32,0,0); +vec4 t38 = vec4(0,0,1,0); +vec4 t39 = vec4(0,0,0,1); +mat4x4 t40 = mat4x4(t35,t37,t38,t39); +vec4 t41 = (t30*t40); +float t42 = (0-t41[1]); +float t43 = (0-t41[0]); +float t44 = (t43*t43); +float t45 = (t42*t42); +float t46 = (t44+t45); +float t47 = (0-t41[2]); +float t48 = (t47*t47); +float t49 = (t46+t48); +float t50 = sqrt(t49); +float t51 = (t42/t50); +float t52 = (t51*1); +float t53 = (t47/t50); +float t54 = (t53*0); +float t55 = (t52-t54); +float t56 = (t55*t55); +float t57 = (t53*0); +float t58 = (t43/t50); +float t59 = (t58*1); +float t60 = (t57-t59); +float t61 = (t60*t60); +float t62 = (t56+t61); +float t63 = (t58*0); +float t64 = (t51*0); +float t65 = (t63-t64); +float t66 = (t65*t65); +float t67 = (t62+t66); +float t68 = sqrt(t67); +float t69 = (t55/t68); +float t70 = (t29*t69); +float t71 = (0+t70); +float t72 = (t60/t68); +float t73 = (t72*t53); +float t74 = (t65/t68); +float t75 = (t74*t51); +float t76 = (t73-t75); +float t77 = (0*t76); +float t78 = (t71+t77); +float t79 = (-t58); +float t80 = (0*t79); +float t81 = (t78+t80); +float t82 = (80000+t25); +float t83 = (t82*t27); +float t84 = (t83*0); +float t85 = (t81+t84); +float t86 = (t29*t72); +float t87 = (0+t86); +float t88 = (t74*t58); +float t89 = (t69*t53); +float t90 = (t88-t89); +float t91 = (0*t90); +float t92 = (t87+t91); +float t93 = (-t51); +float t94 = (0*t93); +float t95 = (t92+t94); +float t96 = (t83*0); +float t97 = (t95+t96); +float t98 = (t29*t74); +float t99 = (0+t98); +float t100 = (t69*t51); +float t101 = (t72*t58); +float t102 = (t100-t101); +float t103 = (0*t102); +float t104 = (t99+t103); +float t105 = (-t53); +float t106 = (0*t105); +float t107 = (t104+t106); +float t108 = (t83*0); +float t109 = (t107+t108); +float t110 = (t69*t41[0]); +float t111 = (t72*t41[1]); +float t112 = (t110+t111); +float t113 = (t74*t41[2]); +float t114 = (t112+t113); +float t115 = (-t114); +float t116 = (t29*t115); +float t117 = (0+t116); +float t118 = (t76*t41[0]); +float t119 = (t90*t41[1]); +float t120 = (t118+t119); +float t121 = (t102*t41[2]); +float t122 = (t120+t121); +float t123 = (-t122); +float t124 = (0*t123); +float t125 = (t117+t124); +float t126 = (t58*t41[0]); +float t127 = (t51*t41[1]); +float t128 = (t126+t127); +float t129 = (t53*t41[2]); +float t130 = (t128+t129); +float t131 = (0*t130); +float t132 = (t125+t131); +float t133 = (t83*1); +float t134 = (t132+t133); +vec4 t135 = vec4(t85,t97,t109,t134); +float t136 = (0*t69); +float t137 = (0+t136); +float t138 = (-50000); +float t139 = (t138-50000); +float t140 = (1/t139); +float t141 = (2*t140); +float t142 = (-t141); +float t143 = (t142*t76); +float t144 = (t137+t143); +float t145 = (0*t79); +float t146 = (t144+t145); +float t147 = (50000+t138); +float t148 = (t147*t140); +float t149 = (t148*0); +float t150 = (t146+t149); +float t151 = (0*t72); +float t152 = (0+t151); +float t153 = (t142*t90); +float t154 = (t152+t153); +float t155 = (0*t93); +float t156 = (t154+t155); +float t157 = (t148*0); +float t158 = (t156+t157); +float t159 = (0*t74); +float t160 = (0+t159); +float t161 = (t142*t102); +float t162 = (t160+t161); +float t163 = (0*t105); +float t164 = (t162+t163); +float t165 = (t148*0); +float t166 = (t164+t165); +float t167 = (0*t115); +float t168 = (0+t167); +float t169 = (t142*t123); +float t170 = (t168+t169); +float t171 = (0*t130); +float t172 = (t170+t171); +float t173 = (t148*1); +float t174 = (t172+t173); +vec4 t175 = vec4(t150,t158,t166,t174); +float t176 = (0*t69); +float t177 = (0+t176); +float t178 = (0*t76); +float t179 = (t177+t178); +float t180 = (3000-350000); +float t181 = (1/t180); +float t182 = (2*t181); +float t183 = (t182*t79); +float t184 = (t179+t183); +float t185 = (350000+3000); +float t186 = (t185*t181); +float t187 = (t186*0); +float t188 = (t184+t187); +float t189 = (0*t72); +float t190 = (0+t189); +float t191 = (0*t90); +float t192 = (t190+t191); +float t193 = (t182*t93); +float t194 = (t192+t193); +float t195 = (t186*0); +float t196 = (t194+t195); +float t197 = (0*t74); +float t198 = (0+t197); +float t199 = (0*t102); +float t200 = (t198+t199); +float t201 = (t182*t105); +float t202 = (t200+t201); +float t203 = (t186*0); +float t204 = (t202+t203); +float t205 = (0*t115); +float t206 = (0+t205); +float t207 = (0*t123); +float t208 = (t206+t207); +float t209 = (t182*t130); +float t210 = (t208+t209); +float t211 = (t186*1); +float t212 = (t210+t211); +vec4 t213 = vec4(t188,t196,t204,t212); +float t214 = (0*t69); +float t215 = (0+t214); +float t216 = (0*t76); +float t217 = (t215+t216); +float t218 = (0*t79); +float t219 = (t217+t218); +float t220 = (1*0); +float t221 = (t219+t220); +float t222 = (0*t72); +float t223 = (0+t222); +float t224 = (0*t90); +float t225 = (t223+t224); +float t226 = (0*t93); +float t227 = (t225+t226); +float t228 = (1*0); +float t229 = (t227+t228); +float t230 = (0*t74); +float t231 = (0+t230); +float t232 = (0*t102); +float t233 = (t231+t232); +float t234 = (0*t105); +float t235 = (t233+t234); +float t236 = (1*0); +float t237 = (t235+t236); +float t238 = (0*t115); +float t239 = (0+t238); +float t240 = (0*t123); +float t241 = (t239+t240); +float t242 = (0*t130); +float t243 = (t241+t242); +float t244 = (1*1); +float t245 = (t243+t244); +vec4 t246 = vec4(t221,t229,t237,t245); +mat4x4 t247 = mat4x4(t135,t175,t213,t246); +vec4 t248 = (t24*t247); +vf10 = t248[0]; +vf11 = t248[1]; +vf12 = t248[2]; +vf13 = t248[3]; +vec4 t249 = vec4(t15[0],t15[1],t15[2],t15[3]); +float t250 = (-80000); +float t251 = (t250-80000); +float t252 = (1/t251); +float t253 = (2*t252); +float t254 = (-t253); +vec4 t255 = vec4(u4.u0,u4.u4,u4.u8,1); +vec4 t256 = vec4(t32,t34,0,0); +vec4 t257 = vec4(t36,t32,0,0); +vec4 t258 = vec4(0,0,1,0); +vec4 t259 = vec4(0,0,0,1); +mat4x4 t260 = mat4x4(t256,t257,t258,t259); +vec4 t261 = (t255*t260); +float t262 = (0-t261[1]); +float t263 = (0-t261[0]); +float t264 = (t263*t263); +float t265 = (t262*t262); +float t266 = (t264+t265); +float t267 = (0-t261[2]); +float t268 = (t267*t267); +float t269 = (t266+t268); +float t270 = sqrt(t269); +float t271 = (t262/t270); +float t272 = (t271*1); +float t273 = (t267/t270); +float t274 = (t273*0); +float t275 = (t272-t274); +float t276 = (t275*t275); +float t277 = (t273*0); +float t278 = (t263/t270); +float t279 = (t278*1); +float t280 = (t277-t279); +float t281 = (t280*t280); +float t282 = (t276+t281); +float t283 = (t278*0); +float t284 = (t271*0); +float t285 = (t283-t284); +float t286 = (t285*t285); +float t287 = (t282+t286); +float t288 = sqrt(t287); +float t289 = (t275/t288); +float t290 = (t254*t289); +float t291 = (0+t290); +float t292 = (t280/t288); +float t293 = (t292*t273); +float t294 = (t285/t288); +float t295 = (t294*t271); +float t296 = (t293-t295); +float t297 = (0*t296); +float t298 = (t291+t297); +float t299 = (-t278); +float t300 = (0*t299); +float t301 = (t298+t300); +float t302 = (80000+t250); +float t303 = (t302*t252); +float t304 = (t303*0); +float t305 = (t301+t304); +float t306 = (t254*t292); +float t307 = (0+t306); +float t308 = (t294*t278); +float t309 = (t289*t273); +float t310 = (t308-t309); +float t311 = (0*t310); +float t312 = (t307+t311); +float t313 = (-t271); +float t314 = (0*t313); +float t315 = (t312+t314); +float t316 = (t303*0); +float t317 = (t315+t316); +float t318 = (t254*t294); +float t319 = (0+t318); +float t320 = (t289*t271); +float t321 = (t292*t278); +float t322 = (t320-t321); +float t323 = (0*t322); +float t324 = (t319+t323); +float t325 = (-t273); +float t326 = (0*t325); +float t327 = (t324+t326); +float t328 = (t303*0); +float t329 = (t327+t328); +float t330 = (t289*t261[0]); +float t331 = (t292*t261[1]); +float t332 = (t330+t331); +float t333 = (t294*t261[2]); +float t334 = (t332+t333); +float t335 = (-t334); +float t336 = (t254*t335); +float t337 = (0+t336); +float t338 = (t296*t261[0]); +float t339 = (t310*t261[1]); +float t340 = (t338+t339); +float t341 = (t322*t261[2]); +float t342 = (t340+t341); +float t343 = (-t342); +float t344 = (0*t343); +float t345 = (t337+t344); +float t346 = (t278*t261[0]); +float t347 = (t271*t261[1]); +float t348 = (t346+t347); +float t349 = (t273*t261[2]); +float t350 = (t348+t349); +float t351 = (0*t350); +float t352 = (t345+t351); +float t353 = (t303*1); +float t354 = (t352+t353); +vec4 t355 = vec4(t305,t317,t329,t354); +float t356 = (0*t289); +float t357 = (0+t356); +float t358 = (-50000); +float t359 = (t358-50000); +float t360 = (1/t359); +float t361 = (2*t360); +float t362 = (-t361); +float t363 = (t362*t296); +float t364 = (t357+t363); +float t365 = (0*t299); +float t366 = (t364+t365); +float t367 = (50000+t358); +float t368 = (t367*t360); +float t369 = (t368*0); +float t370 = (t366+t369); +float t371 = (0*t292); +float t372 = (0+t371); +float t373 = (t362*t310); +float t374 = (t372+t373); +float t375 = (0*t313); +float t376 = (t374+t375); +float t377 = (t368*0); +float t378 = (t376+t377); +float t379 = (0*t294); +float t380 = (0+t379); +float t381 = (t362*t322); +float t382 = (t380+t381); +float t383 = (0*t325); +float t384 = (t382+t383); +float t385 = (t368*0); +float t386 = (t384+t385); +float t387 = (0*t335); +float t388 = (0+t387); +float t389 = (t362*t343); +float t390 = (t388+t389); +float t391 = (0*t350); +float t392 = (t390+t391); +float t393 = (t368*1); +float t394 = (t392+t393); +vec4 t395 = vec4(t370,t378,t386,t394); +float t396 = (0*t289); +float t397 = (0+t396); +float t398 = (0*t296); +float t399 = (t397+t398); +float t400 = (3000-350000); +float t401 = (1/t400); +float t402 = (2*t401); +float t403 = (t402*t299); +float t404 = (t399+t403); +float t405 = (350000+3000); +float t406 = (t405*t401); +float t407 = (t406*0); +float t408 = (t404+t407); +float t409 = (0*t292); +float t410 = (0+t409); +float t411 = (0*t310); +float t412 = (t410+t411); +float t413 = (t402*t313); +float t414 = (t412+t413); +float t415 = (t406*0); +float t416 = (t414+t415); +float t417 = (0*t294); +float t418 = (0+t417); +float t419 = (0*t322); +float t420 = (t418+t419); +float t421 = (t402*t325); +float t422 = (t420+t421); +float t423 = (t406*0); +float t424 = (t422+t423); +float t425 = (0*t335); +float t426 = (0+t425); +float t427 = (0*t343); +float t428 = (t426+t427); +float t429 = (t402*t350); +float t430 = (t428+t429); +float t431 = (t406*1); +float t432 = (t430+t431); +vec4 t433 = vec4(t408,t416,t424,t432); +float t434 = (0*t289); +float t435 = (0+t434); +float t436 = (0*t296); +float t437 = (t435+t436); +float t438 = (0*t299); +float t439 = (t437+t438); +float t440 = (1*0); +float t441 = (t439+t440); +float t442 = (0*t292); +float t443 = (0+t442); +float t444 = (0*t310); +float t445 = (t443+t444); +float t446 = (0*t313); +float t447 = (t445+t446); +float t448 = (1*0); +float t449 = (t447+t448); +float t450 = (0*t294); +float t451 = (0+t450); +float t452 = (0*t322); +float t453 = (t451+t452); +float t454 = (0*t325); +float t455 = (t453+t454); +float t456 = (1*0); +float t457 = (t455+t456); +float t458 = (0*t335); +float t459 = (0+t458); +float t460 = (0*t343); +float t461 = (t459+t460); +float t462 = (0*t350); +float t463 = (t461+t462); +float t464 = (1*1); +float t465 = (t463+t464); +vec4 t466 = vec4(t441,t449,t457,t465); +mat4x4 t467 = mat4x4(t355,t395,t433,t466); +vec4 t468 = (t249*t467); +vf14 = t468[0]; +vf15 = t468[1]; +vf16 = t468[2]; +vf17 = t468[3]; +vec4 t469 = vec4(t15[0],t15[1],t15[2],t15[3]); +float t470 = (u1.u4/u1.u8); +float t471 = (30*3.1415927); +float t472 = (t471/180); +float t473 = (t472/2); +float t474 = tan(t473); +float t475 = (t470*t474); +float t476 = (1/t475); +float t477 = (0-u1.u16); +float t478 = (0-u1.u12); +float t479 = (t478*t478); +float t480 = (t477*t477); +float t481 = (t479+t480); +float t482 = (10000-u1.u20); +float t483 = (t482*t482); +float t484 = (t481+t483); +float t485 = sqrt(t484); +float t486 = (t477/t485); +float t487 = (t486*1); +float t488 = (t482/t485); +float t489 = (t488*0); +float t490 = (t487-t489); +float t491 = (t490*t490); +float t492 = (t488*0); +float t493 = (t478/t485); +float t494 = (t493*1); +float t495 = (t492-t494); +float t496 = (t495*t495); +float t497 = (t491+t496); +float t498 = (t493*0); +float t499 = (t486*0); +float t500 = (t498-t499); +float t501 = (t500*t500); +float t502 = (t497+t501); +float t503 = sqrt(t502); +float t504 = (t490/t503); +float t505 = (t476*t504); +float t506 = (0+t505); +float t507 = (t495/t503); +float t508 = (t507*t488); +float t509 = (t500/t503); +float t510 = (t509*t486); +float t511 = (t508-t510); +float t512 = (0*t511); +float t513 = (t506+t512); +float t514 = (-t493); +float t515 = (0*t514); +float t516 = (t513+t515); +float t517 = (0*0); +float t518 = (t516+t517); +float t519 = (t476*t507); +float t520 = (0+t519); +float t521 = (t509*t493); +float t522 = (t504*t488); +float t523 = (t521-t522); +float t524 = (0*t523); +float t525 = (t520+t524); +float t526 = (-t486); +float t527 = (0*t526); +float t528 = (t525+t527); +float t529 = (0*0); +float t530 = (t528+t529); +float t531 = (t476*t509); +float t532 = (0+t531); +float t533 = (t504*t486); +float t534 = (t507*t493); +float t535 = (t533-t534); +float t536 = (0*t535); +float t537 = (t532+t536); +float t538 = (-t488); +float t539 = (0*t538); +float t540 = (t537+t539); +float t541 = (0*0); +float t542 = (t540+t541); +float t543 = (t504*u1.u12); +float t544 = (t507*u1.u16); +float t545 = (t543+t544); +float t546 = (t509*u1.u20); +float t547 = (t545+t546); +float t548 = (-t547); +float t549 = (t476*t548); +float t550 = (0+t549); +float t551 = (t511*u1.u12); +float t552 = (t523*u1.u16); +float t553 = (t551+t552); +float t554 = (t535*u1.u20); +float t555 = (t553+t554); +float t556 = (-t555); +float t557 = (0*t556); +float t558 = (t550+t557); +float t559 = (t493*u1.u12); +float t560 = (t486*u1.u16); +float t561 = (t559+t560); +float t562 = (t488*u1.u20); +float t563 = (t561+t562); +float t564 = (0*t563); +float t565 = (t558+t564); +float t566 = (0*1); +float t567 = (t565+t566); +vec4 t568 = vec4(t518,t530,t542,t567); +float t569 = (0*t504); +float t570 = (0+t569); +float t571 = (1/t474); +float t572 = (t571*t511); +float t573 = (t570+t572); +float t574 = (0*t514); +float t575 = (t573+t574); +float t576 = (0*0); +float t577 = (t575+t576); +float t578 = (0*t507); +float t579 = (0+t578); +float t580 = (t571*t523); +float t581 = (t579+t580); +float t582 = (0*t526); +float t583 = (t581+t582); +float t584 = (0*0); +float t585 = (t583+t584); +float t586 = (0*t509); +float t587 = (0+t586); +float t588 = (t571*t535); +float t589 = (t587+t588); +float t590 = (0*t538); +float t591 = (t589+t590); +float t592 = (0*0); +float t593 = (t591+t592); +float t594 = (0*t548); +float t595 = (0+t594); +float t596 = (t571*t556); +float t597 = (t595+t596); +float t598 = (0*t563); +float t599 = (t597+t598); +float t600 = (0*1); +float t601 = (t599+t600); +vec4 t602 = vec4(t577,t585,t593,t601); +float t603 = (0*t504); +float t604 = (0+t603); +float t605 = (0*t511); +float t606 = (t604+t605); +float t607 = (350000+3000); +float t608 = (350000-3000); +float t609 = (t607/t608); +float t610 = (-t609); +float t611 = (t610*t514); +float t612 = (t606+t611); +float t613 = (float(0.5)/350000); +float t614 = (float(0.5)/3000); +float t615 = (t613-t614); +float t616 = (1/t615); +float t617 = (t616*0); +float t618 = (t612+t617); +float t619 = (0*t507); +float t620 = (0+t619); +float t621 = (0*t523); +float t622 = (t620+t621); +float t623 = (t610*t526); +float t624 = (t622+t623); +float t625 = (t616*0); +float t626 = (t624+t625); +float t627 = (0*t509); +float t628 = (0+t627); +float t629 = (0*t535); +float t630 = (t628+t629); +float t631 = (t610*t538); +float t632 = (t630+t631); +float t633 = (t616*0); +float t634 = (t632+t633); +float t635 = (0*t548); +float t636 = (0+t635); +float t637 = (0*t556); +float t638 = (t636+t637); +float t639 = (t610*t563); +float t640 = (t638+t639); +float t641 = (t616*1); +float t642 = (t640+t641); +vec4 t643 = vec4(t618,t626,t634,t642); +float t644 = (0*t504); +float t645 = (0+t644); +float t646 = (0*t511); +float t647 = (t645+t646); +float t648 = (-1); +float t649 = (t648*t514); +float t650 = (t647+t649); +float t651 = (0*0); +float t652 = (t650+t651); +float t653 = (0*t507); +float t654 = (0+t653); +float t655 = (0*t523); +float t656 = (t654+t655); +float t657 = (t648*t526); +float t658 = (t656+t657); +float t659 = (0*0); +float t660 = (t658+t659); +float t661 = (0*t509); +float t662 = (0+t661); +float t663 = (0*t535); +float t664 = (t662+t663); +float t665 = (t648*t538); +float t666 = (t664+t665); +float t667 = (0*0); +float t668 = (t666+t667); +float t669 = (0*t548); +float t670 = (0+t669); +float t671 = (0*t556); +float t672 = (t670+t671); +float t673 = (t648*t563); +float t674 = (t672+t673); +float t675 = (0*1); +float t676 = (t674+t675); +vec4 t677 = vec4(t652,t660,t668,t676); +mat4x4 t678 = mat4x4(t568,t602,t643,t677); +vec4 t679 = (t469*t678); +gl_Position = vec4(t679[0],t679[1],t679[2],t679[3]); +} diff --git a/test/data/large-shaders/small.vert b/test/data/large-shaders/small.vert new file mode 100644 --- /dev/null +++ b/test/data/large-shaders/small.vert @@ -0,0 +1,31 @@ +#version 450 +out float vf0; +out float vf1; +layout(std140) uniform uBlock1 { +float u0; +float u4; +float u8; +float u12; +float u16; +float u20; +float u24; +float u28; +} u1; +in vec2 in0; +void main() { +vec2 t0 = in0; +float t1 = (t0.x+1); +float t2 = (t1/2); +vf0 = t2; +float t3 = (t0.y+1); +float t4 = (t3/2); +vf1 = t4; +float t5 = (t0.x*u1.u28); +float t6 = (1-u1.u28); +float t7 = (t5-t6); +float t8 = (t7+u1.u0); +float t9 = (t0.y*u1.u28); +float t10 = (t9-t6); +float t11 = (t10+u1.u4); +gl_Position = vec4(t8,t11,0,1); +} diff --git a/test/data/large-shaders/xax.frag b/test/data/large-shaders/xax.frag new file mode 100644 --- /dev/null +++ b/test/data/large-shaders/xax.frag @@ -0,0 +1,15683 @@ +#version 450 +layout(location = 0) out vec4 out0; +layout(std140) uniform uBlock4 { +float u0; +} u4; +layout(std140) uniform uBlock6 { +float u0; +} u6; +layout(std140) uniform uBlock8 { +float u0; +} u8; +in float vf0; +in float vf1; +in float vf2; +void main() { +float t0 = (0*0); +float t1 = (1-0); +float t2 = (float(0.7)*t1); +float t3 = (t0+t2); +float t4 = (vf0*vf0); +float t5 = (vf2*vf2); +float t6 = (t4+t5); +float t7 = sqrt(t6); +float t8 = atan(t7,vf1); +float t9 = (3.1415927/2); +float t10 = (t8-t9); +float t11 = (float(22.4)/180); +float t12 = (t11*3.1415927); +float t13 = (t12/2); +float t14 = sin(t13); +float t15 = sin(t12); +float t16 = (1*t15); +float t17 = cos(0); +float t18 = (t16*t17); +float t19 = (t18*0); +float t20 = sin(t12); +float t21 = (1*t20); +float t22 = sin(0); +float t23 = (t21*t22); +float t24 = (t23*0); +float t25 = (t19-t24); +float t26 = cos(t12); +float t27 = (1*t26); +float t28 = (t27*0); +float t29 = (t18*1); +float t30 = (t28-t29); +float t31 = (t30*t30); +float t32 = (t25*t25); +float t33 = (t31+t32); +float t34 = (t23*1); +float t35 = (t27*0); +float t36 = (t34-t35); +float t37 = (t36*t36); +float t38 = (t33+t37); +float t39 = sqrt(t38); +float t40 = (t25/t39); +float t41 = (t14*t40); +float t42 = (t41*t41); +float t43 = (t36/t39); +float t44 = (t14*t43); +float t45 = (t44*t44); +float t46 = (t42+t45); +float t47 = (2*t46); +float t48 = (1-t47); +float t49 = (float(27.4)*840); +float t50 = (u4.u0/t49); +float t51 = (t50*3.1415927); +float t52 = (t51*2); +float t53 = sin(t52); +float t54 = (t53*float(2.5e-3)); +float t55 = (t48*t54); +float t56 = (t30/t39); +float t57 = (t14*t56); +float t58 = (t57*t41); +float t59 = cos(t13); +float t60 = (t44*t59); +float t61 = (t58-t60); +float t62 = (2*t61); +float t63 = (t62*0); +float t64 = (t55+t63); +float t65 = (t57*t44); +float t66 = (t41*t59); +float t67 = (t65+t66); +float t68 = (2*t67); +float t69 = (u4.u0/t49); +float t70 = (t69*3.1415927); +float t71 = (t70*2); +float t72 = cos(t71); +float t73 = (t72*float(2.5e-3)); +float t74 = (t68*t73); +float t75 = (t64+t74); +float t76 = (t75*t75); +float t77 = (t65-t66); +float t78 = (2*t77); +float t79 = (t78*t54); +float t80 = (t41*t44); +float t81 = (t57*t59); +float t82 = (t80+t81); +float t83 = (2*t82); +float t84 = (t83*0); +float t85 = (t79+t84); +float t86 = (t57*t57); +float t87 = (t86+t42); +float t88 = (2*t87); +float t89 = (1-t88); +float t90 = (t89*t73); +float t91 = (t85+t90); +float t92 = (t91*t91); +float t93 = (t76+t92); +float t94 = sqrt(t93); +float t95 = (t58+t60); +float t96 = (2*t95); +float t97 = (t96*t54); +float t98 = (t86+t45); +float t99 = (2*t98); +float t100 = (1-t99); +float t101 = (t100*0); +float t102 = (t97+t101); +float t103 = (t80-t81); +float t104 = (2*t103); +float t105 = (t104*t73); +float t106 = (t102+t105); +float t107 = atan(t94,t106); +float t108 = (3.1415927/2); +float t109 = (t107-t108); +float t110 = (t10-t109); +float t111 = abs(t110); +float t112 = (t111/2); +float t113 = sin(t112); +float t114 = (t113*t113); +float t115 = cos(t109); +float t116 = cos(t10); +float t117 = (t115*t116); +float t118 = atan(vf0,vf2); +float t119 = (t118+3.1415927); +float t120 = (3.1415927*2); +float t121 = mod(t119,t120); +float t122 = (t121-3.1415927); +float t123 = atan(t75,t91); +float t124 = (t123+3.1415927); +float t125 = (3.1415927*2); +float t126 = mod(t124,t125); +float t127 = (t126-3.1415927); +float t128 = (t122-t127); +float t129 = abs(t128); +float t130 = (t129/2); +float t131 = sin(t130); +float t132 = (t131*t131); +float t133 = (t117*t132); +float t134 = (t114+t133); +float t135 = sqrt(t134); +float t136 = asin(t135); +float t137 = (2*t136); +float t138 = (t75*t75); +float t139 = (t106*t106); +float t140 = (t138+t139); +float t141 = (t91*t91); +float t142 = (t140+t141); +float t143 = sqrt(t142); +float t144 = (t143*float(1.4959787e8)); +float t145 = (2*t144); +float t146 = (float(3474.4)/t145); +float t147 = asin(t146); +float t148 = (2*t147); +float t149 = (t148*4); +float t150 = (t137/t149); +float t151 = smoothstep(float(0.95),1,t150); +float t152 = (1-t151); +float t153 = (1-t152); +float t154 = (t153*0); +float t155 = (t152+t154); +float t156 = (t3*t155); +float t157 = (t12/2); +float t158 = sin(t157); +float t159 = sin(t12); +float t160 = (1*t159); +float t161 = cos(0); +float t162 = (t160*t161); +float t163 = (t162*0); +float t164 = sin(t12); +float t165 = (1*t164); +float t166 = sin(0); +float t167 = (t165*t166); +float t168 = (t167*0); +float t169 = (t163-t168); +float t170 = cos(t12); +float t171 = (1*t170); +float t172 = (t171*0); +float t173 = (t162*1); +float t174 = (t172-t173); +float t175 = (t174*t174); +float t176 = (t169*t169); +float t177 = (t175+t176); +float t178 = (t167*1); +float t179 = (t171*0); +float t180 = (t178-t179); +float t181 = (t180*t180); +float t182 = (t177+t181); +float t183 = sqrt(t182); +float t184 = (t169/t183); +float t185 = (t158*t184); +float t186 = (t185*t185); +float t187 = (t180/t183); +float t188 = (t158*t187); +float t189 = (t188*t188); +float t190 = (t186+t189); +float t191 = (2*t190); +float t192 = (1-t191); +float t193 = (365*840); +float t194 = (u4.u0/t193); +float t195 = (t194*3.1415927); +float t196 = (t195*2); +float t197 = sin(t196); +float t198 = (t197*1); +float t199 = (-1); +float t200 = (t198*t199); +float t201 = (t192*t200); +float t202 = (t174/t183); +float t203 = (t158*t202); +float t204 = (t203*t185); +float t205 = cos(t157); +float t206 = (t188*t205); +float t207 = (t204-t206); +float t208 = (2*t207); +float t209 = (t208*0); +float t210 = (t201+t209); +float t211 = (t203*t188); +float t212 = (t185*t205); +float t213 = (t211+t212); +float t214 = (2*t213); +float t215 = (u4.u0/t193); +float t216 = (t215*3.1415927); +float t217 = (t216*2); +float t218 = cos(t217); +float t219 = (t218*1); +float t220 = (t219*t199); +float t221 = (t214*t220); +float t222 = (t210+t221); +float t223 = (t222*t222); +float t224 = (t211-t212); +float t225 = (2*t224); +float t226 = (t225*t200); +float t227 = (t185*t188); +float t228 = (t203*t205); +float t229 = (t227+t228); +float t230 = (2*t229); +float t231 = (t230*0); +float t232 = (t226+t231); +float t233 = (t203*t203); +float t234 = (t233+t186); +float t235 = (2*t234); +float t236 = (1-t235); +float t237 = (t236*t220); +float t238 = (t232+t237); +float t239 = (t238*t238); +float t240 = (t223+t239); +float t241 = sqrt(t240); +float t242 = (t204+t206); +float t243 = (2*t242); +float t244 = (t243*t200); +float t245 = (t233+t189); +float t246 = (2*t245); +float t247 = (1-t246); +float t248 = (t247*0); +float t249 = (t244+t248); +float t250 = (t227-t228); +float t251 = (2*t250); +float t252 = (t251*t220); +float t253 = (t249+t252); +float t254 = atan(t241,t253); +float t255 = (3.1415927/2); +float t256 = (t254-t255); +vec4 t257 = vec4(0,1,0,0); +float t258 = mod(u4.u0,840); +float t259 = (t258/840); +float t260 = (t259*3.1415927); +float t261 = (t260*2); +float t262 = (t261/2); +float t263 = sin(t262); +float t264 = (0*0); +float t265 = (1*1); +float t266 = (t264+t265); +float t267 = (0*0); +float t268 = (t266+t267); +float t269 = sqrt(t268); +float t270 = (1/t269); +float t271 = (t263*t270); +float t272 = (t271*t271); +float t273 = (0/t269); +float t274 = (t263*t273); +float t275 = (t274*t274); +float t276 = (t272+t275); +float t277 = (2*t276); +float t278 = (1-t277); +float t279 = (3.1415927/4); +float t280 = (t279/2); +float t281 = sin(t280); +float t282 = sin(t279); +float t283 = (1*t282); +float t284 = cos(0); +float t285 = (t283*t284); +float t286 = (t285*0); +float t287 = sin(t279); +float t288 = (1*t287); +float t289 = sin(0); +float t290 = (t288*t289); +float t291 = (t290*0); +float t292 = (t286-t291); +float t293 = cos(t279); +float t294 = (1*t293); +float t295 = (t294*0); +float t296 = (t285*1); +float t297 = (t295-t296); +float t298 = (t297*t297); +float t299 = (t292*t292); +float t300 = (t298+t299); +float t301 = (t290*1); +float t302 = (t294*0); +float t303 = (t301-t302); +float t304 = (t303*t303); +float t305 = (t300+t304); +float t306 = sqrt(t305); +float t307 = (t292/t306); +float t308 = (t281*t307); +float t309 = (t308*t308); +float t310 = (t303/t306); +float t311 = (t281*t310); +float t312 = (t311*t311); +float t313 = (t309+t312); +float t314 = (2*t313); +float t315 = (1-t314); +float t316 = (t278*t315); +float t317 = (0+t316); +float t318 = (0/t269); +float t319 = (t263*t318); +float t320 = (t319*t271); +float t321 = cos(t262); +float t322 = (t274*t321); +float t323 = (t320-t322); +float t324 = (2*t323); +float t325 = (t297/t306); +float t326 = (t281*t325); +float t327 = (t326*t308); +float t328 = cos(t280); +float t329 = (t311*t328); +float t330 = (t327+t329); +float t331 = (2*t330); +float t332 = (t324*t331); +float t333 = (t317+t332); +float t334 = (t319*t274); +float t335 = (t271*t321); +float t336 = (t334+t335); +float t337 = (2*t336); +float t338 = (t326*t311); +float t339 = (t308*t328); +float t340 = (t338-t339); +float t341 = (2*t340); +float t342 = (t337*t341); +float t343 = (t333+t342); +float t344 = (t327-t329); +float t345 = (2*t344); +float t346 = (t278*t345); +float t347 = (0+t346); +float t348 = (t326*t326); +float t349 = (t348+t312); +float t350 = (2*t349); +float t351 = (1-t350); +float t352 = (t324*t351); +float t353 = (t347+t352); +float t354 = (t308*t311); +float t355 = (t326*t328); +float t356 = (t354+t355); +float t357 = (2*t356); +float t358 = (t337*t357); +float t359 = (t353+t358); +float t360 = (t338+t339); +float t361 = (2*t360); +float t362 = (t278*t361); +float t363 = (0+t362); +float t364 = (t354-t355); +float t365 = (2*t364); +float t366 = (t324*t365); +float t367 = (t363+t366); +float t368 = (t348+t309); +float t369 = (2*t368); +float t370 = (1-t369); +float t371 = (t337*t370); +float t372 = (t367+t371); +vec4 t373 = vec4(t343,t359,t372,0); +float t374 = (t320+t322); +float t375 = (2*t374); +float t376 = (t375*t315); +float t377 = (0+t376); +float t378 = (t319*t319); +float t379 = (t378+t275); +float t380 = (2*t379); +float t381 = (1-t380); +float t382 = (t381*t331); +float t383 = (t377+t382); +float t384 = (t271*t274); +float t385 = (t319*t321); +float t386 = (t384-t385); +float t387 = (2*t386); +float t388 = (t387*t341); +float t389 = (t383+t388); +float t390 = (t375*t345); +float t391 = (0+t390); +float t392 = (t381*t351); +float t393 = (t391+t392); +float t394 = (t387*t357); +float t395 = (t393+t394); +float t396 = (t375*t361); +float t397 = (0+t396); +float t398 = (t381*t365); +float t399 = (t397+t398); +float t400 = (t387*t370); +float t401 = (t399+t400); +vec4 t402 = vec4(t389,t395,t401,0); +float t403 = (t334-t335); +float t404 = (2*t403); +float t405 = (t404*t315); +float t406 = (0+t405); +float t407 = (t384+t385); +float t408 = (2*t407); +float t409 = (t408*t331); +float t410 = (t406+t409); +float t411 = (t378+t272); +float t412 = (2*t411); +float t413 = (1-t412); +float t414 = (t413*t341); +float t415 = (t410+t414); +float t416 = (t404*t345); +float t417 = (0+t416); +float t418 = (t408*t351); +float t419 = (t417+t418); +float t420 = (t413*t357); +float t421 = (t419+t420); +float t422 = (t404*t361); +float t423 = (0+t422); +float t424 = (t408*t365); +float t425 = (t423+t424); +float t426 = (t413*t370); +float t427 = (t425+t426); +vec4 t428 = vec4(t415,t421,t427,0); +vec4 t429 = vec4(0,0,0,1); +mat4x4 t430 = mat4x4(t373,t402,t428,t429); +vec4 t431 = (t257*t430); +float t432 = (t431[0]*t431[0]); +float t433 = (t431[2]*t431[2]); +float t434 = (t432+t433); +float t435 = sqrt(t434); +float t436 = atan(t435,t431[1]); +float t437 = (3.1415927/2); +float t438 = (t436-t437); +float t439 = (t256-t438); +float t440 = abs(t439); +float t441 = (t440/2); +float t442 = sin(t441); +float t443 = (t442*t442); +float t444 = cos(t438); +float t445 = cos(t256); +float t446 = (t444*t445); +float t447 = atan(t222,t238); +float t448 = (t447+3.1415927); +float t449 = (3.1415927*2); +float t450 = mod(t448,t449); +float t451 = (t450-3.1415927); +float t452 = atan(t431[0],t431[2]); +float t453 = (t452+3.1415927); +float t454 = (3.1415927*2); +float t455 = mod(t453,t454); +float t456 = (t455-3.1415927); +float t457 = (t451-t456); +float t458 = abs(t457); +float t459 = (t458/2); +float t460 = sin(t459); +float t461 = (t460*t460); +float t462 = (t446*t461); +float t463 = (t443+t462); +float t464 = sqrt(t463); +float t465 = asin(t464); +float t466 = (2*t465); +float t467 = (3.1415927-t466); +float t468 = (t467/3.1415927); +float t469 = smoothstep(float(0.48),float(0.59),t468); +float t470 = (float(0.0)*t469); +float t471 = (float(1.0)+t470); +float t472 = (1-t155); +float t473 = (t471*t472); +float t474 = (t156+t473); +float t475 = (3.1415927/2); +float t476 = (t8-t475); +float t477 = (3.1415927/2); +float t478 = (t254-t477); +float t479 = (t476-t478); +float t480 = abs(t479); +float t481 = (t480/2); +float t482 = sin(t481); +float t483 = (t482*t482); +float t484 = cos(t478); +float t485 = cos(t476); +float t486 = (t484*t485); +float t487 = (t118+3.1415927); +float t488 = (3.1415927*2); +float t489 = mod(t487,t488); +float t490 = (t489-3.1415927); +float t491 = (t447+3.1415927); +float t492 = (3.1415927*2); +float t493 = mod(t491,t492); +float t494 = (t493-3.1415927); +float t495 = (t490-t494); +float t496 = abs(t495); +float t497 = (t496/2); +float t498 = sin(t497); +float t499 = (t498*t498); +float t500 = (t486*t499); +float t501 = (t483+t500); +float t502 = sqrt(t501); +float t503 = asin(t502); +float t504 = (2*t503); +float t505 = (t222*t222); +float t506 = (t253*t253); +float t507 = (t505+t506); +float t508 = (t238*t238); +float t509 = (t507+t508); +float t510 = sqrt(t509); +float t511 = (t510*float(1.4959787e8)); +float t512 = (2*t511); +float t513 = (1392684/t512); +float t514 = asin(t513); +float t515 = (2*t514); +float t516 = (t515*4); +float t517 = (t504/t516); +float t518 = smoothstep(float(0.95),1,t517); +float t519 = (1-t518); +float t520 = (float(0.0)*t469); +float t521 = (t519+t520); +float t522 = (1-t521); +float t523 = (t522*t155); +float t524 = (t521+t523); +float t525 = (t474*t524); +float t526 = (3.1415927/2); +float t527 = (t8-t526); +float t528 = (t12/2); +float t529 = sin(t528); +float t530 = sin(t12); +float t531 = (1*t530); +float t532 = cos(0); +float t533 = (t531*t532); +float t534 = (t533*0); +float t535 = sin(t12); +float t536 = (1*t535); +float t537 = sin(0); +float t538 = (t536*t537); +float t539 = (t538*0); +float t540 = (t534-t539); +float t541 = cos(t12); +float t542 = (1*t541); +float t543 = (t542*0); +float t544 = (t533*1); +float t545 = (t543-t544); +float t546 = (t545*t545); +float t547 = (t540*t540); +float t548 = (t546+t547); +float t549 = (t538*1); +float t550 = (t542*0); +float t551 = (t549-t550); +float t552 = (t551*t551); +float t553 = (t548+t552); +float t554 = sqrt(t553); +float t555 = (t540/t554); +float t556 = (t529*t555); +float t557 = (t556*t556); +float t558 = (t551/t554); +float t559 = (t529*t558); +float t560 = (t559*t559); +float t561 = (t557+t560); +float t562 = (2*t561); +float t563 = (1-t562); +float t564 = (float(686.971)*840); +float t565 = (u4.u0/t564); +float t566 = (t565*3.1415927); +float t567 = (t566*2); +float t568 = sin(t567); +float t569 = (t568*float(1.5)); +float t570 = (u4.u0/t193); +float t571 = (t570*3.1415927); +float t572 = (t571*2); +float t573 = sin(t572); +float t574 = (t573*1); +float t575 = (t569-t574); +float t576 = (t563*t575); +float t577 = (t545/t554); +float t578 = (t529*t577); +float t579 = (t578*t556); +float t580 = cos(t528); +float t581 = (t559*t580); +float t582 = (t579-t581); +float t583 = (2*t582); +float t584 = (t583*0); +float t585 = (t576+t584); +float t586 = (t578*t559); +float t587 = (t556*t580); +float t588 = (t586+t587); +float t589 = (2*t588); +float t590 = (u4.u0/t564); +float t591 = (t590*3.1415927); +float t592 = (t591*2); +float t593 = cos(t592); +float t594 = (t593*float(1.5)); +float t595 = (u4.u0/t193); +float t596 = (t595*3.1415927); +float t597 = (t596*2); +float t598 = cos(t597); +float t599 = (t598*1); +float t600 = (t594-t599); +float t601 = (t589*t600); +float t602 = (t585+t601); +float t603 = (t602*t602); +float t604 = (t586-t587); +float t605 = (2*t604); +float t606 = (t605*t575); +float t607 = (t556*t559); +float t608 = (t578*t580); +float t609 = (t607+t608); +float t610 = (2*t609); +float t611 = (t610*0); +float t612 = (t606+t611); +float t613 = (t578*t578); +float t614 = (t613+t557); +float t615 = (2*t614); +float t616 = (1-t615); +float t617 = (t616*t600); +float t618 = (t612+t617); +float t619 = (t618*t618); +float t620 = (t603+t619); +float t621 = sqrt(t620); +float t622 = (t579+t581); +float t623 = (2*t622); +float t624 = (t623*t575); +float t625 = (t613+t560); +float t626 = (2*t625); +float t627 = (1-t626); +float t628 = (t627*0); +float t629 = (t624+t628); +float t630 = (t607-t608); +float t631 = (2*t630); +float t632 = (t631*t600); +float t633 = (t629+t632); +float t634 = atan(t621,t633); +float t635 = (3.1415927/2); +float t636 = (t634-t635); +float t637 = (t527-t636); +float t638 = abs(t637); +float t639 = (t638/2); +float t640 = sin(t639); +float t641 = (t640*t640); +float t642 = cos(t636); +float t643 = cos(t527); +float t644 = (t642*t643); +float t645 = (t118+3.1415927); +float t646 = (3.1415927*2); +float t647 = mod(t645,t646); +float t648 = (t647-3.1415927); +float t649 = atan(t602,t618); +float t650 = (t649+3.1415927); +float t651 = (3.1415927*2); +float t652 = mod(t650,t651); +float t653 = (t652-3.1415927); +float t654 = (t648-t653); +float t655 = abs(t654); +float t656 = (t655/2); +float t657 = sin(t656); +float t658 = (t657*t657); +float t659 = (t644*t658); +float t660 = (t641+t659); +float t661 = sqrt(t660); +float t662 = asin(t661); +float t663 = (2*t662); +float t664 = (t602*t602); +float t665 = (t633*t633); +float t666 = (t664+t665); +float t667 = (t618*t618); +float t668 = (t666+t667); +float t669 = sqrt(t668); +float t670 = (t669*float(1.4959787e8)); +float t671 = (2*t670); +float t672 = (6780/t671); +float t673 = asin(t672); +float t674 = (2*t673); +float t675 = (t674*4); +float t676 = (t663/t675); +float t677 = step(1,t676); +float t678 = (1-t677); +float t679 = (float(1.0)*t678); +float t680 = (1-t524); +float t681 = (t679*t680); +float t682 = (t525+t681); +float t683 = (1-t679); +float t684 = (t683*t524); +float t685 = (t679+t684); +float t686 = (t682*t685); +float t687 = (3.1415927/2); +float t688 = (t8-t687); +float t689 = (t12/2); +float t690 = sin(t689); +float t691 = sin(t12); +float t692 = (1*t691); +float t693 = cos(0); +float t694 = (t692*t693); +float t695 = (t694*0); +float t696 = sin(t12); +float t697 = (1*t696); +float t698 = sin(0); +float t699 = (t697*t698); +float t700 = (t699*0); +float t701 = (t695-t700); +float t702 = cos(t12); +float t703 = (1*t702); +float t704 = (t703*0); +float t705 = (t694*1); +float t706 = (t704-t705); +float t707 = (t706*t706); +float t708 = (t701*t701); +float t709 = (t707+t708); +float t710 = (t699*1); +float t711 = (t703*0); +float t712 = (t710-t711); +float t713 = (t712*t712); +float t714 = (t709+t713); +float t715 = sqrt(t714); +float t716 = (t701/t715); +float t717 = (t690*t716); +float t718 = (t717*t717); +float t719 = (t712/t715); +float t720 = (t690*t719); +float t721 = (t720*t720); +float t722 = (t718+t721); +float t723 = (2*t722); +float t724 = (1-t723); +float t725 = (float(224.7)*840); +float t726 = (u4.u0/t725); +float t727 = (t726*3.1415927); +float t728 = (t727*2); +float t729 = sin(t728); +float t730 = (t729*float(0.7205)); +float t731 = (u4.u0/t193); +float t732 = (t731*3.1415927); +float t733 = (t732*2); +float t734 = sin(t733); +float t735 = (t734*1); +float t736 = (t730-t735); +float t737 = (t724*t736); +float t738 = (t706/t715); +float t739 = (t690*t738); +float t740 = (t739*t717); +float t741 = cos(t689); +float t742 = (t720*t741); +float t743 = (t740-t742); +float t744 = (2*t743); +float t745 = (t744*0); +float t746 = (t737+t745); +float t747 = (t739*t720); +float t748 = (t717*t741); +float t749 = (t747+t748); +float t750 = (2*t749); +float t751 = (u4.u0/t725); +float t752 = (t751*3.1415927); +float t753 = (t752*2); +float t754 = cos(t753); +float t755 = (t754*float(0.7205)); +float t756 = (u4.u0/t193); +float t757 = (t756*3.1415927); +float t758 = (t757*2); +float t759 = cos(t758); +float t760 = (t759*1); +float t761 = (t755-t760); +float t762 = (t750*t761); +float t763 = (t746+t762); +float t764 = (t763*t763); +float t765 = (t747-t748); +float t766 = (2*t765); +float t767 = (t766*t736); +float t768 = (t717*t720); +float t769 = (t739*t741); +float t770 = (t768+t769); +float t771 = (2*t770); +float t772 = (t771*0); +float t773 = (t767+t772); +float t774 = (t739*t739); +float t775 = (t774+t718); +float t776 = (2*t775); +float t777 = (1-t776); +float t778 = (t777*t761); +float t779 = (t773+t778); +float t780 = (t779*t779); +float t781 = (t764+t780); +float t782 = sqrt(t781); +float t783 = (t740+t742); +float t784 = (2*t783); +float t785 = (t784*t736); +float t786 = (t774+t721); +float t787 = (2*t786); +float t788 = (1-t787); +float t789 = (t788*0); +float t790 = (t785+t789); +float t791 = (t768-t769); +float t792 = (2*t791); +float t793 = (t792*t761); +float t794 = (t790+t793); +float t795 = atan(t782,t794); +float t796 = (3.1415927/2); +float t797 = (t795-t796); +float t798 = (t688-t797); +float t799 = abs(t798); +float t800 = (t799/2); +float t801 = sin(t800); +float t802 = (t801*t801); +float t803 = cos(t797); +float t804 = cos(t688); +float t805 = (t803*t804); +float t806 = (t118+3.1415927); +float t807 = (3.1415927*2); +float t808 = mod(t806,t807); +float t809 = (t808-3.1415927); +float t810 = atan(t763,t779); +float t811 = (t810+3.1415927); +float t812 = (3.1415927*2); +float t813 = mod(t811,t812); +float t814 = (t813-3.1415927); +float t815 = (t809-t814); +float t816 = abs(t815); +float t817 = (t816/2); +float t818 = sin(t817); +float t819 = (t818*t818); +float t820 = (t805*t819); +float t821 = (t802+t820); +float t822 = sqrt(t821); +float t823 = asin(t822); +float t824 = (2*t823); +float t825 = (t763*t763); +float t826 = (t794*t794); +float t827 = (t825+t826); +float t828 = (t779*t779); +float t829 = (t827+t828); +float t830 = sqrt(t829); +float t831 = (t830*float(1.4959787e8)); +float t832 = (2*t831); +float t833 = (float(12103.6)/t832); +float t834 = asin(t833); +float t835 = (2*t834); +float t836 = (t835*4); +float t837 = (t824/t836); +float t838 = step(1,t837); +float t839 = (1-t838); +float t840 = (float(1.0)*t839); +float t841 = (1-t685); +float t842 = (t840*t841); +float t843 = (t686+t842); +float t844 = (1-t840); +float t845 = (t844*t685); +float t846 = (t840+t845); +float t847 = (t843*t846); +float t848 = (3.1415927/2); +float t849 = (t8-t848); +float t850 = (t12/2); +float t851 = sin(t850); +float t852 = sin(t12); +float t853 = (1*t852); +float t854 = cos(0); +float t855 = (t853*t854); +float t856 = (t855*0); +float t857 = sin(t12); +float t858 = (1*t857); +float t859 = sin(0); +float t860 = (t858*t859); +float t861 = (t860*0); +float t862 = (t856-t861); +float t863 = cos(t12); +float t864 = (1*t863); +float t865 = (t864*0); +float t866 = (t855*1); +float t867 = (t865-t866); +float t868 = (t867*t867); +float t869 = (t862*t862); +float t870 = (t868+t869); +float t871 = (t860*1); +float t872 = (t864*0); +float t873 = (t871-t872); +float t874 = (t873*t873); +float t875 = (t870+t874); +float t876 = sqrt(t875); +float t877 = (t862/t876); +float t878 = (t851*t877); +float t879 = (t878*t878); +float t880 = (t873/t876); +float t881 = (t851*t880); +float t882 = (t881*t881); +float t883 = (t879+t882); +float t884 = (2*t883); +float t885 = (1-t884); +float t886 = (float(4332.59)*840); +float t887 = (u4.u0/t886); +float t888 = (t887*3.1415927); +float t889 = (t888*2); +float t890 = sin(t889); +float t891 = (t890*float(5.2)); +float t892 = (u4.u0/t193); +float t893 = (t892*3.1415927); +float t894 = (t893*2); +float t895 = sin(t894); +float t896 = (t895*1); +float t897 = (t891-t896); +float t898 = (t885*t897); +float t899 = (t867/t876); +float t900 = (t851*t899); +float t901 = (t900*t878); +float t902 = cos(t850); +float t903 = (t881*t902); +float t904 = (t901-t903); +float t905 = (2*t904); +float t906 = (t905*0); +float t907 = (t898+t906); +float t908 = (t900*t881); +float t909 = (t878*t902); +float t910 = (t908+t909); +float t911 = (2*t910); +float t912 = (u4.u0/t886); +float t913 = (t912*3.1415927); +float t914 = (t913*2); +float t915 = cos(t914); +float t916 = (t915*float(5.2)); +float t917 = (u4.u0/t193); +float t918 = (t917*3.1415927); +float t919 = (t918*2); +float t920 = cos(t919); +float t921 = (t920*1); +float t922 = (t916-t921); +float t923 = (t911*t922); +float t924 = (t907+t923); +float t925 = (t924*t924); +float t926 = (t908-t909); +float t927 = (2*t926); +float t928 = (t927*t897); +float t929 = (t878*t881); +float t930 = (t900*t902); +float t931 = (t929+t930); +float t932 = (2*t931); +float t933 = (t932*0); +float t934 = (t928+t933); +float t935 = (t900*t900); +float t936 = (t935+t879); +float t937 = (2*t936); +float t938 = (1-t937); +float t939 = (t938*t922); +float t940 = (t934+t939); +float t941 = (t940*t940); +float t942 = (t925+t941); +float t943 = sqrt(t942); +float t944 = (t901+t903); +float t945 = (2*t944); +float t946 = (t945*t897); +float t947 = (t935+t882); +float t948 = (2*t947); +float t949 = (1-t948); +float t950 = (t949*0); +float t951 = (t946+t950); +float t952 = (t929-t930); +float t953 = (2*t952); +float t954 = (t953*t922); +float t955 = (t951+t954); +float t956 = atan(t943,t955); +float t957 = (3.1415927/2); +float t958 = (t956-t957); +float t959 = (t849-t958); +float t960 = abs(t959); +float t961 = (t960/2); +float t962 = sin(t961); +float t963 = (t962*t962); +float t964 = cos(t958); +float t965 = cos(t849); +float t966 = (t964*t965); +float t967 = (t118+3.1415927); +float t968 = (3.1415927*2); +float t969 = mod(t967,t968); +float t970 = (t969-3.1415927); +float t971 = atan(t924,t940); +float t972 = (t971+3.1415927); +float t973 = (3.1415927*2); +float t974 = mod(t972,t973); +float t975 = (t974-3.1415927); +float t976 = (t970-t975); +float t977 = abs(t976); +float t978 = (t977/2); +float t979 = sin(t978); +float t980 = (t979*t979); +float t981 = (t966*t980); +float t982 = (t963+t981); +float t983 = sqrt(t982); +float t984 = asin(t983); +float t985 = (2*t984); +float t986 = (t924*t924); +float t987 = (t955*t955); +float t988 = (t986+t987); +float t989 = (t940*t940); +float t990 = (t988+t989); +float t991 = sqrt(t990); +float t992 = (t991*float(1.4959787e8)); +float t993 = (2*t992); +float t994 = (140000/t993); +float t995 = asin(t994); +float t996 = (2*t995); +float t997 = (t996*4); +float t998 = (t985/t997); +float t999 = step(1,t998); +float t1000 = (1-t999); +float t1001 = step(float(0.98),t998); +float t1002 = cos(t956); +float t1003 = (1*t1002); +float t1004 = (t1003*0); +float t1005 = sin(t956); +float t1006 = (1*t1005); +float t1007 = cos(t971); +float t1008 = (t1006*t1007); +float t1009 = (t1008*1); +float t1010 = (t1004-t1009); +float t1011 = sin(t8); +float t1012 = (1*t1011); +float t1013 = sin(t118); +float t1014 = (t1012*t1013); +float t1015 = (t1010*t1014); +float t1016 = (t1008*0); +float t1017 = sin(t956); +float t1018 = (1*t1017); +float t1019 = sin(t971); +float t1020 = (t1018*t1019); +float t1021 = (t1020*0); +float t1022 = (t1016-t1021); +float t1023 = cos(t8); +float t1024 = (1*t1023); +float t1025 = (t1022*t1024); +float t1026 = (t1015+t1025); +float t1027 = (t1020*1); +float t1028 = (t1003*0); +float t1029 = (t1027-t1028); +float t1030 = sin(t8); +float t1031 = (1*t1030); +float t1032 = cos(t118); +float t1033 = (t1031*t1032); +float t1034 = (t1029*t1033); +float t1035 = (t1026+t1034); +float t1036 = (t1022*t1008); +float t1037 = (t1029*t1003); +float t1038 = (t1036-t1037); +float t1039 = (t1038*t1014); +float t1040 = (t1029*t1020); +float t1041 = (t1010*t1008); +float t1042 = (t1040-t1041); +float t1043 = (t1042*t1024); +float t1044 = (t1039+t1043); +float t1045 = (t1010*t1003); +float t1046 = (t1022*t1020); +float t1047 = (t1045-t1046); +float t1048 = (t1047*t1033); +float t1049 = (t1044+t1048); +float t1050 = atan(t1035,t1049); +float t1051 = (t1050+3.1415927); +float t1052 = (t1051/3.1415927); +float t1053 = (t1052*2); +float t1054 = (t1053*12); +float t1055 = fract(t1054); +float t1056 = step(float(0.75),t1055); +float t1057 = step(float(0.5),t998); +float t1058 = (t1056*t1057); +float t1059 = (t1001+t1058); +bool t1060 = (1<=t1059); +float t1061; +if(t1060){ +t1061 = 1; +} else { +t1061 = t1059; +} +float t1062 = (float(0.6)*t1061); +float t1063 = (float(1.0)*t1061); +float t1064 = (t1062*t1063); +float t1065 = (1-t1063); +float t1066 = (float(6.0e-2)*t1065); +float t1067 = (t1064+t1066); +float t1068 = (t998*3.1415927); +float t1069 = cos(t1068); +float t1070 = (t1069/2); +float t1071 = (t1070+float(0.5)); +float t1072 = (t1071+float(0.5)); +float t1073 = (t1067*t1072); +float t1074 = (1-float(1.0)); +float t1075 = (t1074*t1063); +float t1076 = (float(1.0)+t1075); +float t1077 = (t1076*t1072); +float t1078 = (t1073*t1077); +float t1079 = (1-t1077); +float t1080 = (0*t1079); +float t1081 = (t1078+t1080); +float t1082 = (t1000*t1081); +float t1083 = (1-t846); +float t1084 = (t1082*t1083); +float t1085 = (t847+t1084); +float t1086 = (1-1); +float t1087 = (t1086*t1077); +float t1088 = (1+t1087); +float t1089 = (t1000*t1088); +float t1090 = (1-t1089); +float t1091 = (t1090*t846); +float t1092 = (t1089+t1091); +float t1093 = (t1085*t1092); +float t1094 = (3.1415927/2); +float t1095 = (t8-t1094); +float t1096 = (t12/2); +float t1097 = sin(t1096); +float t1098 = sin(t12); +float t1099 = (1*t1098); +float t1100 = cos(0); +float t1101 = (t1099*t1100); +float t1102 = (t1101*0); +float t1103 = sin(t12); +float t1104 = (1*t1103); +float t1105 = sin(0); +float t1106 = (t1104*t1105); +float t1107 = (t1106*0); +float t1108 = (t1102-t1107); +float t1109 = cos(t12); +float t1110 = (1*t1109); +float t1111 = (t1110*0); +float t1112 = (t1101*1); +float t1113 = (t1111-t1112); +float t1114 = (t1113*t1113); +float t1115 = (t1108*t1108); +float t1116 = (t1114+t1115); +float t1117 = (t1106*1); +float t1118 = (t1110*0); +float t1119 = (t1117-t1118); +float t1120 = (t1119*t1119); +float t1121 = (t1116+t1120); +float t1122 = sqrt(t1121); +float t1123 = (t1108/t1122); +float t1124 = (t1097*t1123); +float t1125 = (t1124*t1124); +float t1126 = (t1119/t1122); +float t1127 = (t1097*t1126); +float t1128 = (t1127*t1127); +float t1129 = (t1125+t1128); +float t1130 = (2*t1129); +float t1131 = (1-t1130); +float t1132 = (float(10759.22)*840); +float t1133 = (u4.u0/t1132); +float t1134 = (t1133*3.1415927); +float t1135 = (t1134*2); +float t1136 = sin(t1135); +float t1137 = (t1136*float(9.5)); +float t1138 = (u4.u0/t193); +float t1139 = (t1138*3.1415927); +float t1140 = (t1139*2); +float t1141 = sin(t1140); +float t1142 = (t1141*1); +float t1143 = (t1137-t1142); +float t1144 = (t1131*t1143); +float t1145 = (t1113/t1122); +float t1146 = (t1097*t1145); +float t1147 = (t1146*t1124); +float t1148 = cos(t1096); +float t1149 = (t1127*t1148); +float t1150 = (t1147-t1149); +float t1151 = (2*t1150); +float t1152 = (t1151*0); +float t1153 = (t1144+t1152); +float t1154 = (t1146*t1127); +float t1155 = (t1124*t1148); +float t1156 = (t1154+t1155); +float t1157 = (2*t1156); +float t1158 = (u4.u0/t1132); +float t1159 = (t1158*3.1415927); +float t1160 = (t1159*2); +float t1161 = cos(t1160); +float t1162 = (t1161*float(9.5)); +float t1163 = (u4.u0/t193); +float t1164 = (t1163*3.1415927); +float t1165 = (t1164*2); +float t1166 = cos(t1165); +float t1167 = (t1166*1); +float t1168 = (t1162-t1167); +float t1169 = (t1157*t1168); +float t1170 = (t1153+t1169); +float t1171 = (t1170*t1170); +float t1172 = (t1154-t1155); +float t1173 = (2*t1172); +float t1174 = (t1173*t1143); +float t1175 = (t1124*t1127); +float t1176 = (t1146*t1148); +float t1177 = (t1175+t1176); +float t1178 = (2*t1177); +float t1179 = (t1178*0); +float t1180 = (t1174+t1179); +float t1181 = (t1146*t1146); +float t1182 = (t1181+t1125); +float t1183 = (2*t1182); +float t1184 = (1-t1183); +float t1185 = (t1184*t1168); +float t1186 = (t1180+t1185); +float t1187 = (t1186*t1186); +float t1188 = (t1171+t1187); +float t1189 = sqrt(t1188); +float t1190 = (t1147+t1149); +float t1191 = (2*t1190); +float t1192 = (t1191*t1143); +float t1193 = (t1181+t1128); +float t1194 = (2*t1193); +float t1195 = (1-t1194); +float t1196 = (t1195*0); +float t1197 = (t1192+t1196); +float t1198 = (t1175-t1176); +float t1199 = (2*t1198); +float t1200 = (t1199*t1168); +float t1201 = (t1197+t1200); +float t1202 = atan(t1189,t1201); +float t1203 = (3.1415927/2); +float t1204 = (t1202-t1203); +float t1205 = (t1095-t1204); +float t1206 = abs(t1205); +float t1207 = (t1206/2); +float t1208 = sin(t1207); +float t1209 = (t1208*t1208); +float t1210 = cos(t1204); +float t1211 = cos(t1095); +float t1212 = (t1210*t1211); +float t1213 = (t118+3.1415927); +float t1214 = (3.1415927*2); +float t1215 = mod(t1213,t1214); +float t1216 = (t1215-3.1415927); +float t1217 = atan(t1170,t1186); +float t1218 = (t1217+3.1415927); +float t1219 = (3.1415927*2); +float t1220 = mod(t1218,t1219); +float t1221 = (t1220-3.1415927); +float t1222 = (t1216-t1221); +float t1223 = abs(t1222); +float t1224 = (t1223/2); +float t1225 = sin(t1224); +float t1226 = (t1225*t1225); +float t1227 = (t1212*t1226); +float t1228 = (t1209+t1227); +float t1229 = sqrt(t1228); +float t1230 = asin(t1229); +float t1231 = (2*t1230); +float t1232 = (t1170*t1170); +float t1233 = (t1201*t1201); +float t1234 = (t1232+t1233); +float t1235 = (t1186*t1186); +float t1236 = (t1234+t1235); +float t1237 = sqrt(t1236); +float t1238 = (t1237*float(1.4959787e8)); +float t1239 = (2*t1238); +float t1240 = (118000/t1239); +float t1241 = asin(t1240); +float t1242 = (2*t1241); +float t1243 = (t1242*4); +float t1244 = (t1231/t1243); +float t1245 = step(1,t1244); +float t1246 = (1-t1245); +float t1247 = (float(0.9)*t1246); +float t1248 = (1-t1092); +float t1249 = (t1247*t1248); +float t1250 = (t1093+t1249); +float t1251 = (float(1.0)*t1246); +float t1252 = (1-t1251); +float t1253 = (t1252*t1092); +float t1254 = (t1251+t1253); +float t1255 = (t1250*t1254); +float t1256 = smoothstep(float(0.45),float(0.55),t468); +float t1257 = (float(0.3)*t1256); +float t1258 = (1-t1256); +float t1259 = (float(0.5)*t1258); +float t1260 = (t1257+t1259); +float t1261 = (3.1415927/2); +float t1262 = (t8-t1261); +float t1263 = (3.1415927/2); +float t1264 = (t436-t1263); +float t1265 = (t1262-t1264); +float t1266 = abs(t1265); +float t1267 = (t1266/2); +float t1268 = sin(t1267); +float t1269 = (t1268*t1268); +float t1270 = cos(t1264); +float t1271 = cos(t1262); +float t1272 = (t1270*t1271); +float t1273 = (t118+3.1415927); +float t1274 = (3.1415927*2); +float t1275 = mod(t1273,t1274); +float t1276 = (t1275-3.1415927); +float t1277 = (t452+3.1415927); +float t1278 = (3.1415927*2); +float t1279 = mod(t1277,t1278); +float t1280 = (t1279-3.1415927); +float t1281 = (t1276-t1280); +float t1282 = abs(t1281); +float t1283 = (t1282/2); +float t1284 = sin(t1283); +float t1285 = (t1284*t1284); +float t1286 = (t1272*t1285); +float t1287 = (t1269+t1286); +float t1288 = sqrt(t1287); +float t1289 = asin(t1288); +float t1290 = (2*t1289); +float t1291 = (3.1415927-t1290); +float t1292 = (t1291/3.1415927); +float t1293 = (t1292-float(0.5)); +float t1294 = (-2); +float t1295 = (t1293*t1294); +float t1296 = (1-t1295); +float t1297 = (float(0.8)*t1296); +float t1298 = smoothstep(float(0.4),float(0.6),t468); +float t1299 = (t1298*3.1415927); +float t1300 = sin(t1299); +float t1301 = (t1297*t1300); +float t1302 = (3.1415927/2); +float t1303 = (t8-t1302); +float t1304 = (3.1415927/2); +float t1305 = (t254-t1304); +float t1306 = (t1303-t1305); +float t1307 = abs(t1306); +float t1308 = (t1307/2); +float t1309 = sin(t1308); +float t1310 = (t1309*t1309); +float t1311 = cos(t1305); +float t1312 = cos(t1303); +float t1313 = (t1311*t1312); +float t1314 = (t118+3.1415927); +float t1315 = (3.1415927*2); +float t1316 = mod(t1314,t1315); +float t1317 = (t1316-3.1415927); +float t1318 = (t447+3.1415927); +float t1319 = (3.1415927*2); +float t1320 = mod(t1318,t1319); +float t1321 = (t1320-3.1415927); +float t1322 = (t1317-t1321); +float t1323 = abs(t1322); +float t1324 = (t1323/2); +float t1325 = sin(t1324); +float t1326 = (t1325*t1325); +float t1327 = (t1313*t1326); +float t1328 = (t1310+t1327); +float t1329 = sqrt(t1328); +float t1330 = asin(t1329); +float t1331 = (2*t1330); +float t1332 = (3.1415927-t1331); +float t1333 = (t1332/3.1415927); +float t1334 = smoothstep(float(0.5),float(0.7),t1333); +float t1335 = (t1301*t1334); +float t1336 = (t1260+t1335); +float t1337 = (u8.u0*t1336); +float t1338 = (t1333/2); +float t1339 = (t1338+float(0.5)); +float t1340 = smoothstep(float(0.3),float(0.6),t468); +float t1341 = (t1339*t1340); +float t1342 = (u8.u0*t1341); +float t1343 = (t1337*t1342); +float t1344 = (3.1415927/36); +float t1345 = (t8/t1344); +float t1346 = floor(t1345); +float t1347 = (t1346/36); +float t1348 = (t1346/36); +float t1349 = (t1348*float(842.378)); +float t1350 = fract(t1349); +float t1351 = (t1350+float(45.32)); +float t1352 = (t1351+u6.u0); +float t1353 = (t1350*t1352); +float t1354 = (t1346/36); +float t1355 = (t1354*3.1415927); +float t1356 = sin(t1355); +float t1357 = (36*t1356); +float t1358 = floor(t1357); +float t1359 = (t1358+1); +float t1360 = (3.1415927/t1359); +float t1361 = (t118/t1360); +float t1362 = floor(t1361); +float t1363 = (t1362/t1359); +float t1364 = (t1363*float(1734.048)); +float t1365 = fract(t1364); +float t1366 = (t1365+float(45.32)); +float t1367 = (t1366+u6.u0); +float t1368 = (t1365*t1367); +float t1369 = (t1353+t1368); +float t1370 = (t1350+t1369); +float t1371 = (t1365+t1369); +float t1372 = (t1370*t1371); +float t1373 = fract(t1372); +float t1374 = (t1373*5); +float t1375 = (t1347+t1374); +float t1376 = fract(t1375); +float t1377 = (t1376*12000); +float t1378 = (t1377/1000); +bool t1379 = (1<=t1378); +float t1380; +if(t1379){ +t1380 = 1; +} else { +t1380 = t1378; +} +float t1381 = (t1377-6000); +float t1382 = (t1381/8000); +bool t1383 = (0>=t1382); +float t1384; +if(t1383){ +t1384 = 0; +} else { +t1384 = t1382; +} +float t1385 = (t1380-t1384); +float t1386 = (t1373*173); +float t1387 = fract(t1386); +float t1388 = step(float(0.66),t1387); +float t1389 = (t1388*3); +float t1390 = (3+t1389); +float t1391 = (3.1415927/t1390); +float t1392 = cos(t1391); +float t1393 = (1-t1392); +float t1394 = (t1346*t1344); +float t1395 = (t1346/36); +float t1396 = (t1395*float(842.378)); +float t1397 = fract(t1396); +float t1398 = (t1397+float(45.32)); +float t1399 = (t1398+u6.u0); +float t1400 = (t1397*t1399); +float t1401 = (t1362/t1359); +float t1402 = (t1401*float(1734.048)); +float t1403 = fract(t1402); +float t1404 = (t1403+float(45.32)); +float t1405 = (t1404+u6.u0); +float t1406 = (t1403*t1405); +float t1407 = (t1400+t1406); +float t1408 = (t1397+t1407); +float t1409 = (t1403+t1407); +float t1410 = (t1408*t1409); +float t1411 = fract(t1410); +float t1412 = (t1411*float(2852.02)); +float t1413 = fract(t1412); +float t1414 = (t1413-float(0.5)); +float t1415 = (t1414*t1344); +float t1416 = (t1415*float(0.75)); +float t1417 = (t1394+t1416); +float t1418 = cos(t1417); +float t1419 = (1*t1418); +float t1420 = (t1419*0); +float t1421 = sin(t1417); +float t1422 = (1*t1421); +float t1423 = (3.1415927/t1359); +float t1424 = (t1362*t1423); +float t1425 = (t1411*float(97372.83)); +float t1426 = fract(t1425); +float t1427 = (t1426-float(0.5)); +float t1428 = (3.1415927/t1359); +float t1429 = (t1427*t1428); +float t1430 = (t1429*float(0.75)); +float t1431 = (t1424+t1430); +float t1432 = (t1431+3.1415927); +float t1433 = (3.1415927*2); +float t1434 = mod(t1432,t1433); +float t1435 = (t1434-3.1415927); +float t1436 = cos(t1435); +float t1437 = (t1422*t1436); +float t1438 = (t1437*1); +float t1439 = (t1420-t1438); +float t1440 = sin(t8); +float t1441 = (1*t1440); +float t1442 = sin(t118); +float t1443 = (t1441*t1442); +float t1444 = (t1439*t1443); +float t1445 = (t1437*0); +float t1446 = sin(t1417); +float t1447 = (1*t1446); +float t1448 = sin(t1435); +float t1449 = (t1447*t1448); +float t1450 = (t1449*0); +float t1451 = (t1445-t1450); +float t1452 = cos(t8); +float t1453 = (1*t1452); +float t1454 = (t1451*t1453); +float t1455 = (t1444+t1454); +float t1456 = (t1449*1); +float t1457 = (t1419*0); +float t1458 = (t1456-t1457); +float t1459 = sin(t8); +float t1460 = (1*t1459); +float t1461 = cos(t118); +float t1462 = (t1460*t1461); +float t1463 = (t1458*t1462); +float t1464 = (t1455+t1463); +float t1465 = (t1451*t1437); +float t1466 = (t1458*t1419); +float t1467 = (t1465-t1466); +float t1468 = (t1467*t1443); +float t1469 = (t1458*t1449); +float t1470 = (t1439*t1437); +float t1471 = (t1469-t1470); +float t1472 = (t1471*t1453); +float t1473 = (t1468+t1472); +float t1474 = (t1439*t1419); +float t1475 = (t1451*t1449); +float t1476 = (t1474-t1475); +float t1477 = (t1476*t1462); +float t1478 = (t1473+t1477); +float t1479 = atan(t1464,t1478); +float t1480 = (t1479+3.1415927); +float t1481 = (t1387*3.1415927); +float t1482 = (t1480+t1481); +float t1483 = (3.1415927*2); +float t1484 = (t1482/t1483); +float t1485 = fract(t1484); +float t1486 = (t1485*t1390); +float t1487 = fract(t1486); +float t1488 = (t1487*2); +float t1489 = (t1488-1); +float t1490 = abs(t1489); +float t1491 = (t1490*t1490); +float t1492 = (t1393*t1491); +float t1493 = (t1392+t1492); +float t1494 = (t1373*float(8.0e-3)); +float t1495 = (float(1.0e-3)+t1494); +float t1496 = step(float(0.66),t1387); +float t1497 = (t1496*float(3.0e-3)); +float t1498 = (t1495-t1497); +float t1499 = (t1498*float(0.8)); +float t1500 = (t1493*t1499); +float t1501 = (3.1415927/2); +float t1502 = (t1417-t1501); +float t1503 = (3.1415927/2); +float t1504 = (t8-t1503); +float t1505 = (t1502-t1504); +float t1506 = abs(t1505); +float t1507 = (t1506/2); +float t1508 = sin(t1507); +float t1509 = (t1508*t1508); +float t1510 = cos(t1504); +float t1511 = cos(t1502); +float t1512 = (t1510*t1511); +float t1513 = (t1435+3.1415927); +float t1514 = (3.1415927*2); +float t1515 = mod(t1513,t1514); +float t1516 = (t1515-3.1415927); +float t1517 = (t118+3.1415927); +float t1518 = (3.1415927*2); +float t1519 = mod(t1517,t1518); +float t1520 = (t1519-3.1415927); +float t1521 = (t1516-t1520); +float t1522 = abs(t1521); +float t1523 = (t1522/2); +float t1524 = sin(t1523); +float t1525 = (t1524*t1524); +float t1526 = (t1512*t1525); +float t1527 = (t1509+t1526); +float t1528 = sqrt(t1527); +float t1529 = asin(t1528); +float t1530 = (2*t1529); +float t1531 = step(t1500,t1530); +float t1532 = (1-t1531); +float t1533 = (t1385*t1532); +float t1534 = (3.1415927/2); +float t1535 = (t8-t1534); +float t1536 = (3.1415927/2); +float t1537 = (t1417-t1536); +float t1538 = (t1535-t1537); +float t1539 = abs(t1538); +float t1540 = (t1539/2); +float t1541 = sin(t1540); +float t1542 = (t1541*t1541); +float t1543 = cos(t1537); +float t1544 = cos(t1535); +float t1545 = (t1543*t1544); +float t1546 = (t118+3.1415927); +float t1547 = (3.1415927*2); +float t1548 = mod(t1546,t1547); +float t1549 = (t1548-3.1415927); +float t1550 = (t1435+3.1415927); +float t1551 = (3.1415927*2); +float t1552 = mod(t1550,t1551); +float t1553 = (t1552-3.1415927); +float t1554 = (t1549-t1553); +float t1555 = abs(t1554); +float t1556 = (t1555/2); +float t1557 = sin(t1556); +float t1558 = (t1557*t1557); +float t1559 = (t1545*t1558); +float t1560 = (t1542+t1559); +float t1561 = sqrt(t1560); +float t1562 = asin(t1561); +float t1563 = (2*t1562); +float t1564 = (1/t1563); +float t1565 = (t1564*t1499); +float t1566 = (t1565*float(1.25e-2)); +float t1567 = (u4.u0*t1373); +float t1568 = cos(t1567); +float t1569 = (t1568+1); +float t1570 = (t1569/2); +float t1571 = (t1566*t1570); +float t1572 = (t1571*t1385); +float t1573 = (t1533+t1572); +float t1574 = (0+t1573); +float t1575 = (t1346/36); +float t1576 = (t1346/36); +float t1577 = (t1576*float(842.378)); +float t1578 = fract(t1577); +float t1579 = (t1578+float(45.32)); +float t1580 = (t1579+u6.u0); +float t1581 = (t1578*t1580); +float t1582 = (t1362+1); +float t1583 = (t1582/t1359); +float t1584 = (t1583*float(1734.048)); +float t1585 = fract(t1584); +float t1586 = (t1585+float(45.32)); +float t1587 = (t1586+u6.u0); +float t1588 = (t1585*t1587); +float t1589 = (t1581+t1588); +float t1590 = (t1578+t1589); +float t1591 = (t1585+t1589); +float t1592 = (t1590*t1591); +float t1593 = fract(t1592); +float t1594 = (t1593*5); +float t1595 = (t1575+t1594); +float t1596 = fract(t1595); +float t1597 = (t1596*12000); +float t1598 = (t1597/1000); +bool t1599 = (1<=t1598); +float t1600; +if(t1599){ +t1600 = 1; +} else { +t1600 = t1598; +} +float t1601 = (t1597-6000); +float t1602 = (t1601/8000); +bool t1603 = (0>=t1602); +float t1604; +if(t1603){ +t1604 = 0; +} else { +t1604 = t1602; +} +float t1605 = (t1600-t1604); +float t1606 = (t1593*173); +float t1607 = fract(t1606); +float t1608 = step(float(0.66),t1607); +float t1609 = (t1608*3); +float t1610 = (3+t1609); +float t1611 = (3.1415927/t1610); +float t1612 = cos(t1611); +float t1613 = (1-t1612); +float t1614 = (t1346*t1344); +float t1615 = (t1346/36); +float t1616 = (t1615*float(842.378)); +float t1617 = fract(t1616); +float t1618 = (t1617+float(45.32)); +float t1619 = (t1618+u6.u0); +float t1620 = (t1617*t1619); +float t1621 = (t1582/t1359); +float t1622 = (t1621*float(1734.048)); +float t1623 = fract(t1622); +float t1624 = (t1623+float(45.32)); +float t1625 = (t1624+u6.u0); +float t1626 = (t1623*t1625); +float t1627 = (t1620+t1626); +float t1628 = (t1617+t1627); +float t1629 = (t1623+t1627); +float t1630 = (t1628*t1629); +float t1631 = fract(t1630); +float t1632 = (t1631*float(2852.02)); +float t1633 = fract(t1632); +float t1634 = (t1633-float(0.5)); +float t1635 = (t1634*t1344); +float t1636 = (t1635*float(0.75)); +float t1637 = (t1614+t1636); +float t1638 = cos(t1637); +float t1639 = (1*t1638); +float t1640 = (t1639*0); +float t1641 = sin(t1637); +float t1642 = (1*t1641); +float t1643 = (3.1415927/t1359); +float t1644 = (t1582*t1643); +float t1645 = (t1631*float(97372.83)); +float t1646 = fract(t1645); +float t1647 = (t1646-float(0.5)); +float t1648 = (3.1415927/t1359); +float t1649 = (t1647*t1648); +float t1650 = (t1649*float(0.75)); +float t1651 = (t1644+t1650); +float t1652 = (t1651+3.1415927); +float t1653 = mod(t1652,t1433); +float t1654 = (t1653-3.1415927); +float t1655 = cos(t1654); +float t1656 = (t1642*t1655); +float t1657 = (t1656*1); +float t1658 = (t1640-t1657); +float t1659 = sin(t8); +float t1660 = (1*t1659); +float t1661 = sin(t118); +float t1662 = (t1660*t1661); +float t1663 = (t1658*t1662); +float t1664 = (t1656*0); +float t1665 = sin(t1637); +float t1666 = (1*t1665); +float t1667 = sin(t1654); +float t1668 = (t1666*t1667); +float t1669 = (t1668*0); +float t1670 = (t1664-t1669); +float t1671 = cos(t8); +float t1672 = (1*t1671); +float t1673 = (t1670*t1672); +float t1674 = (t1663+t1673); +float t1675 = (t1668*1); +float t1676 = (t1639*0); +float t1677 = (t1675-t1676); +float t1678 = sin(t8); +float t1679 = (1*t1678); +float t1680 = cos(t118); +float t1681 = (t1679*t1680); +float t1682 = (t1677*t1681); +float t1683 = (t1674+t1682); +float t1684 = (t1670*t1656); +float t1685 = (t1677*t1639); +float t1686 = (t1684-t1685); +float t1687 = (t1686*t1662); +float t1688 = (t1677*t1668); +float t1689 = (t1658*t1656); +float t1690 = (t1688-t1689); +float t1691 = (t1690*t1672); +float t1692 = (t1687+t1691); +float t1693 = (t1658*t1639); +float t1694 = (t1670*t1668); +float t1695 = (t1693-t1694); +float t1696 = (t1695*t1681); +float t1697 = (t1692+t1696); +float t1698 = atan(t1683,t1697); +float t1699 = (t1698+3.1415927); +float t1700 = (t1607*3.1415927); +float t1701 = (t1699+t1700); +float t1702 = (t1701/t1483); +float t1703 = fract(t1702); +float t1704 = (t1703*t1610); +float t1705 = fract(t1704); +float t1706 = (t1705*2); +float t1707 = (t1706-1); +float t1708 = abs(t1707); +float t1709 = (t1708*t1708); +float t1710 = (t1613*t1709); +float t1711 = (t1612+t1710); +float t1712 = (t1593*float(8.0e-3)); +float t1713 = (float(1.0e-3)+t1712); +float t1714 = step(float(0.66),t1607); +float t1715 = (t1714*float(3.0e-3)); +float t1716 = (t1713-t1715); +float t1717 = (t1716*float(0.8)); +float t1718 = (t1711*t1717); +float t1719 = (3.1415927/2); +float t1720 = (t1637-t1719); +float t1721 = (3.1415927/2); +float t1722 = (t8-t1721); +float t1723 = (t1720-t1722); +float t1724 = abs(t1723); +float t1725 = (t1724/2); +float t1726 = sin(t1725); +float t1727 = (t1726*t1726); +float t1728 = cos(t1722); +float t1729 = cos(t1720); +float t1730 = (t1728*t1729); +float t1731 = (t1654+3.1415927); +float t1732 = (3.1415927*2); +float t1733 = mod(t1731,t1732); +float t1734 = (t1733-3.1415927); +float t1735 = (t118+3.1415927); +float t1736 = (3.1415927*2); +float t1737 = mod(t1735,t1736); +float t1738 = (t1737-3.1415927); +float t1739 = (t1734-t1738); +float t1740 = abs(t1739); +float t1741 = (t1740/2); +float t1742 = sin(t1741); +float t1743 = (t1742*t1742); +float t1744 = (t1730*t1743); +float t1745 = (t1727+t1744); +float t1746 = sqrt(t1745); +float t1747 = asin(t1746); +float t1748 = (2*t1747); +float t1749 = step(t1718,t1748); +float t1750 = (1-t1749); +float t1751 = (t1605*t1750); +float t1752 = (3.1415927/2); +float t1753 = (t8-t1752); +float t1754 = (3.1415927/2); +float t1755 = (t1637-t1754); +float t1756 = (t1753-t1755); +float t1757 = abs(t1756); +float t1758 = (t1757/2); +float t1759 = sin(t1758); +float t1760 = (t1759*t1759); +float t1761 = cos(t1755); +float t1762 = cos(t1753); +float t1763 = (t1761*t1762); +float t1764 = (t118+3.1415927); +float t1765 = (3.1415927*2); +float t1766 = mod(t1764,t1765); +float t1767 = (t1766-3.1415927); +float t1768 = (t1654+3.1415927); +float t1769 = (3.1415927*2); +float t1770 = mod(t1768,t1769); +float t1771 = (t1770-3.1415927); +float t1772 = (t1767-t1771); +float t1773 = abs(t1772); +float t1774 = (t1773/2); +float t1775 = sin(t1774); +float t1776 = (t1775*t1775); +float t1777 = (t1763*t1776); +float t1778 = (t1760+t1777); +float t1779 = sqrt(t1778); +float t1780 = asin(t1779); +float t1781 = (2*t1780); +float t1782 = (1/t1781); +float t1783 = (t1782*t1717); +float t1784 = (t1783*float(1.25e-2)); +float t1785 = (u4.u0*t1593); +float t1786 = cos(t1785); +float t1787 = (t1786+1); +float t1788 = (t1787/2); +float t1789 = (t1784*t1788); +float t1790 = (t1789*t1605); +float t1791 = (t1751+t1790); +float t1792 = (t1574+t1791); +float t1793 = (t1346/36); +float t1794 = (t1346/36); +float t1795 = (t1794*float(842.378)); +float t1796 = fract(t1795); +float t1797 = (t1796+float(45.32)); +float t1798 = (t1797+u6.u0); +float t1799 = (t1796*t1798); +float t1800 = (t1362+2); +float t1801 = (t1800/t1359); +float t1802 = (t1801*float(1734.048)); +float t1803 = fract(t1802); +float t1804 = (t1803+float(45.32)); +float t1805 = (t1804+u6.u0); +float t1806 = (t1803*t1805); +float t1807 = (t1799+t1806); +float t1808 = (t1796+t1807); +float t1809 = (t1803+t1807); +float t1810 = (t1808*t1809); +float t1811 = fract(t1810); +float t1812 = (t1811*5); +float t1813 = (t1793+t1812); +float t1814 = fract(t1813); +float t1815 = (t1814*12000); +float t1816 = (t1815/1000); +bool t1817 = (1<=t1816); +float t1818; +if(t1817){ +t1818 = 1; +} else { +t1818 = t1816; +} +float t1819 = (t1815-6000); +float t1820 = (t1819/8000); +bool t1821 = (0>=t1820); +float t1822; +if(t1821){ +t1822 = 0; +} else { +t1822 = t1820; +} +float t1823 = (t1818-t1822); +float t1824 = (t1811*173); +float t1825 = fract(t1824); +float t1826 = step(float(0.66),t1825); +float t1827 = (t1826*3); +float t1828 = (3+t1827); +float t1829 = (3.1415927/t1828); +float t1830 = cos(t1829); +float t1831 = (1-t1830); +float t1832 = (t1346*t1344); +float t1833 = (t1346/36); +float t1834 = (t1833*float(842.378)); +float t1835 = fract(t1834); +float t1836 = (t1835+float(45.32)); +float t1837 = (t1836+u6.u0); +float t1838 = (t1835*t1837); +float t1839 = (t1800/t1359); +float t1840 = (t1839*float(1734.048)); +float t1841 = fract(t1840); +float t1842 = (t1841+float(45.32)); +float t1843 = (t1842+u6.u0); +float t1844 = (t1841*t1843); +float t1845 = (t1838+t1844); +float t1846 = (t1835+t1845); +float t1847 = (t1841+t1845); +float t1848 = (t1846*t1847); +float t1849 = fract(t1848); +float t1850 = (t1849*float(2852.02)); +float t1851 = fract(t1850); +float t1852 = (t1851-float(0.5)); +float t1853 = (t1852*t1344); +float t1854 = (t1853*float(0.75)); +float t1855 = (t1832+t1854); +float t1856 = cos(t1855); +float t1857 = (1*t1856); +float t1858 = (t1857*0); +float t1859 = sin(t1855); +float t1860 = (1*t1859); +float t1861 = (3.1415927/t1359); +float t1862 = (t1800*t1861); +float t1863 = (t1849*float(97372.83)); +float t1864 = fract(t1863); +float t1865 = (t1864-float(0.5)); +float t1866 = (3.1415927/t1359); +float t1867 = (t1865*t1866); +float t1868 = (t1867*float(0.75)); +float t1869 = (t1862+t1868); +float t1870 = (t1869+3.1415927); +float t1871 = mod(t1870,t1433); +float t1872 = (t1871-3.1415927); +float t1873 = cos(t1872); +float t1874 = (t1860*t1873); +float t1875 = (t1874*1); +float t1876 = (t1858-t1875); +float t1877 = sin(t8); +float t1878 = (1*t1877); +float t1879 = sin(t118); +float t1880 = (t1878*t1879); +float t1881 = (t1876*t1880); +float t1882 = (t1874*0); +float t1883 = sin(t1855); +float t1884 = (1*t1883); +float t1885 = sin(t1872); +float t1886 = (t1884*t1885); +float t1887 = (t1886*0); +float t1888 = (t1882-t1887); +float t1889 = cos(t8); +float t1890 = (1*t1889); +float t1891 = (t1888*t1890); +float t1892 = (t1881+t1891); +float t1893 = (t1886*1); +float t1894 = (t1857*0); +float t1895 = (t1893-t1894); +float t1896 = sin(t8); +float t1897 = (1*t1896); +float t1898 = cos(t118); +float t1899 = (t1897*t1898); +float t1900 = (t1895*t1899); +float t1901 = (t1892+t1900); +float t1902 = (t1888*t1874); +float t1903 = (t1895*t1857); +float t1904 = (t1902-t1903); +float t1905 = (t1904*t1880); +float t1906 = (t1895*t1886); +float t1907 = (t1876*t1874); +float t1908 = (t1906-t1907); +float t1909 = (t1908*t1890); +float t1910 = (t1905+t1909); +float t1911 = (t1876*t1857); +float t1912 = (t1888*t1886); +float t1913 = (t1911-t1912); +float t1914 = (t1913*t1899); +float t1915 = (t1910+t1914); +float t1916 = atan(t1901,t1915); +float t1917 = (t1916+3.1415927); +float t1918 = (t1825*3.1415927); +float t1919 = (t1917+t1918); +float t1920 = (t1919/t1483); +float t1921 = fract(t1920); +float t1922 = (t1921*t1828); +float t1923 = fract(t1922); +float t1924 = (t1923*2); +float t1925 = (t1924-1); +float t1926 = abs(t1925); +float t1927 = (t1926*t1926); +float t1928 = (t1831*t1927); +float t1929 = (t1830+t1928); +float t1930 = (t1811*float(8.0e-3)); +float t1931 = (float(1.0e-3)+t1930); +float t1932 = step(float(0.66),t1825); +float t1933 = (t1932*float(3.0e-3)); +float t1934 = (t1931-t1933); +float t1935 = (t1934*float(0.8)); +float t1936 = (t1929*t1935); +float t1937 = (3.1415927/2); +float t1938 = (t1855-t1937); +float t1939 = (3.1415927/2); +float t1940 = (t8-t1939); +float t1941 = (t1938-t1940); +float t1942 = abs(t1941); +float t1943 = (t1942/2); +float t1944 = sin(t1943); +float t1945 = (t1944*t1944); +float t1946 = cos(t1940); +float t1947 = cos(t1938); +float t1948 = (t1946*t1947); +float t1949 = (t1872+3.1415927); +float t1950 = (3.1415927*2); +float t1951 = mod(t1949,t1950); +float t1952 = (t1951-3.1415927); +float t1953 = (t118+3.1415927); +float t1954 = (3.1415927*2); +float t1955 = mod(t1953,t1954); +float t1956 = (t1955-3.1415927); +float t1957 = (t1952-t1956); +float t1958 = abs(t1957); +float t1959 = (t1958/2); +float t1960 = sin(t1959); +float t1961 = (t1960*t1960); +float t1962 = (t1948*t1961); +float t1963 = (t1945+t1962); +float t1964 = sqrt(t1963); +float t1965 = asin(t1964); +float t1966 = (2*t1965); +float t1967 = step(t1936,t1966); +float t1968 = (1-t1967); +float t1969 = (t1823*t1968); +float t1970 = (3.1415927/2); +float t1971 = (t8-t1970); +float t1972 = (3.1415927/2); +float t1973 = (t1855-t1972); +float t1974 = (t1971-t1973); +float t1975 = abs(t1974); +float t1976 = (t1975/2); +float t1977 = sin(t1976); +float t1978 = (t1977*t1977); +float t1979 = cos(t1973); +float t1980 = cos(t1971); +float t1981 = (t1979*t1980); +float t1982 = (t118+3.1415927); +float t1983 = (3.1415927*2); +float t1984 = mod(t1982,t1983); +float t1985 = (t1984-3.1415927); +float t1986 = (t1872+3.1415927); +float t1987 = (3.1415927*2); +float t1988 = mod(t1986,t1987); +float t1989 = (t1988-3.1415927); +float t1990 = (t1985-t1989); +float t1991 = abs(t1990); +float t1992 = (t1991/2); +float t1993 = sin(t1992); +float t1994 = (t1993*t1993); +float t1995 = (t1981*t1994); +float t1996 = (t1978+t1995); +float t1997 = sqrt(t1996); +float t1998 = asin(t1997); +float t1999 = (2*t1998); +float t2000 = (1/t1999); +float t2001 = (t2000*t1935); +float t2002 = (t2001*float(1.25e-2)); +float t2003 = (u4.u0*t1811); +float t2004 = cos(t2003); +float t2005 = (t2004+1); +float t2006 = (t2005/2); +float t2007 = (t2002*t2006); +float t2008 = (t2007*t1823); +float t2009 = (t1969+t2008); +float t2010 = (t1792+t2009); +float t2011 = (t1346+1); +float t2012 = (t2011/36); +float t2013 = (t2011/36); +float t2014 = (t2013*float(842.378)); +float t2015 = fract(t2014); +float t2016 = (t2015+float(45.32)); +float t2017 = (t2016+u6.u0); +float t2018 = (t2015*t2017); +float t2019 = (t2011/36); +float t2020 = (t2019*3.1415927); +float t2021 = sin(t2020); +float t2022 = (36*t2021); +float t2023 = floor(t2022); +float t2024 = (t2023+1); +float t2025 = (3.1415927/t2024); +float t2026 = (t118/t2025); +float t2027 = floor(t2026); +float t2028 = (t2027/t2024); +float t2029 = (t2028*float(1734.048)); +float t2030 = fract(t2029); +float t2031 = (t2030+float(45.32)); +float t2032 = (t2031+u6.u0); +float t2033 = (t2030*t2032); +float t2034 = (t2018+t2033); +float t2035 = (t2015+t2034); +float t2036 = (t2030+t2034); +float t2037 = (t2035*t2036); +float t2038 = fract(t2037); +float t2039 = (t2038*5); +float t2040 = (t2012+t2039); +float t2041 = fract(t2040); +float t2042 = (t2041*12000); +float t2043 = (t2042/1000); +bool t2044 = (1<=t2043); +float t2045; +if(t2044){ +t2045 = 1; +} else { +t2045 = t2043; +} +float t2046 = (t2042-6000); +float t2047 = (t2046/8000); +bool t2048 = (0>=t2047); +float t2049; +if(t2048){ +t2049 = 0; +} else { +t2049 = t2047; +} +float t2050 = (t2045-t2049); +float t2051 = (t2038*173); +float t2052 = fract(t2051); +float t2053 = step(float(0.66),t2052); +float t2054 = (t2053*3); +float t2055 = (3+t2054); +float t2056 = (3.1415927/t2055); +float t2057 = cos(t2056); +float t2058 = (1-t2057); +float t2059 = (t2011*t1344); +float t2060 = (t2011/36); +float t2061 = (t2060*float(842.378)); +float t2062 = fract(t2061); +float t2063 = (t2062+float(45.32)); +float t2064 = (t2063+u6.u0); +float t2065 = (t2062*t2064); +float t2066 = (t2027/t2024); +float t2067 = (t2066*float(1734.048)); +float t2068 = fract(t2067); +float t2069 = (t2068+float(45.32)); +float t2070 = (t2069+u6.u0); +float t2071 = (t2068*t2070); +float t2072 = (t2065+t2071); +float t2073 = (t2062+t2072); +float t2074 = (t2068+t2072); +float t2075 = (t2073*t2074); +float t2076 = fract(t2075); +float t2077 = (t2076*float(2852.02)); +float t2078 = fract(t2077); +float t2079 = (t2078-float(0.5)); +float t2080 = (t2079*t1344); +float t2081 = (t2080*float(0.75)); +float t2082 = (t2059+t2081); +float t2083 = cos(t2082); +float t2084 = (1*t2083); +float t2085 = (t2084*0); +float t2086 = sin(t2082); +float t2087 = (1*t2086); +float t2088 = (3.1415927/t2024); +float t2089 = (t2027*t2088); +float t2090 = (t2076*float(97372.83)); +float t2091 = fract(t2090); +float t2092 = (t2091-float(0.5)); +float t2093 = (3.1415927/t2024); +float t2094 = (t2092*t2093); +float t2095 = (t2094*float(0.75)); +float t2096 = (t2089+t2095); +float t2097 = (t2096+3.1415927); +float t2098 = mod(t2097,t1433); +float t2099 = (t2098-3.1415927); +float t2100 = cos(t2099); +float t2101 = (t2087*t2100); +float t2102 = (t2101*1); +float t2103 = (t2085-t2102); +float t2104 = sin(t8); +float t2105 = (1*t2104); +float t2106 = sin(t118); +float t2107 = (t2105*t2106); +float t2108 = (t2103*t2107); +float t2109 = (t2101*0); +float t2110 = sin(t2082); +float t2111 = (1*t2110); +float t2112 = sin(t2099); +float t2113 = (t2111*t2112); +float t2114 = (t2113*0); +float t2115 = (t2109-t2114); +float t2116 = cos(t8); +float t2117 = (1*t2116); +float t2118 = (t2115*t2117); +float t2119 = (t2108+t2118); +float t2120 = (t2113*1); +float t2121 = (t2084*0); +float t2122 = (t2120-t2121); +float t2123 = sin(t8); +float t2124 = (1*t2123); +float t2125 = cos(t118); +float t2126 = (t2124*t2125); +float t2127 = (t2122*t2126); +float t2128 = (t2119+t2127); +float t2129 = (t2115*t2101); +float t2130 = (t2122*t2084); +float t2131 = (t2129-t2130); +float t2132 = (t2131*t2107); +float t2133 = (t2122*t2113); +float t2134 = (t2103*t2101); +float t2135 = (t2133-t2134); +float t2136 = (t2135*t2117); +float t2137 = (t2132+t2136); +float t2138 = (t2103*t2084); +float t2139 = (t2115*t2113); +float t2140 = (t2138-t2139); +float t2141 = (t2140*t2126); +float t2142 = (t2137+t2141); +float t2143 = atan(t2128,t2142); +float t2144 = (t2143+3.1415927); +float t2145 = (t2052*3.1415927); +float t2146 = (t2144+t2145); +float t2147 = (t2146/t1483); +float t2148 = fract(t2147); +float t2149 = (t2148*t2055); +float t2150 = fract(t2149); +float t2151 = (t2150*2); +float t2152 = (t2151-1); +float t2153 = abs(t2152); +float t2154 = (t2153*t2153); +float t2155 = (t2058*t2154); +float t2156 = (t2057+t2155); +float t2157 = (t2038*float(8.0e-3)); +float t2158 = (float(1.0e-3)+t2157); +float t2159 = step(float(0.66),t2052); +float t2160 = (t2159*float(3.0e-3)); +float t2161 = (t2158-t2160); +float t2162 = (t2161*float(0.8)); +float t2163 = (t2156*t2162); +float t2164 = (3.1415927/2); +float t2165 = (t2082-t2164); +float t2166 = (3.1415927/2); +float t2167 = (t8-t2166); +float t2168 = (t2165-t2167); +float t2169 = abs(t2168); +float t2170 = (t2169/2); +float t2171 = sin(t2170); +float t2172 = (t2171*t2171); +float t2173 = cos(t2167); +float t2174 = cos(t2165); +float t2175 = (t2173*t2174); +float t2176 = (t2099+3.1415927); +float t2177 = (3.1415927*2); +float t2178 = mod(t2176,t2177); +float t2179 = (t2178-3.1415927); +float t2180 = (t118+3.1415927); +float t2181 = (3.1415927*2); +float t2182 = mod(t2180,t2181); +float t2183 = (t2182-3.1415927); +float t2184 = (t2179-t2183); +float t2185 = abs(t2184); +float t2186 = (t2185/2); +float t2187 = sin(t2186); +float t2188 = (t2187*t2187); +float t2189 = (t2175*t2188); +float t2190 = (t2172+t2189); +float t2191 = sqrt(t2190); +float t2192 = asin(t2191); +float t2193 = (2*t2192); +float t2194 = step(t2163,t2193); +float t2195 = (1-t2194); +float t2196 = (t2050*t2195); +float t2197 = (3.1415927/2); +float t2198 = (t8-t2197); +float t2199 = (3.1415927/2); +float t2200 = (t2082-t2199); +float t2201 = (t2198-t2200); +float t2202 = abs(t2201); +float t2203 = (t2202/2); +float t2204 = sin(t2203); +float t2205 = (t2204*t2204); +float t2206 = cos(t2200); +float t2207 = cos(t2198); +float t2208 = (t2206*t2207); +float t2209 = (t118+3.1415927); +float t2210 = (3.1415927*2); +float t2211 = mod(t2209,t2210); +float t2212 = (t2211-3.1415927); +float t2213 = (t2099+3.1415927); +float t2214 = (3.1415927*2); +float t2215 = mod(t2213,t2214); +float t2216 = (t2215-3.1415927); +float t2217 = (t2212-t2216); +float t2218 = abs(t2217); +float t2219 = (t2218/2); +float t2220 = sin(t2219); +float t2221 = (t2220*t2220); +float t2222 = (t2208*t2221); +float t2223 = (t2205+t2222); +float t2224 = sqrt(t2223); +float t2225 = asin(t2224); +float t2226 = (2*t2225); +float t2227 = (1/t2226); +float t2228 = (t2227*t2162); +float t2229 = (t2228*float(1.25e-2)); +float t2230 = (u4.u0*t2038); +float t2231 = cos(t2230); +float t2232 = (t2231+1); +float t2233 = (t2232/2); +float t2234 = (t2229*t2233); +float t2235 = (t2234*t2050); +float t2236 = (t2196+t2235); +float t2237 = (t2010+t2236); +float t2238 = (t1346*t1344); +float t2239 = (t1346/36); +float t2240 = (t2239*float(842.378)); +float t2241 = fract(t2240); +float t2242 = (t2241+float(45.32)); +float t2243 = (t2242+u6.u0); +float t2244 = (t2241*t2243); +float t2245 = (t1582/t1359); +float t2246 = (t2245*float(1734.048)); +float t2247 = fract(t2246); +float t2248 = (t2247+float(45.32)); +float t2249 = (t2248+u6.u0); +float t2250 = (t2247*t2249); +float t2251 = (t2244+t2250); +float t2252 = (t2241+t2251); +float t2253 = (t2247+t2251); +float t2254 = (t2252*t2253); +float t2255 = fract(t2254); +float t2256 = (t2255*float(2852.02)); +float t2257 = fract(t2256); +float t2258 = (t2257-float(0.5)); +float t2259 = (t2258*t1344); +float t2260 = (t2259*float(0.75)); +float t2261 = (t2238+t2260); +float t2262 = (3.1415927/2); +float t2263 = (t2261-t2262); +float t2264 = (t1346*t1344); +float t2265 = (t1346/36); +float t2266 = (t2265*float(842.378)); +float t2267 = fract(t2266); +float t2268 = (t2267+float(45.32)); +float t2269 = (t2268+u6.u0); +float t2270 = (t2267*t2269); +float t2271 = (t1362/t1359); +float t2272 = (t2271*float(1734.048)); +float t2273 = fract(t2272); +float t2274 = (t2273+float(45.32)); +float t2275 = (t2274+u6.u0); +float t2276 = (t2273*t2275); +float t2277 = (t2270+t2276); +float t2278 = (t2267+t2277); +float t2279 = (t2273+t2277); +float t2280 = (t2278*t2279); +float t2281 = fract(t2280); +float t2282 = (t2281*float(2852.02)); +float t2283 = fract(t2282); +float t2284 = (t2283-float(0.5)); +float t2285 = (t2284*t1344); +float t2286 = (t2285*float(0.75)); +float t2287 = (t2264+t2286); +float t2288 = (3.1415927/2); +float t2289 = (t2287-t2288); +float t2290 = (t2263-t2289); +float t2291 = abs(t2290); +float t2292 = (t2291/2); +float t2293 = sin(t2292); +float t2294 = (t2293*t2293); +float t2295 = cos(t2289); +float t2296 = cos(t2263); +float t2297 = (t2295*t2296); +float t2298 = (3.1415927/t1359); +float t2299 = (t1582*t2298); +float t2300 = (t2255*float(97372.83)); +float t2301 = fract(t2300); +float t2302 = (t2301-float(0.5)); +float t2303 = (3.1415927/t1359); +float t2304 = (t2302*t2303); +float t2305 = (t2304*float(0.75)); +float t2306 = (t2299+t2305); +float t2307 = (t2306+3.1415927); +float t2308 = mod(t2307,t1433); +float t2309 = (t2308-3.1415927); +float t2310 = (t2309+3.1415927); +float t2311 = (3.1415927*2); +float t2312 = mod(t2310,t2311); +float t2313 = (t2312-3.1415927); +float t2314 = (3.1415927/t1359); +float t2315 = (t1362*t2314); +float t2316 = (t2281*float(97372.83)); +float t2317 = fract(t2316); +float t2318 = (t2317-float(0.5)); +float t2319 = (3.1415927/t1359); +float t2320 = (t2318*t2319); +float t2321 = (t2320*float(0.75)); +float t2322 = (t2315+t2321); +float t2323 = (t2322+3.1415927); +float t2324 = mod(t2323,t1433); +float t2325 = (t2324-3.1415927); +float t2326 = (t2325+3.1415927); +float t2327 = (3.1415927*2); +float t2328 = mod(t2326,t2327); +float t2329 = (t2328-3.1415927); +float t2330 = (t2313-t2329); +float t2331 = abs(t2330); +float t2332 = (t2331/2); +float t2333 = sin(t2332); +float t2334 = (t2333*t2333); +float t2335 = (t2297*t2334); +float t2336 = (t2294+t2335); +float t2337 = sqrt(t2336); +float t2338 = asin(t2337); +float t2339 = (2*t2338); +float t2340 = (3.1415927/2); +float t2341 = (t8-t2340); +float t2342 = (3.1415927/2); +float t2343 = (t2287-t2342); +float t2344 = (t2341-t2343); +float t2345 = abs(t2344); +float t2346 = (t2345/2); +float t2347 = sin(t2346); +float t2348 = (t2347*t2347); +float t2349 = cos(t2343); +float t2350 = cos(t2341); +float t2351 = (t2349*t2350); +float t2352 = (t118+3.1415927); +float t2353 = (3.1415927*2); +float t2354 = mod(t2352,t2353); +float t2355 = (t2354-3.1415927); +float t2356 = (t2325+3.1415927); +float t2357 = (3.1415927*2); +float t2358 = mod(t2356,t2357); +float t2359 = (t2358-3.1415927); +float t2360 = (t2355-t2359); +float t2361 = abs(t2360); +float t2362 = (t2361/2); +float t2363 = sin(t2362); +float t2364 = (t2363*t2363); +float t2365 = (t2351*t2364); +float t2366 = (t2348+t2365); +float t2367 = sqrt(t2366); +float t2368 = asin(t2367); +float t2369 = (2*t2368); +float t2370 = (t2339-t2369); +float t2371 = (3.1415927/2); +float t2372 = (t8-t2371); +float t2373 = (3.1415927/2); +float t2374 = (t2261-t2373); +float t2375 = (t2372-t2374); +float t2376 = abs(t2375); +float t2377 = (t2376/2); +float t2378 = sin(t2377); +float t2379 = (t2378*t2378); +float t2380 = cos(t2374); +float t2381 = cos(t2372); +float t2382 = (t2380*t2381); +float t2383 = (t118+3.1415927); +float t2384 = (3.1415927*2); +float t2385 = mod(t2383,t2384); +float t2386 = (t2385-3.1415927); +float t2387 = (t2309+3.1415927); +float t2388 = (3.1415927*2); +float t2389 = mod(t2387,t2388); +float t2390 = (t2389-3.1415927); +float t2391 = (t2386-t2390); +float t2392 = abs(t2391); +float t2393 = (t2392/2); +float t2394 = sin(t2393); +float t2395 = (t2394*t2394); +float t2396 = (t2382*t2395); +float t2397 = (t2379+t2396); +float t2398 = sqrt(t2397); +float t2399 = asin(t2398); +float t2400 = (2*t2399); +float t2401 = (t2370-t2400); +float t2402 = abs(t2401); +bool t2403 = (float(1.0e-4)>t2402); +float t2404; +if(t2403){ +float t2405 = cos(t2287); +float t2406 = (1*t2405); +float t2407 = sin(t2261); +float t2408 = (1*t2407); +float t2409 = cos(t2309); +float t2410 = (t2408*t2409); +float t2411 = (t2406*t2410); +float t2412 = sin(t2287); +float t2413 = (1*t2412); +float t2414 = cos(t2325); +float t2415 = (t2413*t2414); +float t2416 = cos(t2261); +float t2417 = (1*t2416); +float t2418 = (t2415*t2417); +float t2419 = (t2411-t2418); +float t2420 = sin(t8); +float t2421 = (1*t2420); +float t2422 = sin(t118); +float t2423 = (t2421*t2422); +float t2424 = (t2419*t2423); +float t2425 = sin(t2261); +float t2426 = (1*t2425); +float t2427 = sin(t2309); +float t2428 = (t2426*t2427); +float t2429 = (t2415*t2428); +float t2430 = sin(t2287); +float t2431 = (1*t2430); +float t2432 = sin(t2325); +float t2433 = (t2431*t2432); +float t2434 = (t2433*t2410); +float t2435 = (t2429-t2434); +float t2436 = cos(t8); +float t2437 = (1*t2436); +float t2438 = (t2435*t2437); +float t2439 = (t2424+t2438); +float t2440 = (t2433*t2417); +float t2441 = (t2406*t2428); +float t2442 = (t2440-t2441); +float t2443 = sin(t8); +float t2444 = (1*t2443); +float t2445 = cos(t118); +float t2446 = (t2444*t2445); +float t2447 = (t2442*t2446); +float t2448 = (t2439+t2447); +float t2449 = abs(t2448); +t2404 = t2449; +} else { +float t2450 = (3.1415927/2); +float t2451 = (t8-t2450); +float t2452 = (3.1415927/2); +float t2453 = (t2261-t2452); +float t2454 = (t2451-t2453); +float t2455 = abs(t2454); +float t2456 = (t2455/2); +float t2457 = sin(t2456); +float t2458 = (t2457*t2457); +float t2459 = cos(t2453); +float t2460 = cos(t2451); +float t2461 = (t2459*t2460); +float t2462 = (t118+3.1415927); +float t2463 = (3.1415927*2); +float t2464 = mod(t2462,t2463); +float t2465 = (t2464-3.1415927); +float t2466 = (t2309+3.1415927); +float t2467 = (3.1415927*2); +float t2468 = mod(t2466,t2467); +float t2469 = (t2468-3.1415927); +float t2470 = (t2465-t2469); +float t2471 = abs(t2470); +float t2472 = (t2471/2); +float t2473 = sin(t2472); +float t2474 = (t2473*t2473); +float t2475 = (t2461*t2474); +float t2476 = (t2458+t2475); +float t2477 = sqrt(t2476); +float t2478 = asin(t2477); +float t2479 = (2*t2478); +float t2480 = abs(t2479); +float t2481 = (3.1415927/2); +float t2482 = (t8-t2481); +float t2483 = (3.1415927/2); +float t2484 = (t2287-t2483); +float t2485 = (t2482-t2484); +float t2486 = abs(t2485); +float t2487 = (t2486/2); +float t2488 = sin(t2487); +float t2489 = (t2488*t2488); +float t2490 = cos(t2484); +float t2491 = cos(t2482); +float t2492 = (t2490*t2491); +float t2493 = (t118+3.1415927); +float t2494 = (3.1415927*2); +float t2495 = mod(t2493,t2494); +float t2496 = (t2495-3.1415927); +float t2497 = (t2325+3.1415927); +float t2498 = (3.1415927*2); +float t2499 = mod(t2497,t2498); +float t2500 = (t2499-3.1415927); +float t2501 = (t2496-t2500); +float t2502 = abs(t2501); +float t2503 = (t2502/2); +float t2504 = sin(t2503); +float t2505 = (t2504*t2504); +float t2506 = (t2492*t2505); +float t2507 = (t2489+t2506); +float t2508 = sqrt(t2507); +float t2509 = asin(t2508); +float t2510 = (2*t2509); +float t2511 = abs(t2510); +bool t2512 = (t2480>=t2511); +float t2513; +if(t2512){ +t2513 = t2480; +} else { +t2513 = t2511; +} +t2404 = t2513; +} +float t2514 = abs(t2404); +float t2515 = step(float(2.0e-4),t2514); +float t2516 = (1-t2515); +float t2517 = (t1346*t1582); +float t2518 = (t2517*float(842.378)); +float t2519 = fract(t2518); +float t2520 = (t2519+float(45.32)); +float t2521 = (t2520+u6.u0); +float t2522 = (t2519*t2521); +float t2523 = (t1362*t1346); +float t2524 = (t2523*float(1734.048)); +float t2525 = fract(t2524); +float t2526 = (t2525+float(45.32)); +float t2527 = (t2526+u6.u0); +float t2528 = (t2525*t2527); +float t2529 = (t2522+t2528); +float t2530 = (t2519+t2529); +float t2531 = (t2525+t2529); +float t2532 = (t2530*t2531); +float t2533 = fract(t2532); +float t2534 = step(float(0.2),t2533); +float t2535 = (t2516*t2534); +float t2536 = (3.1415927/2); +float t2537 = (t2261-t2536); +float t2538 = (3.1415927/2); +float t2539 = (t2287-t2538); +float t2540 = (t2537-t2539); +float t2541 = abs(t2540); +float t2542 = (t2541/2); +float t2543 = sin(t2542); +float t2544 = (t2543*t2543); +float t2545 = cos(t2539); +float t2546 = cos(t2537); +float t2547 = (t2545*t2546); +float t2548 = (t2309+3.1415927); +float t2549 = (3.1415927*2); +float t2550 = mod(t2548,t2549); +float t2551 = (t2550-3.1415927); +float t2552 = (t2325+3.1415927); +float t2553 = (3.1415927*2); +float t2554 = mod(t2552,t2553); +float t2555 = (t2554-3.1415927); +float t2556 = (t2551-t2555); +float t2557 = abs(t2556); +float t2558 = (t2557/2); +float t2559 = sin(t2558); +float t2560 = (t2559*t2559); +float t2561 = (t2547*t2560); +float t2562 = (t2544+t2561); +float t2563 = sqrt(t2562); +float t2564 = asin(t2563); +float t2565 = (2*t2564); +float t2566 = (t2565/t1344); +float t2567 = (1-t2566); +float t2568 = (t1346/36); +float t2569 = (t2568*float(842.378)); +float t2570 = fract(t2569); +float t2571 = (t2570+float(45.32)); +float t2572 = (t2571+u6.u0); +float t2573 = (t2570*t2572); +float t2574 = (t1362/t1359); +float t2575 = (t2574*float(1734.048)); +float t2576 = fract(t2575); +float t2577 = (t2576+float(45.32)); +float t2578 = (t2577+u6.u0); +float t2579 = (t2576*t2578); +float t2580 = (t2573+t2579); +float t2581 = (t2570+t2580); +float t2582 = (t2576+t2580); +float t2583 = (t2581*t2582); +float t2584 = fract(t2583); +float t2585 = (t2584*float(8.0e-3)); +float t2586 = (float(1.0e-3)+t2585); +float t2587 = (t2584*173); +float t2588 = fract(t2587); +float t2589 = step(float(0.66),t2588); +float t2590 = (t2589*float(3.0e-3)); +float t2591 = (t2586-t2590); +float t2592 = (t2591*float(0.8)); +float t2593 = (t1346/36); +float t2594 = (t2593*float(842.378)); +float t2595 = fract(t2594); +float t2596 = (t2595+float(45.32)); +float t2597 = (t2596+u6.u0); +float t2598 = (t2595*t2597); +float t2599 = (t1582/t1359); +float t2600 = (t2599*float(1734.048)); +float t2601 = fract(t2600); +float t2602 = (t2601+float(45.32)); +float t2603 = (t2602+u6.u0); +float t2604 = (t2601*t2603); +float t2605 = (t2598+t2604); +float t2606 = (t2595+t2605); +float t2607 = (t2601+t2605); +float t2608 = (t2606*t2607); +float t2609 = fract(t2608); +float t2610 = (t2609*float(8.0e-3)); +float t2611 = (float(1.0e-3)+t2610); +float t2612 = (t2609*173); +float t2613 = fract(t2612); +float t2614 = step(float(0.66),t2613); +float t2615 = (t2614*float(3.0e-3)); +float t2616 = (t2611-t2615); +float t2617 = (t2616*float(0.8)); +float t2618 = (t2592-t2617); +float t2619 = abs(t2618); +float t2620 = (t2619-float(1.0e-3)); +float t2621 = (t2620/float(8.0e-3)); +float t2622 = (1-t2621); +float t2623 = (t2622*t2622); +float t2624 = (t2567*t2623); +float t2625 = (t2535*t2624); +float t2626 = (u4.u0*t2533); +float t2627 = (t2626*3); +float t2628 = sin(t2627); +float t2629 = (t2628+1); +float t2630 = (t2629/2); +float t2631 = (t2630*float(0.66)); +float t2632 = (t2631+float(0.33)); +float t2633 = (t2625*t2632); +float t2634 = (float(0.2)*t2633); +bool t2635 = (0>=t2634); +float t2636; +if(t2635){ +t2636 = 0; +} else { +t2636 = t2634; +} +float t2637 = (t2636*1); +float t2638 = (t2237+t2637); +float t2639 = (t2011*t1344); +float t2640 = (t2011/36); +float t2641 = (t2640*float(842.378)); +float t2642 = fract(t2641); +float t2643 = (t2642+float(45.32)); +float t2644 = (t2643+u6.u0); +float t2645 = (t2642*t2644); +float t2646 = (t2027/t2024); +float t2647 = (t2646*float(1734.048)); +float t2648 = fract(t2647); +float t2649 = (t2648+float(45.32)); +float t2650 = (t2649+u6.u0); +float t2651 = (t2648*t2650); +float t2652 = (t2645+t2651); +float t2653 = (t2642+t2652); +float t2654 = (t2648+t2652); +float t2655 = (t2653*t2654); +float t2656 = fract(t2655); +float t2657 = (t2656*float(2852.02)); +float t2658 = fract(t2657); +float t2659 = (t2658-float(0.5)); +float t2660 = (t2659*t1344); +float t2661 = (t2660*float(0.75)); +float t2662 = (t2639+t2661); +float t2663 = (3.1415927/2); +float t2664 = (t2662-t2663); +float t2665 = (t1346*t1344); +float t2666 = (t1346/36); +float t2667 = (t2666*float(842.378)); +float t2668 = fract(t2667); +float t2669 = (t2668+float(45.32)); +float t2670 = (t2669+u6.u0); +float t2671 = (t2668*t2670); +float t2672 = (t1362/t1359); +float t2673 = (t2672*float(1734.048)); +float t2674 = fract(t2673); +float t2675 = (t2674+float(45.32)); +float t2676 = (t2675+u6.u0); +float t2677 = (t2674*t2676); +float t2678 = (t2671+t2677); +float t2679 = (t2668+t2678); +float t2680 = (t2674+t2678); +float t2681 = (t2679*t2680); +float t2682 = fract(t2681); +float t2683 = (t2682*float(2852.02)); +float t2684 = fract(t2683); +float t2685 = (t2684-float(0.5)); +float t2686 = (t2685*t1344); +float t2687 = (t2686*float(0.75)); +float t2688 = (t2665+t2687); +float t2689 = (3.1415927/2); +float t2690 = (t2688-t2689); +float t2691 = (t2664-t2690); +float t2692 = abs(t2691); +float t2693 = (t2692/2); +float t2694 = sin(t2693); +float t2695 = (t2694*t2694); +float t2696 = cos(t2690); +float t2697 = cos(t2664); +float t2698 = (t2696*t2697); +float t2699 = (3.1415927/t2024); +float t2700 = (t2027*t2699); +float t2701 = (t2656*float(97372.83)); +float t2702 = fract(t2701); +float t2703 = (t2702-float(0.5)); +float t2704 = (3.1415927/t2024); +float t2705 = (t2703*t2704); +float t2706 = (t2705*float(0.75)); +float t2707 = (t2700+t2706); +float t2708 = (t2707+3.1415927); +float t2709 = mod(t2708,t1433); +float t2710 = (t2709-3.1415927); +float t2711 = (t2710+3.1415927); +float t2712 = (3.1415927*2); +float t2713 = mod(t2711,t2712); +float t2714 = (t2713-3.1415927); +float t2715 = (3.1415927/t1359); +float t2716 = (t1362*t2715); +float t2717 = (t2682*float(97372.83)); +float t2718 = fract(t2717); +float t2719 = (t2718-float(0.5)); +float t2720 = (3.1415927/t1359); +float t2721 = (t2719*t2720); +float t2722 = (t2721*float(0.75)); +float t2723 = (t2716+t2722); +float t2724 = (t2723+3.1415927); +float t2725 = mod(t2724,t1433); +float t2726 = (t2725-3.1415927); +float t2727 = (t2726+3.1415927); +float t2728 = (3.1415927*2); +float t2729 = mod(t2727,t2728); +float t2730 = (t2729-3.1415927); +float t2731 = (t2714-t2730); +float t2732 = abs(t2731); +float t2733 = (t2732/2); +float t2734 = sin(t2733); +float t2735 = (t2734*t2734); +float t2736 = (t2698*t2735); +float t2737 = (t2695+t2736); +float t2738 = sqrt(t2737); +float t2739 = asin(t2738); +float t2740 = (2*t2739); +float t2741 = (3.1415927/2); +float t2742 = (t8-t2741); +float t2743 = (3.1415927/2); +float t2744 = (t2688-t2743); +float t2745 = (t2742-t2744); +float t2746 = abs(t2745); +float t2747 = (t2746/2); +float t2748 = sin(t2747); +float t2749 = (t2748*t2748); +float t2750 = cos(t2744); +float t2751 = cos(t2742); +float t2752 = (t2750*t2751); +float t2753 = (t118+3.1415927); +float t2754 = (3.1415927*2); +float t2755 = mod(t2753,t2754); +float t2756 = (t2755-3.1415927); +float t2757 = (t2726+3.1415927); +float t2758 = (3.1415927*2); +float t2759 = mod(t2757,t2758); +float t2760 = (t2759-3.1415927); +float t2761 = (t2756-t2760); +float t2762 = abs(t2761); +float t2763 = (t2762/2); +float t2764 = sin(t2763); +float t2765 = (t2764*t2764); +float t2766 = (t2752*t2765); +float t2767 = (t2749+t2766); +float t2768 = sqrt(t2767); +float t2769 = asin(t2768); +float t2770 = (2*t2769); +float t2771 = (t2740-t2770); +float t2772 = (3.1415927/2); +float t2773 = (t8-t2772); +float t2774 = (3.1415927/2); +float t2775 = (t2662-t2774); +float t2776 = (t2773-t2775); +float t2777 = abs(t2776); +float t2778 = (t2777/2); +float t2779 = sin(t2778); +float t2780 = (t2779*t2779); +float t2781 = cos(t2775); +float t2782 = cos(t2773); +float t2783 = (t2781*t2782); +float t2784 = (t118+3.1415927); +float t2785 = (3.1415927*2); +float t2786 = mod(t2784,t2785); +float t2787 = (t2786-3.1415927); +float t2788 = (t2710+3.1415927); +float t2789 = (3.1415927*2); +float t2790 = mod(t2788,t2789); +float t2791 = (t2790-3.1415927); +float t2792 = (t2787-t2791); +float t2793 = abs(t2792); +float t2794 = (t2793/2); +float t2795 = sin(t2794); +float t2796 = (t2795*t2795); +float t2797 = (t2783*t2796); +float t2798 = (t2780+t2797); +float t2799 = sqrt(t2798); +float t2800 = asin(t2799); +float t2801 = (2*t2800); +float t2802 = (t2771-t2801); +float t2803 = abs(t2802); +bool t2804 = (float(1.0e-4)>t2803); +float t2805; +if(t2804){ +float t2806 = cos(t2688); +float t2807 = (1*t2806); +float t2808 = sin(t2662); +float t2809 = (1*t2808); +float t2810 = cos(t2710); +float t2811 = (t2809*t2810); +float t2812 = (t2807*t2811); +float t2813 = sin(t2688); +float t2814 = (1*t2813); +float t2815 = cos(t2726); +float t2816 = (t2814*t2815); +float t2817 = cos(t2662); +float t2818 = (1*t2817); +float t2819 = (t2816*t2818); +float t2820 = (t2812-t2819); +float t2821 = sin(t8); +float t2822 = (1*t2821); +float t2823 = sin(t118); +float t2824 = (t2822*t2823); +float t2825 = (t2820*t2824); +float t2826 = sin(t2662); +float t2827 = (1*t2826); +float t2828 = sin(t2710); +float t2829 = (t2827*t2828); +float t2830 = (t2816*t2829); +float t2831 = sin(t2688); +float t2832 = (1*t2831); +float t2833 = sin(t2726); +float t2834 = (t2832*t2833); +float t2835 = (t2834*t2811); +float t2836 = (t2830-t2835); +float t2837 = cos(t8); +float t2838 = (1*t2837); +float t2839 = (t2836*t2838); +float t2840 = (t2825+t2839); +float t2841 = (t2834*t2818); +float t2842 = (t2807*t2829); +float t2843 = (t2841-t2842); +float t2844 = sin(t8); +float t2845 = (1*t2844); +float t2846 = cos(t118); +float t2847 = (t2845*t2846); +float t2848 = (t2843*t2847); +float t2849 = (t2840+t2848); +float t2850 = abs(t2849); +t2805 = t2850; +} else { +float t2851 = (3.1415927/2); +float t2852 = (t8-t2851); +float t2853 = (3.1415927/2); +float t2854 = (t2662-t2853); +float t2855 = (t2852-t2854); +float t2856 = abs(t2855); +float t2857 = (t2856/2); +float t2858 = sin(t2857); +float t2859 = (t2858*t2858); +float t2860 = cos(t2854); +float t2861 = cos(t2852); +float t2862 = (t2860*t2861); +float t2863 = (t118+3.1415927); +float t2864 = (3.1415927*2); +float t2865 = mod(t2863,t2864); +float t2866 = (t2865-3.1415927); +float t2867 = (t2710+3.1415927); +float t2868 = (3.1415927*2); +float t2869 = mod(t2867,t2868); +float t2870 = (t2869-3.1415927); +float t2871 = (t2866-t2870); +float t2872 = abs(t2871); +float t2873 = (t2872/2); +float t2874 = sin(t2873); +float t2875 = (t2874*t2874); +float t2876 = (t2862*t2875); +float t2877 = (t2859+t2876); +float t2878 = sqrt(t2877); +float t2879 = asin(t2878); +float t2880 = (2*t2879); +float t2881 = abs(t2880); +float t2882 = (3.1415927/2); +float t2883 = (t8-t2882); +float t2884 = (3.1415927/2); +float t2885 = (t2688-t2884); +float t2886 = (t2883-t2885); +float t2887 = abs(t2886); +float t2888 = (t2887/2); +float t2889 = sin(t2888); +float t2890 = (t2889*t2889); +float t2891 = cos(t2885); +float t2892 = cos(t2883); +float t2893 = (t2891*t2892); +float t2894 = (t118+3.1415927); +float t2895 = (3.1415927*2); +float t2896 = mod(t2894,t2895); +float t2897 = (t2896-3.1415927); +float t2898 = (t2726+3.1415927); +float t2899 = (3.1415927*2); +float t2900 = mod(t2898,t2899); +float t2901 = (t2900-3.1415927); +float t2902 = (t2897-t2901); +float t2903 = abs(t2902); +float t2904 = (t2903/2); +float t2905 = sin(t2904); +float t2906 = (t2905*t2905); +float t2907 = (t2893*t2906); +float t2908 = (t2890+t2907); +float t2909 = sqrt(t2908); +float t2910 = asin(t2909); +float t2911 = (2*t2910); +float t2912 = abs(t2911); +bool t2913 = (t2881>=t2912); +float t2914; +if(t2913){ +t2914 = t2881; +} else { +t2914 = t2912; +} +t2805 = t2914; +} +float t2915 = abs(t2805); +float t2916 = step(float(2.0e-4),t2915); +float t2917 = (1-t2916); +float t2918 = (t1346*t2027); +float t2919 = (t2918*float(842.378)); +float t2920 = fract(t2919); +float t2921 = (t2920+float(45.32)); +float t2922 = (t2921+u6.u0); +float t2923 = (t2920*t2922); +float t2924 = (t1362*t2011); +float t2925 = (t2924*float(1734.048)); +float t2926 = fract(t2925); +float t2927 = (t2926+float(45.32)); +float t2928 = (t2927+u6.u0); +float t2929 = (t2926*t2928); +float t2930 = (t2923+t2929); +float t2931 = (t2920+t2930); +float t2932 = (t2926+t2930); +float t2933 = (t2931*t2932); +float t2934 = fract(t2933); +float t2935 = step(float(0.2),t2934); +float t2936 = (t2917*t2935); +float t2937 = (3.1415927/2); +float t2938 = (t2662-t2937); +float t2939 = (3.1415927/2); +float t2940 = (t2688-t2939); +float t2941 = (t2938-t2940); +float t2942 = abs(t2941); +float t2943 = (t2942/2); +float t2944 = sin(t2943); +float t2945 = (t2944*t2944); +float t2946 = cos(t2940); +float t2947 = cos(t2938); +float t2948 = (t2946*t2947); +float t2949 = (t2710+3.1415927); +float t2950 = (3.1415927*2); +float t2951 = mod(t2949,t2950); +float t2952 = (t2951-3.1415927); +float t2953 = (t2726+3.1415927); +float t2954 = (3.1415927*2); +float t2955 = mod(t2953,t2954); +float t2956 = (t2955-3.1415927); +float t2957 = (t2952-t2956); +float t2958 = abs(t2957); +float t2959 = (t2958/2); +float t2960 = sin(t2959); +float t2961 = (t2960*t2960); +float t2962 = (t2948*t2961); +float t2963 = (t2945+t2962); +float t2964 = sqrt(t2963); +float t2965 = asin(t2964); +float t2966 = (2*t2965); +float t2967 = (t2966/t1344); +float t2968 = (1-t2967); +float t2969 = (t1346/36); +float t2970 = (t2969*float(842.378)); +float t2971 = fract(t2970); +float t2972 = (t2971+float(45.32)); +float t2973 = (t2972+u6.u0); +float t2974 = (t2971*t2973); +float t2975 = (t1362/t1359); +float t2976 = (t2975*float(1734.048)); +float t2977 = fract(t2976); +float t2978 = (t2977+float(45.32)); +float t2979 = (t2978+u6.u0); +float t2980 = (t2977*t2979); +float t2981 = (t2974+t2980); +float t2982 = (t2971+t2981); +float t2983 = (t2977+t2981); +float t2984 = (t2982*t2983); +float t2985 = fract(t2984); +float t2986 = (t2985*float(8.0e-3)); +float t2987 = (float(1.0e-3)+t2986); +float t2988 = (t2985*173); +float t2989 = fract(t2988); +float t2990 = step(float(0.66),t2989); +float t2991 = (t2990*float(3.0e-3)); +float t2992 = (t2987-t2991); +float t2993 = (t2992*float(0.8)); +float t2994 = (t2011/36); +float t2995 = (t2994*float(842.378)); +float t2996 = fract(t2995); +float t2997 = (t2996+float(45.32)); +float t2998 = (t2997+u6.u0); +float t2999 = (t2996*t2998); +float t3000 = (t2027/t2024); +float t3001 = (t3000*float(1734.048)); +float t3002 = fract(t3001); +float t3003 = (t3002+float(45.32)); +float t3004 = (t3003+u6.u0); +float t3005 = (t3002*t3004); +float t3006 = (t2999+t3005); +float t3007 = (t2996+t3006); +float t3008 = (t3002+t3006); +float t3009 = (t3007*t3008); +float t3010 = fract(t3009); +float t3011 = (t3010*float(8.0e-3)); +float t3012 = (float(1.0e-3)+t3011); +float t3013 = (t3010*173); +float t3014 = fract(t3013); +float t3015 = step(float(0.66),t3014); +float t3016 = (t3015*float(3.0e-3)); +float t3017 = (t3012-t3016); +float t3018 = (t3017*float(0.8)); +float t3019 = (t2993-t3018); +float t3020 = abs(t3019); +float t3021 = (t3020-float(1.0e-3)); +float t3022 = (t3021/float(8.0e-3)); +float t3023 = (1-t3022); +float t3024 = (t3023*t3023); +float t3025 = (t2968*t3024); +float t3026 = (t2936*t3025); +float t3027 = (u4.u0*t2934); +float t3028 = (t3027*3); +float t3029 = sin(t3028); +float t3030 = (t3029+1); +float t3031 = (t3030/2); +float t3032 = (t3031*float(0.66)); +float t3033 = (t3032+float(0.33)); +float t3034 = (t3026*t3033); +float t3035 = (float(0.2)*t3034); +bool t3036 = (0>=t3035); +float t3037; +if(t3036){ +t3037 = 0; +} else { +t3037 = t3035; +} +float t3038 = (t3037*1); +float t3039 = (t2638+t3038); +float t3040 = (t2011*t1344); +float t3041 = (t2011/36); +float t3042 = (t3041*float(842.378)); +float t3043 = fract(t3042); +float t3044 = (t3043+float(45.32)); +float t3045 = (t3044+u6.u0); +float t3046 = (t3043*t3045); +float t3047 = (t2027+1); +float t3048 = (t3047/t2024); +float t3049 = (t3048*float(1734.048)); +float t3050 = fract(t3049); +float t3051 = (t3050+float(45.32)); +float t3052 = (t3051+u6.u0); +float t3053 = (t3050*t3052); +float t3054 = (t3046+t3053); +float t3055 = (t3043+t3054); +float t3056 = (t3050+t3054); +float t3057 = (t3055*t3056); +float t3058 = fract(t3057); +float t3059 = (t3058*float(2852.02)); +float t3060 = fract(t3059); +float t3061 = (t3060-float(0.5)); +float t3062 = (t3061*t1344); +float t3063 = (t3062*float(0.75)); +float t3064 = (t3040+t3063); +float t3065 = (3.1415927/2); +float t3066 = (t3064-t3065); +float t3067 = (t2011*t1344); +float t3068 = (t2011/36); +float t3069 = (t3068*float(842.378)); +float t3070 = fract(t3069); +float t3071 = (t3070+float(45.32)); +float t3072 = (t3071+u6.u0); +float t3073 = (t3070*t3072); +float t3074 = (t2027/t2024); +float t3075 = (t3074*float(1734.048)); +float t3076 = fract(t3075); +float t3077 = (t3076+float(45.32)); +float t3078 = (t3077+u6.u0); +float t3079 = (t3076*t3078); +float t3080 = (t3073+t3079); +float t3081 = (t3070+t3080); +float t3082 = (t3076+t3080); +float t3083 = (t3081*t3082); +float t3084 = fract(t3083); +float t3085 = (t3084*float(2852.02)); +float t3086 = fract(t3085); +float t3087 = (t3086-float(0.5)); +float t3088 = (t3087*t1344); +float t3089 = (t3088*float(0.75)); +float t3090 = (t3067+t3089); +float t3091 = (3.1415927/2); +float t3092 = (t3090-t3091); +float t3093 = (t3066-t3092); +float t3094 = abs(t3093); +float t3095 = (t3094/2); +float t3096 = sin(t3095); +float t3097 = (t3096*t3096); +float t3098 = cos(t3092); +float t3099 = cos(t3066); +float t3100 = (t3098*t3099); +float t3101 = (3.1415927/t2024); +float t3102 = (t3047*t3101); +float t3103 = (t3058*float(97372.83)); +float t3104 = fract(t3103); +float t3105 = (t3104-float(0.5)); +float t3106 = (3.1415927/t2024); +float t3107 = (t3105*t3106); +float t3108 = (t3107*float(0.75)); +float t3109 = (t3102+t3108); +float t3110 = (t3109+3.1415927); +float t3111 = mod(t3110,t1433); +float t3112 = (t3111-3.1415927); +float t3113 = (t3112+3.1415927); +float t3114 = (3.1415927*2); +float t3115 = mod(t3113,t3114); +float t3116 = (t3115-3.1415927); +float t3117 = (3.1415927/t2024); +float t3118 = (t2027*t3117); +float t3119 = (t3084*float(97372.83)); +float t3120 = fract(t3119); +float t3121 = (t3120-float(0.5)); +float t3122 = (3.1415927/t2024); +float t3123 = (t3121*t3122); +float t3124 = (t3123*float(0.75)); +float t3125 = (t3118+t3124); +float t3126 = (t3125+3.1415927); +float t3127 = mod(t3126,t1433); +float t3128 = (t3127-3.1415927); +float t3129 = (t3128+3.1415927); +float t3130 = (3.1415927*2); +float t3131 = mod(t3129,t3130); +float t3132 = (t3131-3.1415927); +float t3133 = (t3116-t3132); +float t3134 = abs(t3133); +float t3135 = (t3134/2); +float t3136 = sin(t3135); +float t3137 = (t3136*t3136); +float t3138 = (t3100*t3137); +float t3139 = (t3097+t3138); +float t3140 = sqrt(t3139); +float t3141 = asin(t3140); +float t3142 = (2*t3141); +float t3143 = (3.1415927/2); +float t3144 = (t8-t3143); +float t3145 = (3.1415927/2); +float t3146 = (t3090-t3145); +float t3147 = (t3144-t3146); +float t3148 = abs(t3147); +float t3149 = (t3148/2); +float t3150 = sin(t3149); +float t3151 = (t3150*t3150); +float t3152 = cos(t3146); +float t3153 = cos(t3144); +float t3154 = (t3152*t3153); +float t3155 = (t118+3.1415927); +float t3156 = (3.1415927*2); +float t3157 = mod(t3155,t3156); +float t3158 = (t3157-3.1415927); +float t3159 = (t3128+3.1415927); +float t3160 = (3.1415927*2); +float t3161 = mod(t3159,t3160); +float t3162 = (t3161-3.1415927); +float t3163 = (t3158-t3162); +float t3164 = abs(t3163); +float t3165 = (t3164/2); +float t3166 = sin(t3165); +float t3167 = (t3166*t3166); +float t3168 = (t3154*t3167); +float t3169 = (t3151+t3168); +float t3170 = sqrt(t3169); +float t3171 = asin(t3170); +float t3172 = (2*t3171); +float t3173 = (t3142-t3172); +float t3174 = (3.1415927/2); +float t3175 = (t8-t3174); +float t3176 = (3.1415927/2); +float t3177 = (t3064-t3176); +float t3178 = (t3175-t3177); +float t3179 = abs(t3178); +float t3180 = (t3179/2); +float t3181 = sin(t3180); +float t3182 = (t3181*t3181); +float t3183 = cos(t3177); +float t3184 = cos(t3175); +float t3185 = (t3183*t3184); +float t3186 = (t118+3.1415927); +float t3187 = (3.1415927*2); +float t3188 = mod(t3186,t3187); +float t3189 = (t3188-3.1415927); +float t3190 = (t3112+3.1415927); +float t3191 = (3.1415927*2); +float t3192 = mod(t3190,t3191); +float t3193 = (t3192-3.1415927); +float t3194 = (t3189-t3193); +float t3195 = abs(t3194); +float t3196 = (t3195/2); +float t3197 = sin(t3196); +float t3198 = (t3197*t3197); +float t3199 = (t3185*t3198); +float t3200 = (t3182+t3199); +float t3201 = sqrt(t3200); +float t3202 = asin(t3201); +float t3203 = (2*t3202); +float t3204 = (t3173-t3203); +float t3205 = abs(t3204); +bool t3206 = (float(1.0e-4)>t3205); +float t3207; +if(t3206){ +float t3208 = cos(t3090); +float t3209 = (1*t3208); +float t3210 = sin(t3064); +float t3211 = (1*t3210); +float t3212 = cos(t3112); +float t3213 = (t3211*t3212); +float t3214 = (t3209*t3213); +float t3215 = sin(t3090); +float t3216 = (1*t3215); +float t3217 = cos(t3128); +float t3218 = (t3216*t3217); +float t3219 = cos(t3064); +float t3220 = (1*t3219); +float t3221 = (t3218*t3220); +float t3222 = (t3214-t3221); +float t3223 = sin(t8); +float t3224 = (1*t3223); +float t3225 = sin(t118); +float t3226 = (t3224*t3225); +float t3227 = (t3222*t3226); +float t3228 = sin(t3064); +float t3229 = (1*t3228); +float t3230 = sin(t3112); +float t3231 = (t3229*t3230); +float t3232 = (t3218*t3231); +float t3233 = sin(t3090); +float t3234 = (1*t3233); +float t3235 = sin(t3128); +float t3236 = (t3234*t3235); +float t3237 = (t3236*t3213); +float t3238 = (t3232-t3237); +float t3239 = cos(t8); +float t3240 = (1*t3239); +float t3241 = (t3238*t3240); +float t3242 = (t3227+t3241); +float t3243 = (t3236*t3220); +float t3244 = (t3209*t3231); +float t3245 = (t3243-t3244); +float t3246 = sin(t8); +float t3247 = (1*t3246); +float t3248 = cos(t118); +float t3249 = (t3247*t3248); +float t3250 = (t3245*t3249); +float t3251 = (t3242+t3250); +float t3252 = abs(t3251); +t3207 = t3252; +} else { +float t3253 = (3.1415927/2); +float t3254 = (t8-t3253); +float t3255 = (3.1415927/2); +float t3256 = (t3064-t3255); +float t3257 = (t3254-t3256); +float t3258 = abs(t3257); +float t3259 = (t3258/2); +float t3260 = sin(t3259); +float t3261 = (t3260*t3260); +float t3262 = cos(t3256); +float t3263 = cos(t3254); +float t3264 = (t3262*t3263); +float t3265 = (t118+3.1415927); +float t3266 = (3.1415927*2); +float t3267 = mod(t3265,t3266); +float t3268 = (t3267-3.1415927); +float t3269 = (t3112+3.1415927); +float t3270 = (3.1415927*2); +float t3271 = mod(t3269,t3270); +float t3272 = (t3271-3.1415927); +float t3273 = (t3268-t3272); +float t3274 = abs(t3273); +float t3275 = (t3274/2); +float t3276 = sin(t3275); +float t3277 = (t3276*t3276); +float t3278 = (t3264*t3277); +float t3279 = (t3261+t3278); +float t3280 = sqrt(t3279); +float t3281 = asin(t3280); +float t3282 = (2*t3281); +float t3283 = abs(t3282); +float t3284 = (3.1415927/2); +float t3285 = (t8-t3284); +float t3286 = (3.1415927/2); +float t3287 = (t3090-t3286); +float t3288 = (t3285-t3287); +float t3289 = abs(t3288); +float t3290 = (t3289/2); +float t3291 = sin(t3290); +float t3292 = (t3291*t3291); +float t3293 = cos(t3287); +float t3294 = cos(t3285); +float t3295 = (t3293*t3294); +float t3296 = (t118+3.1415927); +float t3297 = (3.1415927*2); +float t3298 = mod(t3296,t3297); +float t3299 = (t3298-3.1415927); +float t3300 = (t3128+3.1415927); +float t3301 = (3.1415927*2); +float t3302 = mod(t3300,t3301); +float t3303 = (t3302-3.1415927); +float t3304 = (t3299-t3303); +float t3305 = abs(t3304); +float t3306 = (t3305/2); +float t3307 = sin(t3306); +float t3308 = (t3307*t3307); +float t3309 = (t3295*t3308); +float t3310 = (t3292+t3309); +float t3311 = sqrt(t3310); +float t3312 = asin(t3311); +float t3313 = (2*t3312); +float t3314 = abs(t3313); +bool t3315 = (t3283>=t3314); +float t3316; +if(t3315){ +t3316 = t3283; +} else { +t3316 = t3314; +} +t3207 = t3316; +} +float t3317 = abs(t3207); +float t3318 = step(float(2.0e-4),t3317); +float t3319 = (1-t3318); +float t3320 = (t2011*t3047); +float t3321 = (t3320*float(842.378)); +float t3322 = fract(t3321); +float t3323 = (t3322+float(45.32)); +float t3324 = (t3323+u6.u0); +float t3325 = (t3322*t3324); +float t3326 = (t2027*t2011); +float t3327 = (t3326*float(1734.048)); +float t3328 = fract(t3327); +float t3329 = (t3328+float(45.32)); +float t3330 = (t3329+u6.u0); +float t3331 = (t3328*t3330); +float t3332 = (t3325+t3331); +float t3333 = (t3322+t3332); +float t3334 = (t3328+t3332); +float t3335 = (t3333*t3334); +float t3336 = fract(t3335); +float t3337 = step(float(0.2),t3336); +float t3338 = (t3319*t3337); +float t3339 = (3.1415927/2); +float t3340 = (t3064-t3339); +float t3341 = (3.1415927/2); +float t3342 = (t3090-t3341); +float t3343 = (t3340-t3342); +float t3344 = abs(t3343); +float t3345 = (t3344/2); +float t3346 = sin(t3345); +float t3347 = (t3346*t3346); +float t3348 = cos(t3342); +float t3349 = cos(t3340); +float t3350 = (t3348*t3349); +float t3351 = (t3112+3.1415927); +float t3352 = (3.1415927*2); +float t3353 = mod(t3351,t3352); +float t3354 = (t3353-3.1415927); +float t3355 = (t3128+3.1415927); +float t3356 = (3.1415927*2); +float t3357 = mod(t3355,t3356); +float t3358 = (t3357-3.1415927); +float t3359 = (t3354-t3358); +float t3360 = abs(t3359); +float t3361 = (t3360/2); +float t3362 = sin(t3361); +float t3363 = (t3362*t3362); +float t3364 = (t3350*t3363); +float t3365 = (t3347+t3364); +float t3366 = sqrt(t3365); +float t3367 = asin(t3366); +float t3368 = (2*t3367); +float t3369 = (t3368/t1344); +float t3370 = (1-t3369); +float t3371 = (t2011/36); +float t3372 = (t3371*float(842.378)); +float t3373 = fract(t3372); +float t3374 = (t3373+float(45.32)); +float t3375 = (t3374+u6.u0); +float t3376 = (t3373*t3375); +float t3377 = (t2027/t2024); +float t3378 = (t3377*float(1734.048)); +float t3379 = fract(t3378); +float t3380 = (t3379+float(45.32)); +float t3381 = (t3380+u6.u0); +float t3382 = (t3379*t3381); +float t3383 = (t3376+t3382); +float t3384 = (t3373+t3383); +float t3385 = (t3379+t3383); +float t3386 = (t3384*t3385); +float t3387 = fract(t3386); +float t3388 = (t3387*float(8.0e-3)); +float t3389 = (float(1.0e-3)+t3388); +float t3390 = (t3387*173); +float t3391 = fract(t3390); +float t3392 = step(float(0.66),t3391); +float t3393 = (t3392*float(3.0e-3)); +float t3394 = (t3389-t3393); +float t3395 = (t3394*float(0.8)); +float t3396 = (t2011/36); +float t3397 = (t3396*float(842.378)); +float t3398 = fract(t3397); +float t3399 = (t3398+float(45.32)); +float t3400 = (t3399+u6.u0); +float t3401 = (t3398*t3400); +float t3402 = (t3047/t2024); +float t3403 = (t3402*float(1734.048)); +float t3404 = fract(t3403); +float t3405 = (t3404+float(45.32)); +float t3406 = (t3405+u6.u0); +float t3407 = (t3404*t3406); +float t3408 = (t3401+t3407); +float t3409 = (t3398+t3408); +float t3410 = (t3404+t3408); +float t3411 = (t3409*t3410); +float t3412 = fract(t3411); +float t3413 = (t3412*float(8.0e-3)); +float t3414 = (float(1.0e-3)+t3413); +float t3415 = (t3412*173); +float t3416 = fract(t3415); +float t3417 = step(float(0.66),t3416); +float t3418 = (t3417*float(3.0e-3)); +float t3419 = (t3414-t3418); +float t3420 = (t3419*float(0.8)); +float t3421 = (t3395-t3420); +float t3422 = abs(t3421); +float t3423 = (t3422-float(1.0e-3)); +float t3424 = (t3423/float(8.0e-3)); +float t3425 = (1-t3424); +float t3426 = (t3425*t3425); +float t3427 = (t3370*t3426); +float t3428 = (t3338*t3427); +float t3429 = (u4.u0*t3336); +float t3430 = (t3429*3); +float t3431 = sin(t3430); +float t3432 = (t3431+1); +float t3433 = (t3432/2); +float t3434 = (t3433*float(0.66)); +float t3435 = (t3434+float(0.33)); +float t3436 = (t3428*t3435); +float t3437 = (float(0.2)*t3436); +bool t3438 = (0>=t3437); +float t3439; +if(t3438){ +t3439 = 0; +} else { +t3439 = t3437; +} +float t3440 = (t3439*1); +float t3441 = (t3039+t3440); +float t3442 = (t2011*t1344); +float t3443 = (t2011/36); +float t3444 = (t3443*float(842.378)); +float t3445 = fract(t3444); +float t3446 = (t3445+float(45.32)); +float t3447 = (t3446+u6.u0); +float t3448 = (t3445*t3447); +float t3449 = (t3047/t2024); +float t3450 = (t3449*float(1734.048)); +float t3451 = fract(t3450); +float t3452 = (t3451+float(45.32)); +float t3453 = (t3452+u6.u0); +float t3454 = (t3451*t3453); +float t3455 = (t3448+t3454); +float t3456 = (t3445+t3455); +float t3457 = (t3451+t3455); +float t3458 = (t3456*t3457); +float t3459 = fract(t3458); +float t3460 = (t3459*float(2852.02)); +float t3461 = fract(t3460); +float t3462 = (t3461-float(0.5)); +float t3463 = (t3462*t1344); +float t3464 = (t3463*float(0.75)); +float t3465 = (t3442+t3464); +float t3466 = (3.1415927/2); +float t3467 = (t3465-t3466); +float t3468 = (t1346*t1344); +float t3469 = (t1346/36); +float t3470 = (t3469*float(842.378)); +float t3471 = fract(t3470); +float t3472 = (t3471+float(45.32)); +float t3473 = (t3472+u6.u0); +float t3474 = (t3471*t3473); +float t3475 = (t1582/t1359); +float t3476 = (t3475*float(1734.048)); +float t3477 = fract(t3476); +float t3478 = (t3477+float(45.32)); +float t3479 = (t3478+u6.u0); +float t3480 = (t3477*t3479); +float t3481 = (t3474+t3480); +float t3482 = (t3471+t3481); +float t3483 = (t3477+t3481); +float t3484 = (t3482*t3483); +float t3485 = fract(t3484); +float t3486 = (t3485*float(2852.02)); +float t3487 = fract(t3486); +float t3488 = (t3487-float(0.5)); +float t3489 = (t3488*t1344); +float t3490 = (t3489*float(0.75)); +float t3491 = (t3468+t3490); +float t3492 = (3.1415927/2); +float t3493 = (t3491-t3492); +float t3494 = (t3467-t3493); +float t3495 = abs(t3494); +float t3496 = (t3495/2); +float t3497 = sin(t3496); +float t3498 = (t3497*t3497); +float t3499 = cos(t3493); +float t3500 = cos(t3467); +float t3501 = (t3499*t3500); +float t3502 = (3.1415927/t2024); +float t3503 = (t3047*t3502); +float t3504 = (t3459*float(97372.83)); +float t3505 = fract(t3504); +float t3506 = (t3505-float(0.5)); +float t3507 = (3.1415927/t2024); +float t3508 = (t3506*t3507); +float t3509 = (t3508*float(0.75)); +float t3510 = (t3503+t3509); +float t3511 = (t3510+3.1415927); +float t3512 = mod(t3511,t1433); +float t3513 = (t3512-3.1415927); +float t3514 = (t3513+3.1415927); +float t3515 = (3.1415927*2); +float t3516 = mod(t3514,t3515); +float t3517 = (t3516-3.1415927); +float t3518 = (3.1415927/t1359); +float t3519 = (t1582*t3518); +float t3520 = (t3485*float(97372.83)); +float t3521 = fract(t3520); +float t3522 = (t3521-float(0.5)); +float t3523 = (3.1415927/t1359); +float t3524 = (t3522*t3523); +float t3525 = (t3524*float(0.75)); +float t3526 = (t3519+t3525); +float t3527 = (t3526+3.1415927); +float t3528 = mod(t3527,t1433); +float t3529 = (t3528-3.1415927); +float t3530 = (t3529+3.1415927); +float t3531 = (3.1415927*2); +float t3532 = mod(t3530,t3531); +float t3533 = (t3532-3.1415927); +float t3534 = (t3517-t3533); +float t3535 = abs(t3534); +float t3536 = (t3535/2); +float t3537 = sin(t3536); +float t3538 = (t3537*t3537); +float t3539 = (t3501*t3538); +float t3540 = (t3498+t3539); +float t3541 = sqrt(t3540); +float t3542 = asin(t3541); +float t3543 = (2*t3542); +float t3544 = (3.1415927/2); +float t3545 = (t8-t3544); +float t3546 = (3.1415927/2); +float t3547 = (t3491-t3546); +float t3548 = (t3545-t3547); +float t3549 = abs(t3548); +float t3550 = (t3549/2); +float t3551 = sin(t3550); +float t3552 = (t3551*t3551); +float t3553 = cos(t3547); +float t3554 = cos(t3545); +float t3555 = (t3553*t3554); +float t3556 = (t118+3.1415927); +float t3557 = (3.1415927*2); +float t3558 = mod(t3556,t3557); +float t3559 = (t3558-3.1415927); +float t3560 = (t3529+3.1415927); +float t3561 = (3.1415927*2); +float t3562 = mod(t3560,t3561); +float t3563 = (t3562-3.1415927); +float t3564 = (t3559-t3563); +float t3565 = abs(t3564); +float t3566 = (t3565/2); +float t3567 = sin(t3566); +float t3568 = (t3567*t3567); +float t3569 = (t3555*t3568); +float t3570 = (t3552+t3569); +float t3571 = sqrt(t3570); +float t3572 = asin(t3571); +float t3573 = (2*t3572); +float t3574 = (t3543-t3573); +float t3575 = (3.1415927/2); +float t3576 = (t8-t3575); +float t3577 = (3.1415927/2); +float t3578 = (t3465-t3577); +float t3579 = (t3576-t3578); +float t3580 = abs(t3579); +float t3581 = (t3580/2); +float t3582 = sin(t3581); +float t3583 = (t3582*t3582); +float t3584 = cos(t3578); +float t3585 = cos(t3576); +float t3586 = (t3584*t3585); +float t3587 = (t118+3.1415927); +float t3588 = (3.1415927*2); +float t3589 = mod(t3587,t3588); +float t3590 = (t3589-3.1415927); +float t3591 = (t3513+3.1415927); +float t3592 = (3.1415927*2); +float t3593 = mod(t3591,t3592); +float t3594 = (t3593-3.1415927); +float t3595 = (t3590-t3594); +float t3596 = abs(t3595); +float t3597 = (t3596/2); +float t3598 = sin(t3597); +float t3599 = (t3598*t3598); +float t3600 = (t3586*t3599); +float t3601 = (t3583+t3600); +float t3602 = sqrt(t3601); +float t3603 = asin(t3602); +float t3604 = (2*t3603); +float t3605 = (t3574-t3604); +float t3606 = abs(t3605); +bool t3607 = (float(1.0e-4)>t3606); +float t3608; +if(t3607){ +float t3609 = cos(t3491); +float t3610 = (1*t3609); +float t3611 = sin(t3465); +float t3612 = (1*t3611); +float t3613 = cos(t3513); +float t3614 = (t3612*t3613); +float t3615 = (t3610*t3614); +float t3616 = sin(t3491); +float t3617 = (1*t3616); +float t3618 = cos(t3529); +float t3619 = (t3617*t3618); +float t3620 = cos(t3465); +float t3621 = (1*t3620); +float t3622 = (t3619*t3621); +float t3623 = (t3615-t3622); +float t3624 = sin(t8); +float t3625 = (1*t3624); +float t3626 = sin(t118); +float t3627 = (t3625*t3626); +float t3628 = (t3623*t3627); +float t3629 = sin(t3465); +float t3630 = (1*t3629); +float t3631 = sin(t3513); +float t3632 = (t3630*t3631); +float t3633 = (t3619*t3632); +float t3634 = sin(t3491); +float t3635 = (1*t3634); +float t3636 = sin(t3529); +float t3637 = (t3635*t3636); +float t3638 = (t3637*t3614); +float t3639 = (t3633-t3638); +float t3640 = cos(t8); +float t3641 = (1*t3640); +float t3642 = (t3639*t3641); +float t3643 = (t3628+t3642); +float t3644 = (t3637*t3621); +float t3645 = (t3610*t3632); +float t3646 = (t3644-t3645); +float t3647 = sin(t8); +float t3648 = (1*t3647); +float t3649 = cos(t118); +float t3650 = (t3648*t3649); +float t3651 = (t3646*t3650); +float t3652 = (t3643+t3651); +float t3653 = abs(t3652); +t3608 = t3653; +} else { +float t3654 = (3.1415927/2); +float t3655 = (t8-t3654); +float t3656 = (3.1415927/2); +float t3657 = (t3465-t3656); +float t3658 = (t3655-t3657); +float t3659 = abs(t3658); +float t3660 = (t3659/2); +float t3661 = sin(t3660); +float t3662 = (t3661*t3661); +float t3663 = cos(t3657); +float t3664 = cos(t3655); +float t3665 = (t3663*t3664); +float t3666 = (t118+3.1415927); +float t3667 = (3.1415927*2); +float t3668 = mod(t3666,t3667); +float t3669 = (t3668-3.1415927); +float t3670 = (t3513+3.1415927); +float t3671 = (3.1415927*2); +float t3672 = mod(t3670,t3671); +float t3673 = (t3672-3.1415927); +float t3674 = (t3669-t3673); +float t3675 = abs(t3674); +float t3676 = (t3675/2); +float t3677 = sin(t3676); +float t3678 = (t3677*t3677); +float t3679 = (t3665*t3678); +float t3680 = (t3662+t3679); +float t3681 = sqrt(t3680); +float t3682 = asin(t3681); +float t3683 = (2*t3682); +float t3684 = abs(t3683); +float t3685 = (3.1415927/2); +float t3686 = (t8-t3685); +float t3687 = (3.1415927/2); +float t3688 = (t3491-t3687); +float t3689 = (t3686-t3688); +float t3690 = abs(t3689); +float t3691 = (t3690/2); +float t3692 = sin(t3691); +float t3693 = (t3692*t3692); +float t3694 = cos(t3688); +float t3695 = cos(t3686); +float t3696 = (t3694*t3695); +float t3697 = (t118+3.1415927); +float t3698 = (3.1415927*2); +float t3699 = mod(t3697,t3698); +float t3700 = (t3699-3.1415927); +float t3701 = (t3529+3.1415927); +float t3702 = (3.1415927*2); +float t3703 = mod(t3701,t3702); +float t3704 = (t3703-3.1415927); +float t3705 = (t3700-t3704); +float t3706 = abs(t3705); +float t3707 = (t3706/2); +float t3708 = sin(t3707); +float t3709 = (t3708*t3708); +float t3710 = (t3696*t3709); +float t3711 = (t3693+t3710); +float t3712 = sqrt(t3711); +float t3713 = asin(t3712); +float t3714 = (2*t3713); +float t3715 = abs(t3714); +bool t3716 = (t3684>=t3715); +float t3717; +if(t3716){ +t3717 = t3684; +} else { +t3717 = t3715; +} +t3608 = t3717; +} +float t3718 = abs(t3608); +float t3719 = step(float(2.0e-4),t3718); +float t3720 = (1-t3719); +float t3721 = (t1346*t3047); +float t3722 = (t3721*float(842.378)); +float t3723 = fract(t3722); +float t3724 = (t3723+float(45.32)); +float t3725 = (t3724+u6.u0); +float t3726 = (t3723*t3725); +float t3727 = (t1582*t2011); +float t3728 = (t3727*float(1734.048)); +float t3729 = fract(t3728); +float t3730 = (t3729+float(45.32)); +float t3731 = (t3730+u6.u0); +float t3732 = (t3729*t3731); +float t3733 = (t3726+t3732); +float t3734 = (t3723+t3733); +float t3735 = (t3729+t3733); +float t3736 = (t3734*t3735); +float t3737 = fract(t3736); +float t3738 = step(float(0.2),t3737); +float t3739 = (t3720*t3738); +float t3740 = (3.1415927/2); +float t3741 = (t3465-t3740); +float t3742 = (3.1415927/2); +float t3743 = (t3491-t3742); +float t3744 = (t3741-t3743); +float t3745 = abs(t3744); +float t3746 = (t3745/2); +float t3747 = sin(t3746); +float t3748 = (t3747*t3747); +float t3749 = cos(t3743); +float t3750 = cos(t3741); +float t3751 = (t3749*t3750); +float t3752 = (t3513+3.1415927); +float t3753 = (3.1415927*2); +float t3754 = mod(t3752,t3753); +float t3755 = (t3754-3.1415927); +float t3756 = (t3529+3.1415927); +float t3757 = (3.1415927*2); +float t3758 = mod(t3756,t3757); +float t3759 = (t3758-3.1415927); +float t3760 = (t3755-t3759); +float t3761 = abs(t3760); +float t3762 = (t3761/2); +float t3763 = sin(t3762); +float t3764 = (t3763*t3763); +float t3765 = (t3751*t3764); +float t3766 = (t3748+t3765); +float t3767 = sqrt(t3766); +float t3768 = asin(t3767); +float t3769 = (2*t3768); +float t3770 = (t3769/t1344); +float t3771 = (1-t3770); +float t3772 = (t1346/36); +float t3773 = (t3772*float(842.378)); +float t3774 = fract(t3773); +float t3775 = (t3774+float(45.32)); +float t3776 = (t3775+u6.u0); +float t3777 = (t3774*t3776); +float t3778 = (t1582/t1359); +float t3779 = (t3778*float(1734.048)); +float t3780 = fract(t3779); +float t3781 = (t3780+float(45.32)); +float t3782 = (t3781+u6.u0); +float t3783 = (t3780*t3782); +float t3784 = (t3777+t3783); +float t3785 = (t3774+t3784); +float t3786 = (t3780+t3784); +float t3787 = (t3785*t3786); +float t3788 = fract(t3787); +float t3789 = (t3788*float(8.0e-3)); +float t3790 = (float(1.0e-3)+t3789); +float t3791 = (t3788*173); +float t3792 = fract(t3791); +float t3793 = step(float(0.66),t3792); +float t3794 = (t3793*float(3.0e-3)); +float t3795 = (t3790-t3794); +float t3796 = (t3795*float(0.8)); +float t3797 = (t2011/36); +float t3798 = (t3797*float(842.378)); +float t3799 = fract(t3798); +float t3800 = (t3799+float(45.32)); +float t3801 = (t3800+u6.u0); +float t3802 = (t3799*t3801); +float t3803 = (t3047/t2024); +float t3804 = (t3803*float(1734.048)); +float t3805 = fract(t3804); +float t3806 = (t3805+float(45.32)); +float t3807 = (t3806+u6.u0); +float t3808 = (t3805*t3807); +float t3809 = (t3802+t3808); +float t3810 = (t3799+t3809); +float t3811 = (t3805+t3809); +float t3812 = (t3810*t3811); +float t3813 = fract(t3812); +float t3814 = (t3813*float(8.0e-3)); +float t3815 = (float(1.0e-3)+t3814); +float t3816 = (t3813*173); +float t3817 = fract(t3816); +float t3818 = step(float(0.66),t3817); +float t3819 = (t3818*float(3.0e-3)); +float t3820 = (t3815-t3819); +float t3821 = (t3820*float(0.8)); +float t3822 = (t3796-t3821); +float t3823 = abs(t3822); +float t3824 = (t3823-float(1.0e-3)); +float t3825 = (t3824/float(8.0e-3)); +float t3826 = (1-t3825); +float t3827 = (t3826*t3826); +float t3828 = (t3771*t3827); +float t3829 = (t3739*t3828); +float t3830 = (u4.u0*t3737); +float t3831 = (t3830*3); +float t3832 = sin(t3831); +float t3833 = (t3832+1); +float t3834 = (t3833/2); +float t3835 = (t3834*float(0.66)); +float t3836 = (t3835+float(0.33)); +float t3837 = (t3829*t3836); +float t3838 = (float(0.2)*t3837); +bool t3839 = (0>=t3838); +float t3840; +if(t3839){ +t3840 = 0; +} else { +t3840 = t3838; +} +float t3841 = (t3840*1); +float t3842 = (t3441+t3841); +float t3843 = (t2011*t1344); +float t3844 = (t2011/36); +float t3845 = (t3844*float(842.378)); +float t3846 = fract(t3845); +float t3847 = (t3846+float(45.32)); +float t3848 = (t3847+u6.u0); +float t3849 = (t3846*t3848); +float t3850 = (t3047/t2024); +float t3851 = (t3850*float(1734.048)); +float t3852 = fract(t3851); +float t3853 = (t3852+float(45.32)); +float t3854 = (t3853+u6.u0); +float t3855 = (t3852*t3854); +float t3856 = (t3849+t3855); +float t3857 = (t3846+t3856); +float t3858 = (t3852+t3856); +float t3859 = (t3857*t3858); +float t3860 = fract(t3859); +float t3861 = (t3860*float(2852.02)); +float t3862 = fract(t3861); +float t3863 = (t3862-float(0.5)); +float t3864 = (t3863*t1344); +float t3865 = (t3864*float(0.75)); +float t3866 = (t3843+t3865); +float t3867 = (3.1415927/2); +float t3868 = (t3866-t3867); +float t3869 = (t1346*t1344); +float t3870 = (t1346/36); +float t3871 = (t3870*float(842.378)); +float t3872 = fract(t3871); +float t3873 = (t3872+float(45.32)); +float t3874 = (t3873+u6.u0); +float t3875 = (t3872*t3874); +float t3876 = (t1362/t1359); +float t3877 = (t3876*float(1734.048)); +float t3878 = fract(t3877); +float t3879 = (t3878+float(45.32)); +float t3880 = (t3879+u6.u0); +float t3881 = (t3878*t3880); +float t3882 = (t3875+t3881); +float t3883 = (t3872+t3882); +float t3884 = (t3878+t3882); +float t3885 = (t3883*t3884); +float t3886 = fract(t3885); +float t3887 = (t3886*float(2852.02)); +float t3888 = fract(t3887); +float t3889 = (t3888-float(0.5)); +float t3890 = (t3889*t1344); +float t3891 = (t3890*float(0.75)); +float t3892 = (t3869+t3891); +float t3893 = (3.1415927/2); +float t3894 = (t3892-t3893); +float t3895 = (t3868-t3894); +float t3896 = abs(t3895); +float t3897 = (t3896/2); +float t3898 = sin(t3897); +float t3899 = (t3898*t3898); +float t3900 = cos(t3894); +float t3901 = cos(t3868); +float t3902 = (t3900*t3901); +float t3903 = (3.1415927/t2024); +float t3904 = (t3047*t3903); +float t3905 = (t3860*float(97372.83)); +float t3906 = fract(t3905); +float t3907 = (t3906-float(0.5)); +float t3908 = (3.1415927/t2024); +float t3909 = (t3907*t3908); +float t3910 = (t3909*float(0.75)); +float t3911 = (t3904+t3910); +float t3912 = (t3911+3.1415927); +float t3913 = mod(t3912,t1433); +float t3914 = (t3913-3.1415927); +float t3915 = (t3914+3.1415927); +float t3916 = (3.1415927*2); +float t3917 = mod(t3915,t3916); +float t3918 = (t3917-3.1415927); +float t3919 = (3.1415927/t1359); +float t3920 = (t1362*t3919); +float t3921 = (t3886*float(97372.83)); +float t3922 = fract(t3921); +float t3923 = (t3922-float(0.5)); +float t3924 = (3.1415927/t1359); +float t3925 = (t3923*t3924); +float t3926 = (t3925*float(0.75)); +float t3927 = (t3920+t3926); +float t3928 = (t3927+3.1415927); +float t3929 = mod(t3928,t1433); +float t3930 = (t3929-3.1415927); +float t3931 = (t3930+3.1415927); +float t3932 = (3.1415927*2); +float t3933 = mod(t3931,t3932); +float t3934 = (t3933-3.1415927); +float t3935 = (t3918-t3934); +float t3936 = abs(t3935); +float t3937 = (t3936/2); +float t3938 = sin(t3937); +float t3939 = (t3938*t3938); +float t3940 = (t3902*t3939); +float t3941 = (t3899+t3940); +float t3942 = sqrt(t3941); +float t3943 = asin(t3942); +float t3944 = (2*t3943); +float t3945 = (3.1415927/2); +float t3946 = (t8-t3945); +float t3947 = (3.1415927/2); +float t3948 = (t3892-t3947); +float t3949 = (t3946-t3948); +float t3950 = abs(t3949); +float t3951 = (t3950/2); +float t3952 = sin(t3951); +float t3953 = (t3952*t3952); +float t3954 = cos(t3948); +float t3955 = cos(t3946); +float t3956 = (t3954*t3955); +float t3957 = (t118+3.1415927); +float t3958 = (3.1415927*2); +float t3959 = mod(t3957,t3958); +float t3960 = (t3959-3.1415927); +float t3961 = (t3930+3.1415927); +float t3962 = (3.1415927*2); +float t3963 = mod(t3961,t3962); +float t3964 = (t3963-3.1415927); +float t3965 = (t3960-t3964); +float t3966 = abs(t3965); +float t3967 = (t3966/2); +float t3968 = sin(t3967); +float t3969 = (t3968*t3968); +float t3970 = (t3956*t3969); +float t3971 = (t3953+t3970); +float t3972 = sqrt(t3971); +float t3973 = asin(t3972); +float t3974 = (2*t3973); +float t3975 = (t3944-t3974); +float t3976 = (3.1415927/2); +float t3977 = (t8-t3976); +float t3978 = (3.1415927/2); +float t3979 = (t3866-t3978); +float t3980 = (t3977-t3979); +float t3981 = abs(t3980); +float t3982 = (t3981/2); +float t3983 = sin(t3982); +float t3984 = (t3983*t3983); +float t3985 = cos(t3979); +float t3986 = cos(t3977); +float t3987 = (t3985*t3986); +float t3988 = (t118+3.1415927); +float t3989 = (3.1415927*2); +float t3990 = mod(t3988,t3989); +float t3991 = (t3990-3.1415927); +float t3992 = (t3914+3.1415927); +float t3993 = (3.1415927*2); +float t3994 = mod(t3992,t3993); +float t3995 = (t3994-3.1415927); +float t3996 = (t3991-t3995); +float t3997 = abs(t3996); +float t3998 = (t3997/2); +float t3999 = sin(t3998); +float t4000 = (t3999*t3999); +float t4001 = (t3987*t4000); +float t4002 = (t3984+t4001); +float t4003 = sqrt(t4002); +float t4004 = asin(t4003); +float t4005 = (2*t4004); +float t4006 = (t3975-t4005); +float t4007 = abs(t4006); +bool t4008 = (float(1.0e-4)>t4007); +float t4009; +if(t4008){ +float t4010 = cos(t3892); +float t4011 = (1*t4010); +float t4012 = sin(t3866); +float t4013 = (1*t4012); +float t4014 = cos(t3914); +float t4015 = (t4013*t4014); +float t4016 = (t4011*t4015); +float t4017 = sin(t3892); +float t4018 = (1*t4017); +float t4019 = cos(t3930); +float t4020 = (t4018*t4019); +float t4021 = cos(t3866); +float t4022 = (1*t4021); +float t4023 = (t4020*t4022); +float t4024 = (t4016-t4023); +float t4025 = sin(t8); +float t4026 = (1*t4025); +float t4027 = sin(t118); +float t4028 = (t4026*t4027); +float t4029 = (t4024*t4028); +float t4030 = sin(t3866); +float t4031 = (1*t4030); +float t4032 = sin(t3914); +float t4033 = (t4031*t4032); +float t4034 = (t4020*t4033); +float t4035 = sin(t3892); +float t4036 = (1*t4035); +float t4037 = sin(t3930); +float t4038 = (t4036*t4037); +float t4039 = (t4038*t4015); +float t4040 = (t4034-t4039); +float t4041 = cos(t8); +float t4042 = (1*t4041); +float t4043 = (t4040*t4042); +float t4044 = (t4029+t4043); +float t4045 = (t4038*t4022); +float t4046 = (t4011*t4033); +float t4047 = (t4045-t4046); +float t4048 = sin(t8); +float t4049 = (1*t4048); +float t4050 = cos(t118); +float t4051 = (t4049*t4050); +float t4052 = (t4047*t4051); +float t4053 = (t4044+t4052); +float t4054 = abs(t4053); +t4009 = t4054; +} else { +float t4055 = (3.1415927/2); +float t4056 = (t8-t4055); +float t4057 = (3.1415927/2); +float t4058 = (t3866-t4057); +float t4059 = (t4056-t4058); +float t4060 = abs(t4059); +float t4061 = (t4060/2); +float t4062 = sin(t4061); +float t4063 = (t4062*t4062); +float t4064 = cos(t4058); +float t4065 = cos(t4056); +float t4066 = (t4064*t4065); +float t4067 = (t118+3.1415927); +float t4068 = (3.1415927*2); +float t4069 = mod(t4067,t4068); +float t4070 = (t4069-3.1415927); +float t4071 = (t3914+3.1415927); +float t4072 = (3.1415927*2); +float t4073 = mod(t4071,t4072); +float t4074 = (t4073-3.1415927); +float t4075 = (t4070-t4074); +float t4076 = abs(t4075); +float t4077 = (t4076/2); +float t4078 = sin(t4077); +float t4079 = (t4078*t4078); +float t4080 = (t4066*t4079); +float t4081 = (t4063+t4080); +float t4082 = sqrt(t4081); +float t4083 = asin(t4082); +float t4084 = (2*t4083); +float t4085 = abs(t4084); +float t4086 = (3.1415927/2); +float t4087 = (t8-t4086); +float t4088 = (3.1415927/2); +float t4089 = (t3892-t4088); +float t4090 = (t4087-t4089); +float t4091 = abs(t4090); +float t4092 = (t4091/2); +float t4093 = sin(t4092); +float t4094 = (t4093*t4093); +float t4095 = cos(t4089); +float t4096 = cos(t4087); +float t4097 = (t4095*t4096); +float t4098 = (t118+3.1415927); +float t4099 = (3.1415927*2); +float t4100 = mod(t4098,t4099); +float t4101 = (t4100-3.1415927); +float t4102 = (t3930+3.1415927); +float t4103 = (3.1415927*2); +float t4104 = mod(t4102,t4103); +float t4105 = (t4104-3.1415927); +float t4106 = (t4101-t4105); +float t4107 = abs(t4106); +float t4108 = (t4107/2); +float t4109 = sin(t4108); +float t4110 = (t4109*t4109); +float t4111 = (t4097*t4110); +float t4112 = (t4094+t4111); +float t4113 = sqrt(t4112); +float t4114 = asin(t4113); +float t4115 = (2*t4114); +float t4116 = abs(t4115); +bool t4117 = (t4085>=t4116); +float t4118; +if(t4117){ +t4118 = t4085; +} else { +t4118 = t4116; +} +t4009 = t4118; +} +float t4119 = abs(t4009); +float t4120 = step(float(2.0e-4),t4119); +float t4121 = (1-t4120); +float t4122 = (t1346*t3047); +float t4123 = (t4122*float(842.378)); +float t4124 = fract(t4123); +float t4125 = (t4124+float(45.32)); +float t4126 = (t4125+u6.u0); +float t4127 = (t4124*t4126); +float t4128 = (t1362*t2011); +float t4129 = (t4128*float(1734.048)); +float t4130 = fract(t4129); +float t4131 = (t4130+float(45.32)); +float t4132 = (t4131+u6.u0); +float t4133 = (t4130*t4132); +float t4134 = (t4127+t4133); +float t4135 = (t4124+t4134); +float t4136 = (t4130+t4134); +float t4137 = (t4135*t4136); +float t4138 = fract(t4137); +float t4139 = step(float(0.2),t4138); +float t4140 = (t4121*t4139); +float t4141 = (3.1415927/2); +float t4142 = (t3866-t4141); +float t4143 = (3.1415927/2); +float t4144 = (t3892-t4143); +float t4145 = (t4142-t4144); +float t4146 = abs(t4145); +float t4147 = (t4146/2); +float t4148 = sin(t4147); +float t4149 = (t4148*t4148); +float t4150 = cos(t4144); +float t4151 = cos(t4142); +float t4152 = (t4150*t4151); +float t4153 = (t3914+3.1415927); +float t4154 = (3.1415927*2); +float t4155 = mod(t4153,t4154); +float t4156 = (t4155-3.1415927); +float t4157 = (t3930+3.1415927); +float t4158 = (3.1415927*2); +float t4159 = mod(t4157,t4158); +float t4160 = (t4159-3.1415927); +float t4161 = (t4156-t4160); +float t4162 = abs(t4161); +float t4163 = (t4162/2); +float t4164 = sin(t4163); +float t4165 = (t4164*t4164); +float t4166 = (t4152*t4165); +float t4167 = (t4149+t4166); +float t4168 = sqrt(t4167); +float t4169 = asin(t4168); +float t4170 = (2*t4169); +float t4171 = (t4170/t1344); +float t4172 = (1-t4171); +float t4173 = (t1346/36); +float t4174 = (t4173*float(842.378)); +float t4175 = fract(t4174); +float t4176 = (t4175+float(45.32)); +float t4177 = (t4176+u6.u0); +float t4178 = (t4175*t4177); +float t4179 = (t1362/t1359); +float t4180 = (t4179*float(1734.048)); +float t4181 = fract(t4180); +float t4182 = (t4181+float(45.32)); +float t4183 = (t4182+u6.u0); +float t4184 = (t4181*t4183); +float t4185 = (t4178+t4184); +float t4186 = (t4175+t4185); +float t4187 = (t4181+t4185); +float t4188 = (t4186*t4187); +float t4189 = fract(t4188); +float t4190 = (t4189*float(8.0e-3)); +float t4191 = (float(1.0e-3)+t4190); +float t4192 = (t4189*173); +float t4193 = fract(t4192); +float t4194 = step(float(0.66),t4193); +float t4195 = (t4194*float(3.0e-3)); +float t4196 = (t4191-t4195); +float t4197 = (t4196*float(0.8)); +float t4198 = (t2011/36); +float t4199 = (t4198*float(842.378)); +float t4200 = fract(t4199); +float t4201 = (t4200+float(45.32)); +float t4202 = (t4201+u6.u0); +float t4203 = (t4200*t4202); +float t4204 = (t3047/t2024); +float t4205 = (t4204*float(1734.048)); +float t4206 = fract(t4205); +float t4207 = (t4206+float(45.32)); +float t4208 = (t4207+u6.u0); +float t4209 = (t4206*t4208); +float t4210 = (t4203+t4209); +float t4211 = (t4200+t4210); +float t4212 = (t4206+t4210); +float t4213 = (t4211*t4212); +float t4214 = fract(t4213); +float t4215 = (t4214*float(8.0e-3)); +float t4216 = (float(1.0e-3)+t4215); +float t4217 = (t4214*173); +float t4218 = fract(t4217); +float t4219 = step(float(0.66),t4218); +float t4220 = (t4219*float(3.0e-3)); +float t4221 = (t4216-t4220); +float t4222 = (t4221*float(0.8)); +float t4223 = (t4197-t4222); +float t4224 = abs(t4223); +float t4225 = (t4224-float(1.0e-3)); +float t4226 = (t4225/float(8.0e-3)); +float t4227 = (1-t4226); +float t4228 = (t4227*t4227); +float t4229 = (t4172*t4228); +float t4230 = (t4140*t4229); +float t4231 = (u4.u0*t4138); +float t4232 = (t4231*3); +float t4233 = sin(t4232); +float t4234 = (t4233+1); +float t4235 = (t4234/2); +float t4236 = (t4235*float(0.66)); +float t4237 = (t4236+float(0.33)); +float t4238 = (t4230*t4237); +float t4239 = (float(0.2)*t4238); +bool t4240 = (0>=t4239); +float t4241; +if(t4240){ +t4241 = 0; +} else { +t4241 = t4239; +} +float t4242 = (t4241*1); +float t4243 = (t3842+t4242); +float t4244 = (t1346*t1344); +float t4245 = (t1346/36); +float t4246 = (t4245*float(842.378)); +float t4247 = fract(t4246); +float t4248 = (t4247+float(45.32)); +float t4249 = (t4248+u6.u0); +float t4250 = (t4247*t4249); +float t4251 = (t1800/t1359); +float t4252 = (t4251*float(1734.048)); +float t4253 = fract(t4252); +float t4254 = (t4253+float(45.32)); +float t4255 = (t4254+u6.u0); +float t4256 = (t4253*t4255); +float t4257 = (t4250+t4256); +float t4258 = (t4247+t4257); +float t4259 = (t4253+t4257); +float t4260 = (t4258*t4259); +float t4261 = fract(t4260); +float t4262 = (t4261*float(2852.02)); +float t4263 = fract(t4262); +float t4264 = (t4263-float(0.5)); +float t4265 = (t4264*t1344); +float t4266 = (t4265*float(0.75)); +float t4267 = (t4244+t4266); +float t4268 = (3.1415927/2); +float t4269 = (t4267-t4268); +float t4270 = (t1346*t1344); +float t4271 = (t1346/36); +float t4272 = (t4271*float(842.378)); +float t4273 = fract(t4272); +float t4274 = (t4273+float(45.32)); +float t4275 = (t4274+u6.u0); +float t4276 = (t4273*t4275); +float t4277 = (t1582/t1359); +float t4278 = (t4277*float(1734.048)); +float t4279 = fract(t4278); +float t4280 = (t4279+float(45.32)); +float t4281 = (t4280+u6.u0); +float t4282 = (t4279*t4281); +float t4283 = (t4276+t4282); +float t4284 = (t4273+t4283); +float t4285 = (t4279+t4283); +float t4286 = (t4284*t4285); +float t4287 = fract(t4286); +float t4288 = (t4287*float(2852.02)); +float t4289 = fract(t4288); +float t4290 = (t4289-float(0.5)); +float t4291 = (t4290*t1344); +float t4292 = (t4291*float(0.75)); +float t4293 = (t4270+t4292); +float t4294 = (3.1415927/2); +float t4295 = (t4293-t4294); +float t4296 = (t4269-t4295); +float t4297 = abs(t4296); +float t4298 = (t4297/2); +float t4299 = sin(t4298); +float t4300 = (t4299*t4299); +float t4301 = cos(t4295); +float t4302 = cos(t4269); +float t4303 = (t4301*t4302); +float t4304 = (3.1415927/t1359); +float t4305 = (t1800*t4304); +float t4306 = (t4261*float(97372.83)); +float t4307 = fract(t4306); +float t4308 = (t4307-float(0.5)); +float t4309 = (3.1415927/t1359); +float t4310 = (t4308*t4309); +float t4311 = (t4310*float(0.75)); +float t4312 = (t4305+t4311); +float t4313 = (t4312+3.1415927); +float t4314 = mod(t4313,t1433); +float t4315 = (t4314-3.1415927); +float t4316 = (t4315+3.1415927); +float t4317 = (3.1415927*2); +float t4318 = mod(t4316,t4317); +float t4319 = (t4318-3.1415927); +float t4320 = (3.1415927/t1359); +float t4321 = (t1582*t4320); +float t4322 = (t4287*float(97372.83)); +float t4323 = fract(t4322); +float t4324 = (t4323-float(0.5)); +float t4325 = (3.1415927/t1359); +float t4326 = (t4324*t4325); +float t4327 = (t4326*float(0.75)); +float t4328 = (t4321+t4327); +float t4329 = (t4328+3.1415927); +float t4330 = mod(t4329,t1433); +float t4331 = (t4330-3.1415927); +float t4332 = (t4331+3.1415927); +float t4333 = (3.1415927*2); +float t4334 = mod(t4332,t4333); +float t4335 = (t4334-3.1415927); +float t4336 = (t4319-t4335); +float t4337 = abs(t4336); +float t4338 = (t4337/2); +float t4339 = sin(t4338); +float t4340 = (t4339*t4339); +float t4341 = (t4303*t4340); +float t4342 = (t4300+t4341); +float t4343 = sqrt(t4342); +float t4344 = asin(t4343); +float t4345 = (2*t4344); +float t4346 = (3.1415927/2); +float t4347 = (t8-t4346); +float t4348 = (3.1415927/2); +float t4349 = (t4293-t4348); +float t4350 = (t4347-t4349); +float t4351 = abs(t4350); +float t4352 = (t4351/2); +float t4353 = sin(t4352); +float t4354 = (t4353*t4353); +float t4355 = cos(t4349); +float t4356 = cos(t4347); +float t4357 = (t4355*t4356); +float t4358 = (t118+3.1415927); +float t4359 = (3.1415927*2); +float t4360 = mod(t4358,t4359); +float t4361 = (t4360-3.1415927); +float t4362 = (t4331+3.1415927); +float t4363 = (3.1415927*2); +float t4364 = mod(t4362,t4363); +float t4365 = (t4364-3.1415927); +float t4366 = (t4361-t4365); +float t4367 = abs(t4366); +float t4368 = (t4367/2); +float t4369 = sin(t4368); +float t4370 = (t4369*t4369); +float t4371 = (t4357*t4370); +float t4372 = (t4354+t4371); +float t4373 = sqrt(t4372); +float t4374 = asin(t4373); +float t4375 = (2*t4374); +float t4376 = (t4345-t4375); +float t4377 = (3.1415927/2); +float t4378 = (t8-t4377); +float t4379 = (3.1415927/2); +float t4380 = (t4267-t4379); +float t4381 = (t4378-t4380); +float t4382 = abs(t4381); +float t4383 = (t4382/2); +float t4384 = sin(t4383); +float t4385 = (t4384*t4384); +float t4386 = cos(t4380); +float t4387 = cos(t4378); +float t4388 = (t4386*t4387); +float t4389 = (t118+3.1415927); +float t4390 = (3.1415927*2); +float t4391 = mod(t4389,t4390); +float t4392 = (t4391-3.1415927); +float t4393 = (t4315+3.1415927); +float t4394 = (3.1415927*2); +float t4395 = mod(t4393,t4394); +float t4396 = (t4395-3.1415927); +float t4397 = (t4392-t4396); +float t4398 = abs(t4397); +float t4399 = (t4398/2); +float t4400 = sin(t4399); +float t4401 = (t4400*t4400); +float t4402 = (t4388*t4401); +float t4403 = (t4385+t4402); +float t4404 = sqrt(t4403); +float t4405 = asin(t4404); +float t4406 = (2*t4405); +float t4407 = (t4376-t4406); +float t4408 = abs(t4407); +bool t4409 = (float(1.0e-4)>t4408); +float t4410; +if(t4409){ +float t4411 = cos(t4293); +float t4412 = (1*t4411); +float t4413 = sin(t4267); +float t4414 = (1*t4413); +float t4415 = cos(t4315); +float t4416 = (t4414*t4415); +float t4417 = (t4412*t4416); +float t4418 = sin(t4293); +float t4419 = (1*t4418); +float t4420 = cos(t4331); +float t4421 = (t4419*t4420); +float t4422 = cos(t4267); +float t4423 = (1*t4422); +float t4424 = (t4421*t4423); +float t4425 = (t4417-t4424); +float t4426 = sin(t8); +float t4427 = (1*t4426); +float t4428 = sin(t118); +float t4429 = (t4427*t4428); +float t4430 = (t4425*t4429); +float t4431 = sin(t4267); +float t4432 = (1*t4431); +float t4433 = sin(t4315); +float t4434 = (t4432*t4433); +float t4435 = (t4421*t4434); +float t4436 = sin(t4293); +float t4437 = (1*t4436); +float t4438 = sin(t4331); +float t4439 = (t4437*t4438); +float t4440 = (t4439*t4416); +float t4441 = (t4435-t4440); +float t4442 = cos(t8); +float t4443 = (1*t4442); +float t4444 = (t4441*t4443); +float t4445 = (t4430+t4444); +float t4446 = (t4439*t4423); +float t4447 = (t4412*t4434); +float t4448 = (t4446-t4447); +float t4449 = sin(t8); +float t4450 = (1*t4449); +float t4451 = cos(t118); +float t4452 = (t4450*t4451); +float t4453 = (t4448*t4452); +float t4454 = (t4445+t4453); +float t4455 = abs(t4454); +t4410 = t4455; +} else { +float t4456 = (3.1415927/2); +float t4457 = (t8-t4456); +float t4458 = (3.1415927/2); +float t4459 = (t4267-t4458); +float t4460 = (t4457-t4459); +float t4461 = abs(t4460); +float t4462 = (t4461/2); +float t4463 = sin(t4462); +float t4464 = (t4463*t4463); +float t4465 = cos(t4459); +float t4466 = cos(t4457); +float t4467 = (t4465*t4466); +float t4468 = (t118+3.1415927); +float t4469 = (3.1415927*2); +float t4470 = mod(t4468,t4469); +float t4471 = (t4470-3.1415927); +float t4472 = (t4315+3.1415927); +float t4473 = (3.1415927*2); +float t4474 = mod(t4472,t4473); +float t4475 = (t4474-3.1415927); +float t4476 = (t4471-t4475); +float t4477 = abs(t4476); +float t4478 = (t4477/2); +float t4479 = sin(t4478); +float t4480 = (t4479*t4479); +float t4481 = (t4467*t4480); +float t4482 = (t4464+t4481); +float t4483 = sqrt(t4482); +float t4484 = asin(t4483); +float t4485 = (2*t4484); +float t4486 = abs(t4485); +float t4487 = (3.1415927/2); +float t4488 = (t8-t4487); +float t4489 = (3.1415927/2); +float t4490 = (t4293-t4489); +float t4491 = (t4488-t4490); +float t4492 = abs(t4491); +float t4493 = (t4492/2); +float t4494 = sin(t4493); +float t4495 = (t4494*t4494); +float t4496 = cos(t4490); +float t4497 = cos(t4488); +float t4498 = (t4496*t4497); +float t4499 = (t118+3.1415927); +float t4500 = (3.1415927*2); +float t4501 = mod(t4499,t4500); +float t4502 = (t4501-3.1415927); +float t4503 = (t4331+3.1415927); +float t4504 = (3.1415927*2); +float t4505 = mod(t4503,t4504); +float t4506 = (t4505-3.1415927); +float t4507 = (t4502-t4506); +float t4508 = abs(t4507); +float t4509 = (t4508/2); +float t4510 = sin(t4509); +float t4511 = (t4510*t4510); +float t4512 = (t4498*t4511); +float t4513 = (t4495+t4512); +float t4514 = sqrt(t4513); +float t4515 = asin(t4514); +float t4516 = (2*t4515); +float t4517 = abs(t4516); +bool t4518 = (t4486>=t4517); +float t4519; +if(t4518){ +t4519 = t4486; +} else { +t4519 = t4517; +} +t4410 = t4519; +} +float t4520 = abs(t4410); +float t4521 = step(float(2.0e-4),t4520); +float t4522 = (1-t4521); +float t4523 = (t1346*t1800); +float t4524 = (t4523*float(842.378)); +float t4525 = fract(t4524); +float t4526 = (t4525+float(45.32)); +float t4527 = (t4526+u6.u0); +float t4528 = (t4525*t4527); +float t4529 = (t1582*t1346); +float t4530 = (t4529*float(1734.048)); +float t4531 = fract(t4530); +float t4532 = (t4531+float(45.32)); +float t4533 = (t4532+u6.u0); +float t4534 = (t4531*t4533); +float t4535 = (t4528+t4534); +float t4536 = (t4525+t4535); +float t4537 = (t4531+t4535); +float t4538 = (t4536*t4537); +float t4539 = fract(t4538); +float t4540 = step(float(0.2),t4539); +float t4541 = (t4522*t4540); +float t4542 = (3.1415927/2); +float t4543 = (t4267-t4542); +float t4544 = (3.1415927/2); +float t4545 = (t4293-t4544); +float t4546 = (t4543-t4545); +float t4547 = abs(t4546); +float t4548 = (t4547/2); +float t4549 = sin(t4548); +float t4550 = (t4549*t4549); +float t4551 = cos(t4545); +float t4552 = cos(t4543); +float t4553 = (t4551*t4552); +float t4554 = (t4315+3.1415927); +float t4555 = (3.1415927*2); +float t4556 = mod(t4554,t4555); +float t4557 = (t4556-3.1415927); +float t4558 = (t4331+3.1415927); +float t4559 = (3.1415927*2); +float t4560 = mod(t4558,t4559); +float t4561 = (t4560-3.1415927); +float t4562 = (t4557-t4561); +float t4563 = abs(t4562); +float t4564 = (t4563/2); +float t4565 = sin(t4564); +float t4566 = (t4565*t4565); +float t4567 = (t4553*t4566); +float t4568 = (t4550+t4567); +float t4569 = sqrt(t4568); +float t4570 = asin(t4569); +float t4571 = (2*t4570); +float t4572 = (t4571/t1344); +float t4573 = (1-t4572); +float t4574 = (t1346/36); +float t4575 = (t4574*float(842.378)); +float t4576 = fract(t4575); +float t4577 = (t4576+float(45.32)); +float t4578 = (t4577+u6.u0); +float t4579 = (t4576*t4578); +float t4580 = (t1582/t1359); +float t4581 = (t4580*float(1734.048)); +float t4582 = fract(t4581); +float t4583 = (t4582+float(45.32)); +float t4584 = (t4583+u6.u0); +float t4585 = (t4582*t4584); +float t4586 = (t4579+t4585); +float t4587 = (t4576+t4586); +float t4588 = (t4582+t4586); +float t4589 = (t4587*t4588); +float t4590 = fract(t4589); +float t4591 = (t4590*float(8.0e-3)); +float t4592 = (float(1.0e-3)+t4591); +float t4593 = (t4590*173); +float t4594 = fract(t4593); +float t4595 = step(float(0.66),t4594); +float t4596 = (t4595*float(3.0e-3)); +float t4597 = (t4592-t4596); +float t4598 = (t4597*float(0.8)); +float t4599 = (t1346/36); +float t4600 = (t4599*float(842.378)); +float t4601 = fract(t4600); +float t4602 = (t4601+float(45.32)); +float t4603 = (t4602+u6.u0); +float t4604 = (t4601*t4603); +float t4605 = (t1800/t1359); +float t4606 = (t4605*float(1734.048)); +float t4607 = fract(t4606); +float t4608 = (t4607+float(45.32)); +float t4609 = (t4608+u6.u0); +float t4610 = (t4607*t4609); +float t4611 = (t4604+t4610); +float t4612 = (t4601+t4611); +float t4613 = (t4607+t4611); +float t4614 = (t4612*t4613); +float t4615 = fract(t4614); +float t4616 = (t4615*float(8.0e-3)); +float t4617 = (float(1.0e-3)+t4616); +float t4618 = (t4615*173); +float t4619 = fract(t4618); +float t4620 = step(float(0.66),t4619); +float t4621 = (t4620*float(3.0e-3)); +float t4622 = (t4617-t4621); +float t4623 = (t4622*float(0.8)); +float t4624 = (t4598-t4623); +float t4625 = abs(t4624); +float t4626 = (t4625-float(1.0e-3)); +float t4627 = (t4626/float(8.0e-3)); +float t4628 = (1-t4627); +float t4629 = (t4628*t4628); +float t4630 = (t4573*t4629); +float t4631 = (t4541*t4630); +float t4632 = (u4.u0*t4539); +float t4633 = (t4632*3); +float t4634 = sin(t4633); +float t4635 = (t4634+1); +float t4636 = (t4635/2); +float t4637 = (t4636*float(0.66)); +float t4638 = (t4637+float(0.33)); +float t4639 = (t4631*t4638); +float t4640 = (float(0.2)*t4639); +bool t4641 = (0>=t4640); +float t4642; +if(t4641){ +t4642 = 0; +} else { +t4642 = t4640; +} +float t4643 = (t4642*1); +float t4644 = (t4243+t4643); +float t4645 = (t1346*t1344); +float t4646 = (t1346/36); +float t4647 = (t4646*float(842.378)); +float t4648 = fract(t4647); +float t4649 = (t4648+float(45.32)); +float t4650 = (t4649+u6.u0); +float t4651 = (t4648*t4650); +float t4652 = (t1362+2); +float t4653 = (t4652/t2024); +float t4654 = (t4653*float(1734.048)); +float t4655 = fract(t4654); +float t4656 = (t4655+float(45.32)); +float t4657 = (t4656+u6.u0); +float t4658 = (t4655*t4657); +float t4659 = (t4651+t4658); +float t4660 = (t4648+t4659); +float t4661 = (t4655+t4659); +float t4662 = (t4660*t4661); +float t4663 = fract(t4662); +float t4664 = (t4663*float(2852.02)); +float t4665 = fract(t4664); +float t4666 = (t4665-float(0.5)); +float t4667 = (t4666*t1344); +float t4668 = (t4667*float(0.75)); +float t4669 = (t4645+t4668); +float t4670 = (3.1415927/2); +float t4671 = (t4669-t4670); +float t4672 = (t2011*t1344); +float t4673 = (t2011/36); +float t4674 = (t4673*float(842.378)); +float t4675 = fract(t4674); +float t4676 = (t4675+float(45.32)); +float t4677 = (t4676+u6.u0); +float t4678 = (t4675*t4677); +float t4679 = (t3047/t2024); +float t4680 = (t4679*float(1734.048)); +float t4681 = fract(t4680); +float t4682 = (t4681+float(45.32)); +float t4683 = (t4682+u6.u0); +float t4684 = (t4681*t4683); +float t4685 = (t4678+t4684); +float t4686 = (t4675+t4685); +float t4687 = (t4681+t4685); +float t4688 = (t4686*t4687); +float t4689 = fract(t4688); +float t4690 = (t4689*float(2852.02)); +float t4691 = fract(t4690); +float t4692 = (t4691-float(0.5)); +float t4693 = (t4692*t1344); +float t4694 = (t4693*float(0.75)); +float t4695 = (t4672+t4694); +float t4696 = (3.1415927/2); +float t4697 = (t4695-t4696); +float t4698 = (t4671-t4697); +float t4699 = abs(t4698); +float t4700 = (t4699/2); +float t4701 = sin(t4700); +float t4702 = (t4701*t4701); +float t4703 = cos(t4697); +float t4704 = cos(t4671); +float t4705 = (t4703*t4704); +float t4706 = (3.1415927/t2024); +float t4707 = (t4652*t4706); +float t4708 = (t4663*float(97372.83)); +float t4709 = fract(t4708); +float t4710 = (t4709-float(0.5)); +float t4711 = (3.1415927/t2024); +float t4712 = (t4710*t4711); +float t4713 = (t4712*float(0.75)); +float t4714 = (t4707+t4713); +float t4715 = (t4714+3.1415927); +float t4716 = mod(t4715,t1433); +float t4717 = (t4716-3.1415927); +float t4718 = (t4717+3.1415927); +float t4719 = (3.1415927*2); +float t4720 = mod(t4718,t4719); +float t4721 = (t4720-3.1415927); +float t4722 = (3.1415927/t2024); +float t4723 = (t3047*t4722); +float t4724 = (t4689*float(97372.83)); +float t4725 = fract(t4724); +float t4726 = (t4725-float(0.5)); +float t4727 = (3.1415927/t2024); +float t4728 = (t4726*t4727); +float t4729 = (t4728*float(0.75)); +float t4730 = (t4723+t4729); +float t4731 = (t4730+3.1415927); +float t4732 = mod(t4731,t1433); +float t4733 = (t4732-3.1415927); +float t4734 = (t4733+3.1415927); +float t4735 = (3.1415927*2); +float t4736 = mod(t4734,t4735); +float t4737 = (t4736-3.1415927); +float t4738 = (t4721-t4737); +float t4739 = abs(t4738); +float t4740 = (t4739/2); +float t4741 = sin(t4740); +float t4742 = (t4741*t4741); +float t4743 = (t4705*t4742); +float t4744 = (t4702+t4743); +float t4745 = sqrt(t4744); +float t4746 = asin(t4745); +float t4747 = (2*t4746); +float t4748 = (3.1415927/2); +float t4749 = (t8-t4748); +float t4750 = (3.1415927/2); +float t4751 = (t4695-t4750); +float t4752 = (t4749-t4751); +float t4753 = abs(t4752); +float t4754 = (t4753/2); +float t4755 = sin(t4754); +float t4756 = (t4755*t4755); +float t4757 = cos(t4751); +float t4758 = cos(t4749); +float t4759 = (t4757*t4758); +float t4760 = (t118+3.1415927); +float t4761 = (3.1415927*2); +float t4762 = mod(t4760,t4761); +float t4763 = (t4762-3.1415927); +float t4764 = (t4733+3.1415927); +float t4765 = (3.1415927*2); +float t4766 = mod(t4764,t4765); +float t4767 = (t4766-3.1415927); +float t4768 = (t4763-t4767); +float t4769 = abs(t4768); +float t4770 = (t4769/2); +float t4771 = sin(t4770); +float t4772 = (t4771*t4771); +float t4773 = (t4759*t4772); +float t4774 = (t4756+t4773); +float t4775 = sqrt(t4774); +float t4776 = asin(t4775); +float t4777 = (2*t4776); +float t4778 = (t4747-t4777); +float t4779 = (3.1415927/2); +float t4780 = (t8-t4779); +float t4781 = (3.1415927/2); +float t4782 = (t4669-t4781); +float t4783 = (t4780-t4782); +float t4784 = abs(t4783); +float t4785 = (t4784/2); +float t4786 = sin(t4785); +float t4787 = (t4786*t4786); +float t4788 = cos(t4782); +float t4789 = cos(t4780); +float t4790 = (t4788*t4789); +float t4791 = (t118+3.1415927); +float t4792 = (3.1415927*2); +float t4793 = mod(t4791,t4792); +float t4794 = (t4793-3.1415927); +float t4795 = (t4717+3.1415927); +float t4796 = (3.1415927*2); +float t4797 = mod(t4795,t4796); +float t4798 = (t4797-3.1415927); +float t4799 = (t4794-t4798); +float t4800 = abs(t4799); +float t4801 = (t4800/2); +float t4802 = sin(t4801); +float t4803 = (t4802*t4802); +float t4804 = (t4790*t4803); +float t4805 = (t4787+t4804); +float t4806 = sqrt(t4805); +float t4807 = asin(t4806); +float t4808 = (2*t4807); +float t4809 = (t4778-t4808); +float t4810 = abs(t4809); +bool t4811 = (float(1.0e-4)>t4810); +float t4812; +if(t4811){ +float t4813 = cos(t4695); +float t4814 = (1*t4813); +float t4815 = sin(t4669); +float t4816 = (1*t4815); +float t4817 = cos(t4717); +float t4818 = (t4816*t4817); +float t4819 = (t4814*t4818); +float t4820 = sin(t4695); +float t4821 = (1*t4820); +float t4822 = cos(t4733); +float t4823 = (t4821*t4822); +float t4824 = cos(t4669); +float t4825 = (1*t4824); +float t4826 = (t4823*t4825); +float t4827 = (t4819-t4826); +float t4828 = sin(t8); +float t4829 = (1*t4828); +float t4830 = sin(t118); +float t4831 = (t4829*t4830); +float t4832 = (t4827*t4831); +float t4833 = sin(t4669); +float t4834 = (1*t4833); +float t4835 = sin(t4717); +float t4836 = (t4834*t4835); +float t4837 = (t4823*t4836); +float t4838 = sin(t4695); +float t4839 = (1*t4838); +float t4840 = sin(t4733); +float t4841 = (t4839*t4840); +float t4842 = (t4841*t4818); +float t4843 = (t4837-t4842); +float t4844 = cos(t8); +float t4845 = (1*t4844); +float t4846 = (t4843*t4845); +float t4847 = (t4832+t4846); +float t4848 = (t4841*t4825); +float t4849 = (t4814*t4836); +float t4850 = (t4848-t4849); +float t4851 = sin(t8); +float t4852 = (1*t4851); +float t4853 = cos(t118); +float t4854 = (t4852*t4853); +float t4855 = (t4850*t4854); +float t4856 = (t4847+t4855); +float t4857 = abs(t4856); +t4812 = t4857; +} else { +float t4858 = (3.1415927/2); +float t4859 = (t8-t4858); +float t4860 = (3.1415927/2); +float t4861 = (t4669-t4860); +float t4862 = (t4859-t4861); +float t4863 = abs(t4862); +float t4864 = (t4863/2); +float t4865 = sin(t4864); +float t4866 = (t4865*t4865); +float t4867 = cos(t4861); +float t4868 = cos(t4859); +float t4869 = (t4867*t4868); +float t4870 = (t118+3.1415927); +float t4871 = (3.1415927*2); +float t4872 = mod(t4870,t4871); +float t4873 = (t4872-3.1415927); +float t4874 = (t4717+3.1415927); +float t4875 = (3.1415927*2); +float t4876 = mod(t4874,t4875); +float t4877 = (t4876-3.1415927); +float t4878 = (t4873-t4877); +float t4879 = abs(t4878); +float t4880 = (t4879/2); +float t4881 = sin(t4880); +float t4882 = (t4881*t4881); +float t4883 = (t4869*t4882); +float t4884 = (t4866+t4883); +float t4885 = sqrt(t4884); +float t4886 = asin(t4885); +float t4887 = (2*t4886); +float t4888 = abs(t4887); +float t4889 = (3.1415927/2); +float t4890 = (t8-t4889); +float t4891 = (3.1415927/2); +float t4892 = (t4695-t4891); +float t4893 = (t4890-t4892); +float t4894 = abs(t4893); +float t4895 = (t4894/2); +float t4896 = sin(t4895); +float t4897 = (t4896*t4896); +float t4898 = cos(t4892); +float t4899 = cos(t4890); +float t4900 = (t4898*t4899); +float t4901 = (t118+3.1415927); +float t4902 = (3.1415927*2); +float t4903 = mod(t4901,t4902); +float t4904 = (t4903-3.1415927); +float t4905 = (t4733+3.1415927); +float t4906 = (3.1415927*2); +float t4907 = mod(t4905,t4906); +float t4908 = (t4907-3.1415927); +float t4909 = (t4904-t4908); +float t4910 = abs(t4909); +float t4911 = (t4910/2); +float t4912 = sin(t4911); +float t4913 = (t4912*t4912); +float t4914 = (t4900*t4913); +float t4915 = (t4897+t4914); +float t4916 = sqrt(t4915); +float t4917 = asin(t4916); +float t4918 = (2*t4917); +float t4919 = abs(t4918); +bool t4920 = (t4888>=t4919); +float t4921; +if(t4920){ +t4921 = t4888; +} else { +t4921 = t4919; +} +t4812 = t4921; +} +float t4922 = abs(t4812); +float t4923 = step(float(2.0e-4),t4922); +float t4924 = (1-t4923); +float t4925 = (t2011*t4652); +float t4926 = (t4925*float(842.378)); +float t4927 = fract(t4926); +float t4928 = (t4927+float(45.32)); +float t4929 = (t4928+u6.u0); +float t4930 = (t4927*t4929); +float t4931 = (t3047*t1346); +float t4932 = (t4931*float(1734.048)); +float t4933 = fract(t4932); +float t4934 = (t4933+float(45.32)); +float t4935 = (t4934+u6.u0); +float t4936 = (t4933*t4935); +float t4937 = (t4930+t4936); +float t4938 = (t4927+t4937); +float t4939 = (t4933+t4937); +float t4940 = (t4938*t4939); +float t4941 = fract(t4940); +float t4942 = step(float(0.2),t4941); +float t4943 = (t4924*t4942); +float t4944 = (3.1415927/2); +float t4945 = (t4669-t4944); +float t4946 = (3.1415927/2); +float t4947 = (t4695-t4946); +float t4948 = (t4945-t4947); +float t4949 = abs(t4948); +float t4950 = (t4949/2); +float t4951 = sin(t4950); +float t4952 = (t4951*t4951); +float t4953 = cos(t4947); +float t4954 = cos(t4945); +float t4955 = (t4953*t4954); +float t4956 = (t4717+3.1415927); +float t4957 = (3.1415927*2); +float t4958 = mod(t4956,t4957); +float t4959 = (t4958-3.1415927); +float t4960 = (t4733+3.1415927); +float t4961 = (3.1415927*2); +float t4962 = mod(t4960,t4961); +float t4963 = (t4962-3.1415927); +float t4964 = (t4959-t4963); +float t4965 = abs(t4964); +float t4966 = (t4965/2); +float t4967 = sin(t4966); +float t4968 = (t4967*t4967); +float t4969 = (t4955*t4968); +float t4970 = (t4952+t4969); +float t4971 = sqrt(t4970); +float t4972 = asin(t4971); +float t4973 = (2*t4972); +float t4974 = (t4973/t1344); +float t4975 = (1-t4974); +float t4976 = (t2011/36); +float t4977 = (t4976*float(842.378)); +float t4978 = fract(t4977); +float t4979 = (t4978+float(45.32)); +float t4980 = (t4979+u6.u0); +float t4981 = (t4978*t4980); +float t4982 = (t3047/t2024); +float t4983 = (t4982*float(1734.048)); +float t4984 = fract(t4983); +float t4985 = (t4984+float(45.32)); +float t4986 = (t4985+u6.u0); +float t4987 = (t4984*t4986); +float t4988 = (t4981+t4987); +float t4989 = (t4978+t4988); +float t4990 = (t4984+t4988); +float t4991 = (t4989*t4990); +float t4992 = fract(t4991); +float t4993 = (t4992*float(8.0e-3)); +float t4994 = (float(1.0e-3)+t4993); +float t4995 = (t4992*173); +float t4996 = fract(t4995); +float t4997 = step(float(0.66),t4996); +float t4998 = (t4997*float(3.0e-3)); +float t4999 = (t4994-t4998); +float t5000 = (t4999*float(0.8)); +float t5001 = (t1346/36); +float t5002 = (t5001*float(842.378)); +float t5003 = fract(t5002); +float t5004 = (t5003+float(45.32)); +float t5005 = (t5004+u6.u0); +float t5006 = (t5003*t5005); +float t5007 = (t4652/t2024); +float t5008 = (t5007*float(1734.048)); +float t5009 = fract(t5008); +float t5010 = (t5009+float(45.32)); +float t5011 = (t5010+u6.u0); +float t5012 = (t5009*t5011); +float t5013 = (t5006+t5012); +float t5014 = (t5003+t5013); +float t5015 = (t5009+t5013); +float t5016 = (t5014*t5015); +float t5017 = fract(t5016); +float t5018 = (t5017*float(8.0e-3)); +float t5019 = (float(1.0e-3)+t5018); +float t5020 = (t5017*173); +float t5021 = fract(t5020); +float t5022 = step(float(0.66),t5021); +float t5023 = (t5022*float(3.0e-3)); +float t5024 = (t5019-t5023); +float t5025 = (t5024*float(0.8)); +float t5026 = (t5000-t5025); +float t5027 = abs(t5026); +float t5028 = (t5027-float(1.0e-3)); +float t5029 = (t5028/float(8.0e-3)); +float t5030 = (1-t5029); +float t5031 = (t5030*t5030); +float t5032 = (t4975*t5031); +float t5033 = (t4943*t5032); +float t5034 = (u4.u0*t4941); +float t5035 = (t5034*3); +float t5036 = sin(t5035); +float t5037 = (t5036+1); +float t5038 = (t5037/2); +float t5039 = (t5038*float(0.66)); +float t5040 = (t5039+float(0.33)); +float t5041 = (t5033*t5040); +float t5042 = (float(0.2)*t5041); +bool t5043 = (0>=t5042); +float t5044; +if(t5043){ +t5044 = 0; +} else { +t5044 = t5042; +} +float t5045 = (t5044*1); +float t5046 = (t4644+t5045); +float t5047 = (t1346*t1344); +float t5048 = (t1346/36); +float t5049 = (t5048*float(842.378)); +float t5050 = fract(t5049); +float t5051 = (t5050+float(45.32)); +float t5052 = (t5051+u6.u0); +float t5053 = (t5050*t5052); +float t5054 = (t4652/t2024); +float t5055 = (t5054*float(1734.048)); +float t5056 = fract(t5055); +float t5057 = (t5056+float(45.32)); +float t5058 = (t5057+u6.u0); +float t5059 = (t5056*t5058); +float t5060 = (t5053+t5059); +float t5061 = (t5050+t5060); +float t5062 = (t5056+t5060); +float t5063 = (t5061*t5062); +float t5064 = fract(t5063); +float t5065 = (t5064*float(2852.02)); +float t5066 = fract(t5065); +float t5067 = (t5066-float(0.5)); +float t5068 = (t5067*t1344); +float t5069 = (t5068*float(0.75)); +float t5070 = (t5047+t5069); +float t5071 = (3.1415927/2); +float t5072 = (t5070-t5071); +float t5073 = (t1346*t1344); +float t5074 = (t1346/36); +float t5075 = (t5074*float(842.378)); +float t5076 = fract(t5075); +float t5077 = (t5076+float(45.32)); +float t5078 = (t5077+u6.u0); +float t5079 = (t5076*t5078); +float t5080 = (t1800/t1359); +float t5081 = (t5080*float(1734.048)); +float t5082 = fract(t5081); +float t5083 = (t5082+float(45.32)); +float t5084 = (t5083+u6.u0); +float t5085 = (t5082*t5084); +float t5086 = (t5079+t5085); +float t5087 = (t5076+t5086); +float t5088 = (t5082+t5086); +float t5089 = (t5087*t5088); +float t5090 = fract(t5089); +float t5091 = (t5090*float(2852.02)); +float t5092 = fract(t5091); +float t5093 = (t5092-float(0.5)); +float t5094 = (t5093*t1344); +float t5095 = (t5094*float(0.75)); +float t5096 = (t5073+t5095); +float t5097 = (3.1415927/2); +float t5098 = (t5096-t5097); +float t5099 = (t5072-t5098); +float t5100 = abs(t5099); +float t5101 = (t5100/2); +float t5102 = sin(t5101); +float t5103 = (t5102*t5102); +float t5104 = cos(t5098); +float t5105 = cos(t5072); +float t5106 = (t5104*t5105); +float t5107 = (3.1415927/t2024); +float t5108 = (t4652*t5107); +float t5109 = (t5064*float(97372.83)); +float t5110 = fract(t5109); +float t5111 = (t5110-float(0.5)); +float t5112 = (3.1415927/t2024); +float t5113 = (t5111*t5112); +float t5114 = (t5113*float(0.75)); +float t5115 = (t5108+t5114); +float t5116 = (t5115+3.1415927); +float t5117 = mod(t5116,t1433); +float t5118 = (t5117-3.1415927); +float t5119 = (t5118+3.1415927); +float t5120 = (3.1415927*2); +float t5121 = mod(t5119,t5120); +float t5122 = (t5121-3.1415927); +float t5123 = (3.1415927/t1359); +float t5124 = (t1800*t5123); +float t5125 = (t5090*float(97372.83)); +float t5126 = fract(t5125); +float t5127 = (t5126-float(0.5)); +float t5128 = (3.1415927/t1359); +float t5129 = (t5127*t5128); +float t5130 = (t5129*float(0.75)); +float t5131 = (t5124+t5130); +float t5132 = (t5131+3.1415927); +float t5133 = mod(t5132,t1433); +float t5134 = (t5133-3.1415927); +float t5135 = (t5134+3.1415927); +float t5136 = (3.1415927*2); +float t5137 = mod(t5135,t5136); +float t5138 = (t5137-3.1415927); +float t5139 = (t5122-t5138); +float t5140 = abs(t5139); +float t5141 = (t5140/2); +float t5142 = sin(t5141); +float t5143 = (t5142*t5142); +float t5144 = (t5106*t5143); +float t5145 = (t5103+t5144); +float t5146 = sqrt(t5145); +float t5147 = asin(t5146); +float t5148 = (2*t5147); +float t5149 = (3.1415927/2); +float t5150 = (t8-t5149); +float t5151 = (3.1415927/2); +float t5152 = (t5096-t5151); +float t5153 = (t5150-t5152); +float t5154 = abs(t5153); +float t5155 = (t5154/2); +float t5156 = sin(t5155); +float t5157 = (t5156*t5156); +float t5158 = cos(t5152); +float t5159 = cos(t5150); +float t5160 = (t5158*t5159); +float t5161 = (t118+3.1415927); +float t5162 = (3.1415927*2); +float t5163 = mod(t5161,t5162); +float t5164 = (t5163-3.1415927); +float t5165 = (t5134+3.1415927); +float t5166 = (3.1415927*2); +float t5167 = mod(t5165,t5166); +float t5168 = (t5167-3.1415927); +float t5169 = (t5164-t5168); +float t5170 = abs(t5169); +float t5171 = (t5170/2); +float t5172 = sin(t5171); +float t5173 = (t5172*t5172); +float t5174 = (t5160*t5173); +float t5175 = (t5157+t5174); +float t5176 = sqrt(t5175); +float t5177 = asin(t5176); +float t5178 = (2*t5177); +float t5179 = (t5148-t5178); +float t5180 = (3.1415927/2); +float t5181 = (t8-t5180); +float t5182 = (3.1415927/2); +float t5183 = (t5070-t5182); +float t5184 = (t5181-t5183); +float t5185 = abs(t5184); +float t5186 = (t5185/2); +float t5187 = sin(t5186); +float t5188 = (t5187*t5187); +float t5189 = cos(t5183); +float t5190 = cos(t5181); +float t5191 = (t5189*t5190); +float t5192 = (t118+3.1415927); +float t5193 = (3.1415927*2); +float t5194 = mod(t5192,t5193); +float t5195 = (t5194-3.1415927); +float t5196 = (t5118+3.1415927); +float t5197 = (3.1415927*2); +float t5198 = mod(t5196,t5197); +float t5199 = (t5198-3.1415927); +float t5200 = (t5195-t5199); +float t5201 = abs(t5200); +float t5202 = (t5201/2); +float t5203 = sin(t5202); +float t5204 = (t5203*t5203); +float t5205 = (t5191*t5204); +float t5206 = (t5188+t5205); +float t5207 = sqrt(t5206); +float t5208 = asin(t5207); +float t5209 = (2*t5208); +float t5210 = (t5179-t5209); +float t5211 = abs(t5210); +bool t5212 = (float(1.0e-4)>t5211); +float t5213; +if(t5212){ +float t5214 = cos(t5096); +float t5215 = (1*t5214); +float t5216 = sin(t5070); +float t5217 = (1*t5216); +float t5218 = cos(t5118); +float t5219 = (t5217*t5218); +float t5220 = (t5215*t5219); +float t5221 = sin(t5096); +float t5222 = (1*t5221); +float t5223 = cos(t5134); +float t5224 = (t5222*t5223); +float t5225 = cos(t5070); +float t5226 = (1*t5225); +float t5227 = (t5224*t5226); +float t5228 = (t5220-t5227); +float t5229 = sin(t8); +float t5230 = (1*t5229); +float t5231 = sin(t118); +float t5232 = (t5230*t5231); +float t5233 = (t5228*t5232); +float t5234 = sin(t5070); +float t5235 = (1*t5234); +float t5236 = sin(t5118); +float t5237 = (t5235*t5236); +float t5238 = (t5224*t5237); +float t5239 = sin(t5096); +float t5240 = (1*t5239); +float t5241 = sin(t5134); +float t5242 = (t5240*t5241); +float t5243 = (t5242*t5219); +float t5244 = (t5238-t5243); +float t5245 = cos(t8); +float t5246 = (1*t5245); +float t5247 = (t5244*t5246); +float t5248 = (t5233+t5247); +float t5249 = (t5242*t5226); +float t5250 = (t5215*t5237); +float t5251 = (t5249-t5250); +float t5252 = sin(t8); +float t5253 = (1*t5252); +float t5254 = cos(t118); +float t5255 = (t5253*t5254); +float t5256 = (t5251*t5255); +float t5257 = (t5248+t5256); +float t5258 = abs(t5257); +t5213 = t5258; +} else { +float t5259 = (3.1415927/2); +float t5260 = (t8-t5259); +float t5261 = (3.1415927/2); +float t5262 = (t5070-t5261); +float t5263 = (t5260-t5262); +float t5264 = abs(t5263); +float t5265 = (t5264/2); +float t5266 = sin(t5265); +float t5267 = (t5266*t5266); +float t5268 = cos(t5262); +float t5269 = cos(t5260); +float t5270 = (t5268*t5269); +float t5271 = (t118+3.1415927); +float t5272 = (3.1415927*2); +float t5273 = mod(t5271,t5272); +float t5274 = (t5273-3.1415927); +float t5275 = (t5118+3.1415927); +float t5276 = (3.1415927*2); +float t5277 = mod(t5275,t5276); +float t5278 = (t5277-3.1415927); +float t5279 = (t5274-t5278); +float t5280 = abs(t5279); +float t5281 = (t5280/2); +float t5282 = sin(t5281); +float t5283 = (t5282*t5282); +float t5284 = (t5270*t5283); +float t5285 = (t5267+t5284); +float t5286 = sqrt(t5285); +float t5287 = asin(t5286); +float t5288 = (2*t5287); +float t5289 = abs(t5288); +float t5290 = (3.1415927/2); +float t5291 = (t8-t5290); +float t5292 = (3.1415927/2); +float t5293 = (t5096-t5292); +float t5294 = (t5291-t5293); +float t5295 = abs(t5294); +float t5296 = (t5295/2); +float t5297 = sin(t5296); +float t5298 = (t5297*t5297); +float t5299 = cos(t5293); +float t5300 = cos(t5291); +float t5301 = (t5299*t5300); +float t5302 = (t118+3.1415927); +float t5303 = (3.1415927*2); +float t5304 = mod(t5302,t5303); +float t5305 = (t5304-3.1415927); +float t5306 = (t5134+3.1415927); +float t5307 = (3.1415927*2); +float t5308 = mod(t5306,t5307); +float t5309 = (t5308-3.1415927); +float t5310 = (t5305-t5309); +float t5311 = abs(t5310); +float t5312 = (t5311/2); +float t5313 = sin(t5312); +float t5314 = (t5313*t5313); +float t5315 = (t5301*t5314); +float t5316 = (t5298+t5315); +float t5317 = sqrt(t5316); +float t5318 = asin(t5317); +float t5319 = (2*t5318); +float t5320 = abs(t5319); +bool t5321 = (t5289>=t5320); +float t5322; +if(t5321){ +t5322 = t5289; +} else { +t5322 = t5320; +} +t5213 = t5322; +} +float t5323 = abs(t5213); +float t5324 = step(float(2.0e-4),t5323); +float t5325 = (1-t5324); +float t5326 = (t1346*t4652); +float t5327 = (t5326*float(842.378)); +float t5328 = fract(t5327); +float t5329 = (t5328+float(45.32)); +float t5330 = (t5329+u6.u0); +float t5331 = (t5328*t5330); +float t5332 = (t1800*t1346); +float t5333 = (t5332*float(1734.048)); +float t5334 = fract(t5333); +float t5335 = (t5334+float(45.32)); +float t5336 = (t5335+u6.u0); +float t5337 = (t5334*t5336); +float t5338 = (t5331+t5337); +float t5339 = (t5328+t5338); +float t5340 = (t5334+t5338); +float t5341 = (t5339*t5340); +float t5342 = fract(t5341); +float t5343 = step(float(0.2),t5342); +float t5344 = (t5325*t5343); +float t5345 = (3.1415927/2); +float t5346 = (t5070-t5345); +float t5347 = (3.1415927/2); +float t5348 = (t5096-t5347); +float t5349 = (t5346-t5348); +float t5350 = abs(t5349); +float t5351 = (t5350/2); +float t5352 = sin(t5351); +float t5353 = (t5352*t5352); +float t5354 = cos(t5348); +float t5355 = cos(t5346); +float t5356 = (t5354*t5355); +float t5357 = (t5118+3.1415927); +float t5358 = (3.1415927*2); +float t5359 = mod(t5357,t5358); +float t5360 = (t5359-3.1415927); +float t5361 = (t5134+3.1415927); +float t5362 = (3.1415927*2); +float t5363 = mod(t5361,t5362); +float t5364 = (t5363-3.1415927); +float t5365 = (t5360-t5364); +float t5366 = abs(t5365); +float t5367 = (t5366/2); +float t5368 = sin(t5367); +float t5369 = (t5368*t5368); +float t5370 = (t5356*t5369); +float t5371 = (t5353+t5370); +float t5372 = sqrt(t5371); +float t5373 = asin(t5372); +float t5374 = (2*t5373); +float t5375 = (t5374/t1344); +float t5376 = (1-t5375); +float t5377 = (t1346/36); +float t5378 = (t5377*float(842.378)); +float t5379 = fract(t5378); +float t5380 = (t5379+float(45.32)); +float t5381 = (t5380+u6.u0); +float t5382 = (t5379*t5381); +float t5383 = (t1800/t1359); +float t5384 = (t5383*float(1734.048)); +float t5385 = fract(t5384); +float t5386 = (t5385+float(45.32)); +float t5387 = (t5386+u6.u0); +float t5388 = (t5385*t5387); +float t5389 = (t5382+t5388); +float t5390 = (t5379+t5389); +float t5391 = (t5385+t5389); +float t5392 = (t5390*t5391); +float t5393 = fract(t5392); +float t5394 = (t5393*float(8.0e-3)); +float t5395 = (float(1.0e-3)+t5394); +float t5396 = (t5393*173); +float t5397 = fract(t5396); +float t5398 = step(float(0.66),t5397); +float t5399 = (t5398*float(3.0e-3)); +float t5400 = (t5395-t5399); +float t5401 = (t5400*float(0.8)); +float t5402 = (t1346/36); +float t5403 = (t5402*float(842.378)); +float t5404 = fract(t5403); +float t5405 = (t5404+float(45.32)); +float t5406 = (t5405+u6.u0); +float t5407 = (t5404*t5406); +float t5408 = (t4652/t2024); +float t5409 = (t5408*float(1734.048)); +float t5410 = fract(t5409); +float t5411 = (t5410+float(45.32)); +float t5412 = (t5411+u6.u0); +float t5413 = (t5410*t5412); +float t5414 = (t5407+t5413); +float t5415 = (t5404+t5414); +float t5416 = (t5410+t5414); +float t5417 = (t5415*t5416); +float t5418 = fract(t5417); +float t5419 = (t5418*float(8.0e-3)); +float t5420 = (float(1.0e-3)+t5419); +float t5421 = (t5418*173); +float t5422 = fract(t5421); +float t5423 = step(float(0.66),t5422); +float t5424 = (t5423*float(3.0e-3)); +float t5425 = (t5420-t5424); +float t5426 = (t5425*float(0.8)); +float t5427 = (t5401-t5426); +float t5428 = abs(t5427); +float t5429 = (t5428-float(1.0e-3)); +float t5430 = (t5429/float(8.0e-3)); +float t5431 = (1-t5430); +float t5432 = (t5431*t5431); +float t5433 = (t5376*t5432); +float t5434 = (t5344*t5433); +float t5435 = (u4.u0*t5342); +float t5436 = (t5435*3); +float t5437 = sin(t5436); +float t5438 = (t5437+1); +float t5439 = (t5438/2); +float t5440 = (t5439*float(0.66)); +float t5441 = (t5440+float(0.33)); +float t5442 = (t5434*t5441); +float t5443 = (float(0.2)*t5442); +bool t5444 = (0>=t5443); +float t5445; +if(t5444){ +t5445 = 0; +} else { +t5445 = t5443; +} +float t5446 = (t5445*1); +float t5447 = (t5046+t5446); +float t5448 = (3.1415927/85); +float t5449 = (t8/t5448); +float t5450 = floor(t5449); +float t5451 = (t5450/85); +float t5452 = (t5450/85); +float t5453 = (t5452*float(842.378)); +float t5454 = fract(t5453); +float t5455 = (t5454+float(45.32)); +float t5456 = (t5455+u6.u0); +float t5457 = (t5454*t5456); +float t5458 = (t5450/85); +float t5459 = (t5458*3.1415927); +float t5460 = sin(t5459); +float t5461 = (85*t5460); +float t5462 = floor(t5461); +float t5463 = (t5462+1); +float t5464 = (3.1415927/t5463); +float t5465 = (t118/t5464); +float t5466 = floor(t5465); +float t5467 = (t5466/t5463); +float t5468 = (t5467*float(1734.048)); +float t5469 = fract(t5468); +float t5470 = (t5469+float(45.32)); +float t5471 = (t5470+u6.u0); +float t5472 = (t5469*t5471); +float t5473 = (t5457+t5472); +float t5474 = (t5454+t5473); +float t5475 = (t5469+t5473); +float t5476 = (t5474*t5475); +float t5477 = fract(t5476); +float t5478 = (t5477*5); +float t5479 = (t5451+t5478); +float t5480 = fract(t5479); +float t5481 = (t5480*12000); +float t5482 = (t5481/1000); +bool t5483 = (1<=t5482); +float t5484; +if(t5483){ +t5484 = 1; +} else { +t5484 = t5482; +} +float t5485 = (t5481-6000); +float t5486 = (t5485/8000); +bool t5487 = (0>=t5486); +float t5488; +if(t5487){ +t5488 = 0; +} else { +t5488 = t5486; +} +float t5489 = (t5484-t5488); +float t5490 = (t5477*173); +float t5491 = fract(t5490); +float t5492 = step(float(0.66),t5491); +float t5493 = (t5492*3); +float t5494 = (3+t5493); +float t5495 = (3.1415927/t5494); +float t5496 = cos(t5495); +float t5497 = (1-t5496); +float t5498 = (t5450*t5448); +float t5499 = (t5450/85); +float t5500 = (t5499*float(842.378)); +float t5501 = fract(t5500); +float t5502 = (t5501+float(45.32)); +float t5503 = (t5502+u6.u0); +float t5504 = (t5501*t5503); +float t5505 = (t5466/t5463); +float t5506 = (t5505*float(1734.048)); +float t5507 = fract(t5506); +float t5508 = (t5507+float(45.32)); +float t5509 = (t5508+u6.u0); +float t5510 = (t5507*t5509); +float t5511 = (t5504+t5510); +float t5512 = (t5501+t5511); +float t5513 = (t5507+t5511); +float t5514 = (t5512*t5513); +float t5515 = fract(t5514); +float t5516 = (t5515*float(2852.02)); +float t5517 = fract(t5516); +float t5518 = (t5517-float(0.5)); +float t5519 = (t5518*t5448); +float t5520 = (t5519*float(0.75)); +float t5521 = (t5498+t5520); +float t5522 = cos(t5521); +float t5523 = (1*t5522); +float t5524 = (t5523*0); +float t5525 = sin(t5521); +float t5526 = (1*t5525); +float t5527 = (3.1415927/t5463); +float t5528 = (t5466*t5527); +float t5529 = (t5515*float(97372.83)); +float t5530 = fract(t5529); +float t5531 = (t5530-float(0.5)); +float t5532 = (3.1415927/t5463); +float t5533 = (t5531*t5532); +float t5534 = (t5533*float(0.75)); +float t5535 = (t5528+t5534); +float t5536 = (t5535+3.1415927); +float t5537 = mod(t5536,t1433); +float t5538 = (t5537-3.1415927); +float t5539 = cos(t5538); +float t5540 = (t5526*t5539); +float t5541 = (t5540*1); +float t5542 = (t5524-t5541); +float t5543 = sin(t8); +float t5544 = (1*t5543); +float t5545 = sin(t118); +float t5546 = (t5544*t5545); +float t5547 = (t5542*t5546); +float t5548 = (t5540*0); +float t5549 = sin(t5521); +float t5550 = (1*t5549); +float t5551 = sin(t5538); +float t5552 = (t5550*t5551); +float t5553 = (t5552*0); +float t5554 = (t5548-t5553); +float t5555 = cos(t8); +float t5556 = (1*t5555); +float t5557 = (t5554*t5556); +float t5558 = (t5547+t5557); +float t5559 = (t5552*1); +float t5560 = (t5523*0); +float t5561 = (t5559-t5560); +float t5562 = sin(t8); +float t5563 = (1*t5562); +float t5564 = cos(t118); +float t5565 = (t5563*t5564); +float t5566 = (t5561*t5565); +float t5567 = (t5558+t5566); +float t5568 = (t5554*t5540); +float t5569 = (t5561*t5523); +float t5570 = (t5568-t5569); +float t5571 = (t5570*t5546); +float t5572 = (t5561*t5552); +float t5573 = (t5542*t5540); +float t5574 = (t5572-t5573); +float t5575 = (t5574*t5556); +float t5576 = (t5571+t5575); +float t5577 = (t5542*t5523); +float t5578 = (t5554*t5552); +float t5579 = (t5577-t5578); +float t5580 = (t5579*t5565); +float t5581 = (t5576+t5580); +float t5582 = atan(t5567,t5581); +float t5583 = (t5582+3.1415927); +float t5584 = (t5491*3.1415927); +float t5585 = (t5583+t5584); +float t5586 = (t5585/t1483); +float t5587 = fract(t5586); +float t5588 = (t5587*t5494); +float t5589 = fract(t5588); +float t5590 = (t5589*2); +float t5591 = (t5590-1); +float t5592 = abs(t5591); +float t5593 = (t5592*t5592); +float t5594 = (t5497*t5593); +float t5595 = (t5496+t5594); +float t5596 = (t5477*float(8.0e-3)); +float t5597 = (float(1.0e-3)+t5596); +float t5598 = step(float(0.66),t5491); +float t5599 = (t5598*float(3.0e-3)); +float t5600 = (t5597-t5599); +float t5601 = (t5600*float(0.45)); +float t5602 = (t5595*t5601); +float t5603 = (3.1415927/2); +float t5604 = (t5521-t5603); +float t5605 = (3.1415927/2); +float t5606 = (t8-t5605); +float t5607 = (t5604-t5606); +float t5608 = abs(t5607); +float t5609 = (t5608/2); +float t5610 = sin(t5609); +float t5611 = (t5610*t5610); +float t5612 = cos(t5606); +float t5613 = cos(t5604); +float t5614 = (t5612*t5613); +float t5615 = (t5538+3.1415927); +float t5616 = (3.1415927*2); +float t5617 = mod(t5615,t5616); +float t5618 = (t5617-3.1415927); +float t5619 = (t118+3.1415927); +float t5620 = (3.1415927*2); +float t5621 = mod(t5619,t5620); +float t5622 = (t5621-3.1415927); +float t5623 = (t5618-t5622); +float t5624 = abs(t5623); +float t5625 = (t5624/2); +float t5626 = sin(t5625); +float t5627 = (t5626*t5626); +float t5628 = (t5614*t5627); +float t5629 = (t5611+t5628); +float t5630 = sqrt(t5629); +float t5631 = asin(t5630); +float t5632 = (2*t5631); +float t5633 = step(t5602,t5632); +float t5634 = (1-t5633); +float t5635 = (t5489*t5634); +float t5636 = (3.1415927/2); +float t5637 = (t8-t5636); +float t5638 = (3.1415927/2); +float t5639 = (t5521-t5638); +float t5640 = (t5637-t5639); +float t5641 = abs(t5640); +float t5642 = (t5641/2); +float t5643 = sin(t5642); +float t5644 = (t5643*t5643); +float t5645 = cos(t5639); +float t5646 = cos(t5637); +float t5647 = (t5645*t5646); +float t5648 = (t118+3.1415927); +float t5649 = (3.1415927*2); +float t5650 = mod(t5648,t5649); +float t5651 = (t5650-3.1415927); +float t5652 = (t5538+3.1415927); +float t5653 = (3.1415927*2); +float t5654 = mod(t5652,t5653); +float t5655 = (t5654-3.1415927); +float t5656 = (t5651-t5655); +float t5657 = abs(t5656); +float t5658 = (t5657/2); +float t5659 = sin(t5658); +float t5660 = (t5659*t5659); +float t5661 = (t5647*t5660); +float t5662 = (t5644+t5661); +float t5663 = sqrt(t5662); +float t5664 = asin(t5663); +float t5665 = (2*t5664); +float t5666 = (1/t5665); +float t5667 = (t5666*t5601); +float t5668 = (t5667*float(1.25e-2)); +float t5669 = (u4.u0*t5477); +float t5670 = cos(t5669); +float t5671 = (t5670+1); +float t5672 = (t5671/2); +float t5673 = (t5668*t5672); +float t5674 = (t5673*t5489); +float t5675 = (t5635+t5674); +float t5676 = (0+t5675); +float t5677 = (t5450/85); +float t5678 = (t5450/85); +float t5679 = (t5678*float(842.378)); +float t5680 = fract(t5679); +float t5681 = (t5680+float(45.32)); +float t5682 = (t5681+u6.u0); +float t5683 = (t5680*t5682); +float t5684 = (t5466+1); +float t5685 = (t5684/t5463); +float t5686 = (t5685*float(1734.048)); +float t5687 = fract(t5686); +float t5688 = (t5687+float(45.32)); +float t5689 = (t5688+u6.u0); +float t5690 = (t5687*t5689); +float t5691 = (t5683+t5690); +float t5692 = (t5680+t5691); +float t5693 = (t5687+t5691); +float t5694 = (t5692*t5693); +float t5695 = fract(t5694); +float t5696 = (t5695*5); +float t5697 = (t5677+t5696); +float t5698 = fract(t5697); +float t5699 = (t5698*12000); +float t5700 = (t5699/1000); +bool t5701 = (1<=t5700); +float t5702; +if(t5701){ +t5702 = 1; +} else { +t5702 = t5700; +} +float t5703 = (t5699-6000); +float t5704 = (t5703/8000); +bool t5705 = (0>=t5704); +float t5706; +if(t5705){ +t5706 = 0; +} else { +t5706 = t5704; +} +float t5707 = (t5702-t5706); +float t5708 = (t5695*173); +float t5709 = fract(t5708); +float t5710 = step(float(0.66),t5709); +float t5711 = (t5710*3); +float t5712 = (3+t5711); +float t5713 = (3.1415927/t5712); +float t5714 = cos(t5713); +float t5715 = (1-t5714); +float t5716 = (t5450*t5448); +float t5717 = (t5450/85); +float t5718 = (t5717*float(842.378)); +float t5719 = fract(t5718); +float t5720 = (t5719+float(45.32)); +float t5721 = (t5720+u6.u0); +float t5722 = (t5719*t5721); +float t5723 = (t5684/t5463); +float t5724 = (t5723*float(1734.048)); +float t5725 = fract(t5724); +float t5726 = (t5725+float(45.32)); +float t5727 = (t5726+u6.u0); +float t5728 = (t5725*t5727); +float t5729 = (t5722+t5728); +float t5730 = (t5719+t5729); +float t5731 = (t5725+t5729); +float t5732 = (t5730*t5731); +float t5733 = fract(t5732); +float t5734 = (t5733*float(2852.02)); +float t5735 = fract(t5734); +float t5736 = (t5735-float(0.5)); +float t5737 = (t5736*t5448); +float t5738 = (t5737*float(0.75)); +float t5739 = (t5716+t5738); +float t5740 = cos(t5739); +float t5741 = (1*t5740); +float t5742 = (t5741*0); +float t5743 = sin(t5739); +float t5744 = (1*t5743); +float t5745 = (3.1415927/t5463); +float t5746 = (t5684*t5745); +float t5747 = (t5733*float(97372.83)); +float t5748 = fract(t5747); +float t5749 = (t5748-float(0.5)); +float t5750 = (3.1415927/t5463); +float t5751 = (t5749*t5750); +float t5752 = (t5751*float(0.75)); +float t5753 = (t5746+t5752); +float t5754 = (t5753+3.1415927); +float t5755 = mod(t5754,t1433); +float t5756 = (t5755-3.1415927); +float t5757 = cos(t5756); +float t5758 = (t5744*t5757); +float t5759 = (t5758*1); +float t5760 = (t5742-t5759); +float t5761 = sin(t8); +float t5762 = (1*t5761); +float t5763 = sin(t118); +float t5764 = (t5762*t5763); +float t5765 = (t5760*t5764); +float t5766 = (t5758*0); +float t5767 = sin(t5739); +float t5768 = (1*t5767); +float t5769 = sin(t5756); +float t5770 = (t5768*t5769); +float t5771 = (t5770*0); +float t5772 = (t5766-t5771); +float t5773 = cos(t8); +float t5774 = (1*t5773); +float t5775 = (t5772*t5774); +float t5776 = (t5765+t5775); +float t5777 = (t5770*1); +float t5778 = (t5741*0); +float t5779 = (t5777-t5778); +float t5780 = sin(t8); +float t5781 = (1*t5780); +float t5782 = cos(t118); +float t5783 = (t5781*t5782); +float t5784 = (t5779*t5783); +float t5785 = (t5776+t5784); +float t5786 = (t5772*t5758); +float t5787 = (t5779*t5741); +float t5788 = (t5786-t5787); +float t5789 = (t5788*t5764); +float t5790 = (t5779*t5770); +float t5791 = (t5760*t5758); +float t5792 = (t5790-t5791); +float t5793 = (t5792*t5774); +float t5794 = (t5789+t5793); +float t5795 = (t5760*t5741); +float t5796 = (t5772*t5770); +float t5797 = (t5795-t5796); +float t5798 = (t5797*t5783); +float t5799 = (t5794+t5798); +float t5800 = atan(t5785,t5799); +float t5801 = (t5800+3.1415927); +float t5802 = (t5709*3.1415927); +float t5803 = (t5801+t5802); +float t5804 = (t5803/t1483); +float t5805 = fract(t5804); +float t5806 = (t5805*t5712); +float t5807 = fract(t5806); +float t5808 = (t5807*2); +float t5809 = (t5808-1); +float t5810 = abs(t5809); +float t5811 = (t5810*t5810); +float t5812 = (t5715*t5811); +float t5813 = (t5714+t5812); +float t5814 = (t5695*float(8.0e-3)); +float t5815 = (float(1.0e-3)+t5814); +float t5816 = step(float(0.66),t5709); +float t5817 = (t5816*float(3.0e-3)); +float t5818 = (t5815-t5817); +float t5819 = (t5818*float(0.45)); +float t5820 = (t5813*t5819); +float t5821 = (3.1415927/2); +float t5822 = (t5739-t5821); +float t5823 = (3.1415927/2); +float t5824 = (t8-t5823); +float t5825 = (t5822-t5824); +float t5826 = abs(t5825); +float t5827 = (t5826/2); +float t5828 = sin(t5827); +float t5829 = (t5828*t5828); +float t5830 = cos(t5824); +float t5831 = cos(t5822); +float t5832 = (t5830*t5831); +float t5833 = (t5756+3.1415927); +float t5834 = (3.1415927*2); +float t5835 = mod(t5833,t5834); +float t5836 = (t5835-3.1415927); +float t5837 = (t118+3.1415927); +float t5838 = (3.1415927*2); +float t5839 = mod(t5837,t5838); +float t5840 = (t5839-3.1415927); +float t5841 = (t5836-t5840); +float t5842 = abs(t5841); +float t5843 = (t5842/2); +float t5844 = sin(t5843); +float t5845 = (t5844*t5844); +float t5846 = (t5832*t5845); +float t5847 = (t5829+t5846); +float t5848 = sqrt(t5847); +float t5849 = asin(t5848); +float t5850 = (2*t5849); +float t5851 = step(t5820,t5850); +float t5852 = (1-t5851); +float t5853 = (t5707*t5852); +float t5854 = (3.1415927/2); +float t5855 = (t8-t5854); +float t5856 = (3.1415927/2); +float t5857 = (t5739-t5856); +float t5858 = (t5855-t5857); +float t5859 = abs(t5858); +float t5860 = (t5859/2); +float t5861 = sin(t5860); +float t5862 = (t5861*t5861); +float t5863 = cos(t5857); +float t5864 = cos(t5855); +float t5865 = (t5863*t5864); +float t5866 = (t118+3.1415927); +float t5867 = (3.1415927*2); +float t5868 = mod(t5866,t5867); +float t5869 = (t5868-3.1415927); +float t5870 = (t5756+3.1415927); +float t5871 = (3.1415927*2); +float t5872 = mod(t5870,t5871); +float t5873 = (t5872-3.1415927); +float t5874 = (t5869-t5873); +float t5875 = abs(t5874); +float t5876 = (t5875/2); +float t5877 = sin(t5876); +float t5878 = (t5877*t5877); +float t5879 = (t5865*t5878); +float t5880 = (t5862+t5879); +float t5881 = sqrt(t5880); +float t5882 = asin(t5881); +float t5883 = (2*t5882); +float t5884 = (1/t5883); +float t5885 = (t5884*t5819); +float t5886 = (t5885*float(1.25e-2)); +float t5887 = (u4.u0*t5695); +float t5888 = cos(t5887); +float t5889 = (t5888+1); +float t5890 = (t5889/2); +float t5891 = (t5886*t5890); +float t5892 = (t5891*t5707); +float t5893 = (t5853+t5892); +float t5894 = (t5676+t5893); +float t5895 = (t5450/85); +float t5896 = (t5450/85); +float t5897 = (t5896*float(842.378)); +float t5898 = fract(t5897); +float t5899 = (t5898+float(45.32)); +float t5900 = (t5899+u6.u0); +float t5901 = (t5898*t5900); +float t5902 = (t5466+2); +float t5903 = (t5902/t5463); +float t5904 = (t5903*float(1734.048)); +float t5905 = fract(t5904); +float t5906 = (t5905+float(45.32)); +float t5907 = (t5906+u6.u0); +float t5908 = (t5905*t5907); +float t5909 = (t5901+t5908); +float t5910 = (t5898+t5909); +float t5911 = (t5905+t5909); +float t5912 = (t5910*t5911); +float t5913 = fract(t5912); +float t5914 = (t5913*5); +float t5915 = (t5895+t5914); +float t5916 = fract(t5915); +float t5917 = (t5916*12000); +float t5918 = (t5917/1000); +bool t5919 = (1<=t5918); +float t5920; +if(t5919){ +t5920 = 1; +} else { +t5920 = t5918; +} +float t5921 = (t5917-6000); +float t5922 = (t5921/8000); +bool t5923 = (0>=t5922); +float t5924; +if(t5923){ +t5924 = 0; +} else { +t5924 = t5922; +} +float t5925 = (t5920-t5924); +float t5926 = (t5913*173); +float t5927 = fract(t5926); +float t5928 = step(float(0.66),t5927); +float t5929 = (t5928*3); +float t5930 = (3+t5929); +float t5931 = (3.1415927/t5930); +float t5932 = cos(t5931); +float t5933 = (1-t5932); +float t5934 = (t5450*t5448); +float t5935 = (t5450/85); +float t5936 = (t5935*float(842.378)); +float t5937 = fract(t5936); +float t5938 = (t5937+float(45.32)); +float t5939 = (t5938+u6.u0); +float t5940 = (t5937*t5939); +float t5941 = (t5902/t5463); +float t5942 = (t5941*float(1734.048)); +float t5943 = fract(t5942); +float t5944 = (t5943+float(45.32)); +float t5945 = (t5944+u6.u0); +float t5946 = (t5943*t5945); +float t5947 = (t5940+t5946); +float t5948 = (t5937+t5947); +float t5949 = (t5943+t5947); +float t5950 = (t5948*t5949); +float t5951 = fract(t5950); +float t5952 = (t5951*float(2852.02)); +float t5953 = fract(t5952); +float t5954 = (t5953-float(0.5)); +float t5955 = (t5954*t5448); +float t5956 = (t5955*float(0.75)); +float t5957 = (t5934+t5956); +float t5958 = cos(t5957); +float t5959 = (1*t5958); +float t5960 = (t5959*0); +float t5961 = sin(t5957); +float t5962 = (1*t5961); +float t5963 = (3.1415927/t5463); +float t5964 = (t5902*t5963); +float t5965 = (t5951*float(97372.83)); +float t5966 = fract(t5965); +float t5967 = (t5966-float(0.5)); +float t5968 = (3.1415927/t5463); +float t5969 = (t5967*t5968); +float t5970 = (t5969*float(0.75)); +float t5971 = (t5964+t5970); +float t5972 = (t5971+3.1415927); +float t5973 = mod(t5972,t1433); +float t5974 = (t5973-3.1415927); +float t5975 = cos(t5974); +float t5976 = (t5962*t5975); +float t5977 = (t5976*1); +float t5978 = (t5960-t5977); +float t5979 = sin(t8); +float t5980 = (1*t5979); +float t5981 = sin(t118); +float t5982 = (t5980*t5981); +float t5983 = (t5978*t5982); +float t5984 = (t5976*0); +float t5985 = sin(t5957); +float t5986 = (1*t5985); +float t5987 = sin(t5974); +float t5988 = (t5986*t5987); +float t5989 = (t5988*0); +float t5990 = (t5984-t5989); +float t5991 = cos(t8); +float t5992 = (1*t5991); +float t5993 = (t5990*t5992); +float t5994 = (t5983+t5993); +float t5995 = (t5988*1); +float t5996 = (t5959*0); +float t5997 = (t5995-t5996); +float t5998 = sin(t8); +float t5999 = (1*t5998); +float t6000 = cos(t118); +float t6001 = (t5999*t6000); +float t6002 = (t5997*t6001); +float t6003 = (t5994+t6002); +float t6004 = (t5990*t5976); +float t6005 = (t5997*t5959); +float t6006 = (t6004-t6005); +float t6007 = (t6006*t5982); +float t6008 = (t5997*t5988); +float t6009 = (t5978*t5976); +float t6010 = (t6008-t6009); +float t6011 = (t6010*t5992); +float t6012 = (t6007+t6011); +float t6013 = (t5978*t5959); +float t6014 = (t5990*t5988); +float t6015 = (t6013-t6014); +float t6016 = (t6015*t6001); +float t6017 = (t6012+t6016); +float t6018 = atan(t6003,t6017); +float t6019 = (t6018+3.1415927); +float t6020 = (t5927*3.1415927); +float t6021 = (t6019+t6020); +float t6022 = (t6021/t1483); +float t6023 = fract(t6022); +float t6024 = (t6023*t5930); +float t6025 = fract(t6024); +float t6026 = (t6025*2); +float t6027 = (t6026-1); +float t6028 = abs(t6027); +float t6029 = (t6028*t6028); +float t6030 = (t5933*t6029); +float t6031 = (t5932+t6030); +float t6032 = (t5913*float(8.0e-3)); +float t6033 = (float(1.0e-3)+t6032); +float t6034 = step(float(0.66),t5927); +float t6035 = (t6034*float(3.0e-3)); +float t6036 = (t6033-t6035); +float t6037 = (t6036*float(0.45)); +float t6038 = (t6031*t6037); +float t6039 = (3.1415927/2); +float t6040 = (t5957-t6039); +float t6041 = (3.1415927/2); +float t6042 = (t8-t6041); +float t6043 = (t6040-t6042); +float t6044 = abs(t6043); +float t6045 = (t6044/2); +float t6046 = sin(t6045); +float t6047 = (t6046*t6046); +float t6048 = cos(t6042); +float t6049 = cos(t6040); +float t6050 = (t6048*t6049); +float t6051 = (t5974+3.1415927); +float t6052 = (3.1415927*2); +float t6053 = mod(t6051,t6052); +float t6054 = (t6053-3.1415927); +float t6055 = (t118+3.1415927); +float t6056 = (3.1415927*2); +float t6057 = mod(t6055,t6056); +float t6058 = (t6057-3.1415927); +float t6059 = (t6054-t6058); +float t6060 = abs(t6059); +float t6061 = (t6060/2); +float t6062 = sin(t6061); +float t6063 = (t6062*t6062); +float t6064 = (t6050*t6063); +float t6065 = (t6047+t6064); +float t6066 = sqrt(t6065); +float t6067 = asin(t6066); +float t6068 = (2*t6067); +float t6069 = step(t6038,t6068); +float t6070 = (1-t6069); +float t6071 = (t5925*t6070); +float t6072 = (3.1415927/2); +float t6073 = (t8-t6072); +float t6074 = (3.1415927/2); +float t6075 = (t5957-t6074); +float t6076 = (t6073-t6075); +float t6077 = abs(t6076); +float t6078 = (t6077/2); +float t6079 = sin(t6078); +float t6080 = (t6079*t6079); +float t6081 = cos(t6075); +float t6082 = cos(t6073); +float t6083 = (t6081*t6082); +float t6084 = (t118+3.1415927); +float t6085 = (3.1415927*2); +float t6086 = mod(t6084,t6085); +float t6087 = (t6086-3.1415927); +float t6088 = (t5974+3.1415927); +float t6089 = (3.1415927*2); +float t6090 = mod(t6088,t6089); +float t6091 = (t6090-3.1415927); +float t6092 = (t6087-t6091); +float t6093 = abs(t6092); +float t6094 = (t6093/2); +float t6095 = sin(t6094); +float t6096 = (t6095*t6095); +float t6097 = (t6083*t6096); +float t6098 = (t6080+t6097); +float t6099 = sqrt(t6098); +float t6100 = asin(t6099); +float t6101 = (2*t6100); +float t6102 = (1/t6101); +float t6103 = (t6102*t6037); +float t6104 = (t6103*float(1.25e-2)); +float t6105 = (u4.u0*t5913); +float t6106 = cos(t6105); +float t6107 = (t6106+1); +float t6108 = (t6107/2); +float t6109 = (t6104*t6108); +float t6110 = (t6109*t5925); +float t6111 = (t6071+t6110); +float t6112 = (t5894+t6111); +float t6113 = (t5450+1); +float t6114 = (t6113/85); +float t6115 = (t6113/85); +float t6116 = (t6115*float(842.378)); +float t6117 = fract(t6116); +float t6118 = (t6117+float(45.32)); +float t6119 = (t6118+u6.u0); +float t6120 = (t6117*t6119); +float t6121 = (t6113/85); +float t6122 = (t6121*3.1415927); +float t6123 = sin(t6122); +float t6124 = (85*t6123); +float t6125 = floor(t6124); +float t6126 = (t6125+1); +float t6127 = (3.1415927/t6126); +float t6128 = (t118/t6127); +float t6129 = floor(t6128); +float t6130 = (t6129/t6126); +float t6131 = (t6130*float(1734.048)); +float t6132 = fract(t6131); +float t6133 = (t6132+float(45.32)); +float t6134 = (t6133+u6.u0); +float t6135 = (t6132*t6134); +float t6136 = (t6120+t6135); +float t6137 = (t6117+t6136); +float t6138 = (t6132+t6136); +float t6139 = (t6137*t6138); +float t6140 = fract(t6139); +float t6141 = (t6140*5); +float t6142 = (t6114+t6141); +float t6143 = fract(t6142); +float t6144 = (t6143*12000); +float t6145 = (t6144/1000); +bool t6146 = (1<=t6145); +float t6147; +if(t6146){ +t6147 = 1; +} else { +t6147 = t6145; +} +float t6148 = (t6144-6000); +float t6149 = (t6148/8000); +bool t6150 = (0>=t6149); +float t6151; +if(t6150){ +t6151 = 0; +} else { +t6151 = t6149; +} +float t6152 = (t6147-t6151); +float t6153 = (t6140*173); +float t6154 = fract(t6153); +float t6155 = step(float(0.66),t6154); +float t6156 = (t6155*3); +float t6157 = (3+t6156); +float t6158 = (3.1415927/t6157); +float t6159 = cos(t6158); +float t6160 = (1-t6159); +float t6161 = (t6113*t5448); +float t6162 = (t6113/85); +float t6163 = (t6162*float(842.378)); +float t6164 = fract(t6163); +float t6165 = (t6164+float(45.32)); +float t6166 = (t6165+u6.u0); +float t6167 = (t6164*t6166); +float t6168 = (t6129/t6126); +float t6169 = (t6168*float(1734.048)); +float t6170 = fract(t6169); +float t6171 = (t6170+float(45.32)); +float t6172 = (t6171+u6.u0); +float t6173 = (t6170*t6172); +float t6174 = (t6167+t6173); +float t6175 = (t6164+t6174); +float t6176 = (t6170+t6174); +float t6177 = (t6175*t6176); +float t6178 = fract(t6177); +float t6179 = (t6178*float(2852.02)); +float t6180 = fract(t6179); +float t6181 = (t6180-float(0.5)); +float t6182 = (t6181*t5448); +float t6183 = (t6182*float(0.75)); +float t6184 = (t6161+t6183); +float t6185 = cos(t6184); +float t6186 = (1*t6185); +float t6187 = (t6186*0); +float t6188 = sin(t6184); +float t6189 = (1*t6188); +float t6190 = (3.1415927/t6126); +float t6191 = (t6129*t6190); +float t6192 = (t6178*float(97372.83)); +float t6193 = fract(t6192); +float t6194 = (t6193-float(0.5)); +float t6195 = (3.1415927/t6126); +float t6196 = (t6194*t6195); +float t6197 = (t6196*float(0.75)); +float t6198 = (t6191+t6197); +float t6199 = (t6198+3.1415927); +float t6200 = mod(t6199,t1433); +float t6201 = (t6200-3.1415927); +float t6202 = cos(t6201); +float t6203 = (t6189*t6202); +float t6204 = (t6203*1); +float t6205 = (t6187-t6204); +float t6206 = sin(t8); +float t6207 = (1*t6206); +float t6208 = sin(t118); +float t6209 = (t6207*t6208); +float t6210 = (t6205*t6209); +float t6211 = (t6203*0); +float t6212 = sin(t6184); +float t6213 = (1*t6212); +float t6214 = sin(t6201); +float t6215 = (t6213*t6214); +float t6216 = (t6215*0); +float t6217 = (t6211-t6216); +float t6218 = cos(t8); +float t6219 = (1*t6218); +float t6220 = (t6217*t6219); +float t6221 = (t6210+t6220); +float t6222 = (t6215*1); +float t6223 = (t6186*0); +float t6224 = (t6222-t6223); +float t6225 = sin(t8); +float t6226 = (1*t6225); +float t6227 = cos(t118); +float t6228 = (t6226*t6227); +float t6229 = (t6224*t6228); +float t6230 = (t6221+t6229); +float t6231 = (t6217*t6203); +float t6232 = (t6224*t6186); +float t6233 = (t6231-t6232); +float t6234 = (t6233*t6209); +float t6235 = (t6224*t6215); +float t6236 = (t6205*t6203); +float t6237 = (t6235-t6236); +float t6238 = (t6237*t6219); +float t6239 = (t6234+t6238); +float t6240 = (t6205*t6186); +float t6241 = (t6217*t6215); +float t6242 = (t6240-t6241); +float t6243 = (t6242*t6228); +float t6244 = (t6239+t6243); +float t6245 = atan(t6230,t6244); +float t6246 = (t6245+3.1415927); +float t6247 = (t6154*3.1415927); +float t6248 = (t6246+t6247); +float t6249 = (t6248/t1483); +float t6250 = fract(t6249); +float t6251 = (t6250*t6157); +float t6252 = fract(t6251); +float t6253 = (t6252*2); +float t6254 = (t6253-1); +float t6255 = abs(t6254); +float t6256 = (t6255*t6255); +float t6257 = (t6160*t6256); +float t6258 = (t6159+t6257); +float t6259 = (t6140*float(8.0e-3)); +float t6260 = (float(1.0e-3)+t6259); +float t6261 = step(float(0.66),t6154); +float t6262 = (t6261*float(3.0e-3)); +float t6263 = (t6260-t6262); +float t6264 = (t6263*float(0.45)); +float t6265 = (t6258*t6264); +float t6266 = (3.1415927/2); +float t6267 = (t6184-t6266); +float t6268 = (3.1415927/2); +float t6269 = (t8-t6268); +float t6270 = (t6267-t6269); +float t6271 = abs(t6270); +float t6272 = (t6271/2); +float t6273 = sin(t6272); +float t6274 = (t6273*t6273); +float t6275 = cos(t6269); +float t6276 = cos(t6267); +float t6277 = (t6275*t6276); +float t6278 = (t6201+3.1415927); +float t6279 = (3.1415927*2); +float t6280 = mod(t6278,t6279); +float t6281 = (t6280-3.1415927); +float t6282 = (t118+3.1415927); +float t6283 = (3.1415927*2); +float t6284 = mod(t6282,t6283); +float t6285 = (t6284-3.1415927); +float t6286 = (t6281-t6285); +float t6287 = abs(t6286); +float t6288 = (t6287/2); +float t6289 = sin(t6288); +float t6290 = (t6289*t6289); +float t6291 = (t6277*t6290); +float t6292 = (t6274+t6291); +float t6293 = sqrt(t6292); +float t6294 = asin(t6293); +float t6295 = (2*t6294); +float t6296 = step(t6265,t6295); +float t6297 = (1-t6296); +float t6298 = (t6152*t6297); +float t6299 = (3.1415927/2); +float t6300 = (t8-t6299); +float t6301 = (3.1415927/2); +float t6302 = (t6184-t6301); +float t6303 = (t6300-t6302); +float t6304 = abs(t6303); +float t6305 = (t6304/2); +float t6306 = sin(t6305); +float t6307 = (t6306*t6306); +float t6308 = cos(t6302); +float t6309 = cos(t6300); +float t6310 = (t6308*t6309); +float t6311 = (t118+3.1415927); +float t6312 = (3.1415927*2); +float t6313 = mod(t6311,t6312); +float t6314 = (t6313-3.1415927); +float t6315 = (t6201+3.1415927); +float t6316 = (3.1415927*2); +float t6317 = mod(t6315,t6316); +float t6318 = (t6317-3.1415927); +float t6319 = (t6314-t6318); +float t6320 = abs(t6319); +float t6321 = (t6320/2); +float t6322 = sin(t6321); +float t6323 = (t6322*t6322); +float t6324 = (t6310*t6323); +float t6325 = (t6307+t6324); +float t6326 = sqrt(t6325); +float t6327 = asin(t6326); +float t6328 = (2*t6327); +float t6329 = (1/t6328); +float t6330 = (t6329*t6264); +float t6331 = (t6330*float(1.25e-2)); +float t6332 = (u4.u0*t6140); +float t6333 = cos(t6332); +float t6334 = (t6333+1); +float t6335 = (t6334/2); +float t6336 = (t6331*t6335); +float t6337 = (t6336*t6152); +float t6338 = (t6298+t6337); +float t6339 = (t6112+t6338); +float t6340 = (t5450*t5448); +float t6341 = (t5450/85); +float t6342 = (t6341*float(842.378)); +float t6343 = fract(t6342); +float t6344 = (t6343+float(45.32)); +float t6345 = (t6344+u6.u0); +float t6346 = (t6343*t6345); +float t6347 = (t5684/t5463); +float t6348 = (t6347*float(1734.048)); +float t6349 = fract(t6348); +float t6350 = (t6349+float(45.32)); +float t6351 = (t6350+u6.u0); +float t6352 = (t6349*t6351); +float t6353 = (t6346+t6352); +float t6354 = (t6343+t6353); +float t6355 = (t6349+t6353); +float t6356 = (t6354*t6355); +float t6357 = fract(t6356); +float t6358 = (t6357*float(2852.02)); +float t6359 = fract(t6358); +float t6360 = (t6359-float(0.5)); +float t6361 = (t6360*t5448); +float t6362 = (t6361*float(0.75)); +float t6363 = (t6340+t6362); +float t6364 = (3.1415927/2); +float t6365 = (t6363-t6364); +float t6366 = (t5450*t5448); +float t6367 = (t5450/85); +float t6368 = (t6367*float(842.378)); +float t6369 = fract(t6368); +float t6370 = (t6369+float(45.32)); +float t6371 = (t6370+u6.u0); +float t6372 = (t6369*t6371); +float t6373 = (t5466/t5463); +float t6374 = (t6373*float(1734.048)); +float t6375 = fract(t6374); +float t6376 = (t6375+float(45.32)); +float t6377 = (t6376+u6.u0); +float t6378 = (t6375*t6377); +float t6379 = (t6372+t6378); +float t6380 = (t6369+t6379); +float t6381 = (t6375+t6379); +float t6382 = (t6380*t6381); +float t6383 = fract(t6382); +float t6384 = (t6383*float(2852.02)); +float t6385 = fract(t6384); +float t6386 = (t6385-float(0.5)); +float t6387 = (t6386*t5448); +float t6388 = (t6387*float(0.75)); +float t6389 = (t6366+t6388); +float t6390 = (3.1415927/2); +float t6391 = (t6389-t6390); +float t6392 = (t6365-t6391); +float t6393 = abs(t6392); +float t6394 = (t6393/2); +float t6395 = sin(t6394); +float t6396 = (t6395*t6395); +float t6397 = cos(t6391); +float t6398 = cos(t6365); +float t6399 = (t6397*t6398); +float t6400 = (3.1415927/t5463); +float t6401 = (t5684*t6400); +float t6402 = (t6357*float(97372.83)); +float t6403 = fract(t6402); +float t6404 = (t6403-float(0.5)); +float t6405 = (3.1415927/t5463); +float t6406 = (t6404*t6405); +float t6407 = (t6406*float(0.75)); +float t6408 = (t6401+t6407); +float t6409 = (t6408+3.1415927); +float t6410 = mod(t6409,t1433); +float t6411 = (t6410-3.1415927); +float t6412 = (t6411+3.1415927); +float t6413 = (3.1415927*2); +float t6414 = mod(t6412,t6413); +float t6415 = (t6414-3.1415927); +float t6416 = (3.1415927/t5463); +float t6417 = (t5466*t6416); +float t6418 = (t6383*float(97372.83)); +float t6419 = fract(t6418); +float t6420 = (t6419-float(0.5)); +float t6421 = (3.1415927/t5463); +float t6422 = (t6420*t6421); +float t6423 = (t6422*float(0.75)); +float t6424 = (t6417+t6423); +float t6425 = (t6424+3.1415927); +float t6426 = mod(t6425,t1433); +float t6427 = (t6426-3.1415927); +float t6428 = (t6427+3.1415927); +float t6429 = (3.1415927*2); +float t6430 = mod(t6428,t6429); +float t6431 = (t6430-3.1415927); +float t6432 = (t6415-t6431); +float t6433 = abs(t6432); +float t6434 = (t6433/2); +float t6435 = sin(t6434); +float t6436 = (t6435*t6435); +float t6437 = (t6399*t6436); +float t6438 = (t6396+t6437); +float t6439 = sqrt(t6438); +float t6440 = asin(t6439); +float t6441 = (2*t6440); +float t6442 = (3.1415927/2); +float t6443 = (t8-t6442); +float t6444 = (3.1415927/2); +float t6445 = (t6389-t6444); +float t6446 = (t6443-t6445); +float t6447 = abs(t6446); +float t6448 = (t6447/2); +float t6449 = sin(t6448); +float t6450 = (t6449*t6449); +float t6451 = cos(t6445); +float t6452 = cos(t6443); +float t6453 = (t6451*t6452); +float t6454 = (t118+3.1415927); +float t6455 = (3.1415927*2); +float t6456 = mod(t6454,t6455); +float t6457 = (t6456-3.1415927); +float t6458 = (t6427+3.1415927); +float t6459 = (3.1415927*2); +float t6460 = mod(t6458,t6459); +float t6461 = (t6460-3.1415927); +float t6462 = (t6457-t6461); +float t6463 = abs(t6462); +float t6464 = (t6463/2); +float t6465 = sin(t6464); +float t6466 = (t6465*t6465); +float t6467 = (t6453*t6466); +float t6468 = (t6450+t6467); +float t6469 = sqrt(t6468); +float t6470 = asin(t6469); +float t6471 = (2*t6470); +float t6472 = (t6441-t6471); +float t6473 = (3.1415927/2); +float t6474 = (t8-t6473); +float t6475 = (3.1415927/2); +float t6476 = (t6363-t6475); +float t6477 = (t6474-t6476); +float t6478 = abs(t6477); +float t6479 = (t6478/2); +float t6480 = sin(t6479); +float t6481 = (t6480*t6480); +float t6482 = cos(t6476); +float t6483 = cos(t6474); +float t6484 = (t6482*t6483); +float t6485 = (t118+3.1415927); +float t6486 = (3.1415927*2); +float t6487 = mod(t6485,t6486); +float t6488 = (t6487-3.1415927); +float t6489 = (t6411+3.1415927); +float t6490 = (3.1415927*2); +float t6491 = mod(t6489,t6490); +float t6492 = (t6491-3.1415927); +float t6493 = (t6488-t6492); +float t6494 = abs(t6493); +float t6495 = (t6494/2); +float t6496 = sin(t6495); +float t6497 = (t6496*t6496); +float t6498 = (t6484*t6497); +float t6499 = (t6481+t6498); +float t6500 = sqrt(t6499); +float t6501 = asin(t6500); +float t6502 = (2*t6501); +float t6503 = (t6472-t6502); +float t6504 = abs(t6503); +bool t6505 = (float(1.0e-4)>t6504); +float t6506; +if(t6505){ +float t6507 = cos(t6389); +float t6508 = (1*t6507); +float t6509 = sin(t6363); +float t6510 = (1*t6509); +float t6511 = cos(t6411); +float t6512 = (t6510*t6511); +float t6513 = (t6508*t6512); +float t6514 = sin(t6389); +float t6515 = (1*t6514); +float t6516 = cos(t6427); +float t6517 = (t6515*t6516); +float t6518 = cos(t6363); +float t6519 = (1*t6518); +float t6520 = (t6517*t6519); +float t6521 = (t6513-t6520); +float t6522 = sin(t8); +float t6523 = (1*t6522); +float t6524 = sin(t118); +float t6525 = (t6523*t6524); +float t6526 = (t6521*t6525); +float t6527 = sin(t6363); +float t6528 = (1*t6527); +float t6529 = sin(t6411); +float t6530 = (t6528*t6529); +float t6531 = (t6517*t6530); +float t6532 = sin(t6389); +float t6533 = (1*t6532); +float t6534 = sin(t6427); +float t6535 = (t6533*t6534); +float t6536 = (t6535*t6512); +float t6537 = (t6531-t6536); +float t6538 = cos(t8); +float t6539 = (1*t6538); +float t6540 = (t6537*t6539); +float t6541 = (t6526+t6540); +float t6542 = (t6535*t6519); +float t6543 = (t6508*t6530); +float t6544 = (t6542-t6543); +float t6545 = sin(t8); +float t6546 = (1*t6545); +float t6547 = cos(t118); +float t6548 = (t6546*t6547); +float t6549 = (t6544*t6548); +float t6550 = (t6541+t6549); +float t6551 = abs(t6550); +t6506 = t6551; +} else { +float t6552 = (3.1415927/2); +float t6553 = (t8-t6552); +float t6554 = (3.1415927/2); +float t6555 = (t6363-t6554); +float t6556 = (t6553-t6555); +float t6557 = abs(t6556); +float t6558 = (t6557/2); +float t6559 = sin(t6558); +float t6560 = (t6559*t6559); +float t6561 = cos(t6555); +float t6562 = cos(t6553); +float t6563 = (t6561*t6562); +float t6564 = (t118+3.1415927); +float t6565 = (3.1415927*2); +float t6566 = mod(t6564,t6565); +float t6567 = (t6566-3.1415927); +float t6568 = (t6411+3.1415927); +float t6569 = (3.1415927*2); +float t6570 = mod(t6568,t6569); +float t6571 = (t6570-3.1415927); +float t6572 = (t6567-t6571); +float t6573 = abs(t6572); +float t6574 = (t6573/2); +float t6575 = sin(t6574); +float t6576 = (t6575*t6575); +float t6577 = (t6563*t6576); +float t6578 = (t6560+t6577); +float t6579 = sqrt(t6578); +float t6580 = asin(t6579); +float t6581 = (2*t6580); +float t6582 = abs(t6581); +float t6583 = (3.1415927/2); +float t6584 = (t8-t6583); +float t6585 = (3.1415927/2); +float t6586 = (t6389-t6585); +float t6587 = (t6584-t6586); +float t6588 = abs(t6587); +float t6589 = (t6588/2); +float t6590 = sin(t6589); +float t6591 = (t6590*t6590); +float t6592 = cos(t6586); +float t6593 = cos(t6584); +float t6594 = (t6592*t6593); +float t6595 = (t118+3.1415927); +float t6596 = (3.1415927*2); +float t6597 = mod(t6595,t6596); +float t6598 = (t6597-3.1415927); +float t6599 = (t6427+3.1415927); +float t6600 = (3.1415927*2); +float t6601 = mod(t6599,t6600); +float t6602 = (t6601-3.1415927); +float t6603 = (t6598-t6602); +float t6604 = abs(t6603); +float t6605 = (t6604/2); +float t6606 = sin(t6605); +float t6607 = (t6606*t6606); +float t6608 = (t6594*t6607); +float t6609 = (t6591+t6608); +float t6610 = sqrt(t6609); +float t6611 = asin(t6610); +float t6612 = (2*t6611); +float t6613 = abs(t6612); +bool t6614 = (t6582>=t6613); +float t6615; +if(t6614){ +t6615 = t6582; +} else { +t6615 = t6613; +} +t6506 = t6615; +} +float t6616 = abs(t6506); +float t6617 = step(float(2.0e-4),t6616); +float t6618 = (1-t6617); +float t6619 = (t5450*t5684); +float t6620 = (t6619*float(842.378)); +float t6621 = fract(t6620); +float t6622 = (t6621+float(45.32)); +float t6623 = (t6622+u6.u0); +float t6624 = (t6621*t6623); +float t6625 = (t5466*t5450); +float t6626 = (t6625*float(1734.048)); +float t6627 = fract(t6626); +float t6628 = (t6627+float(45.32)); +float t6629 = (t6628+u6.u0); +float t6630 = (t6627*t6629); +float t6631 = (t6624+t6630); +float t6632 = (t6621+t6631); +float t6633 = (t6627+t6631); +float t6634 = (t6632*t6633); +float t6635 = fract(t6634); +float t6636 = step(float(0.2),t6635); +float t6637 = (t6618*t6636); +float t6638 = (3.1415927/2); +float t6639 = (t6363-t6638); +float t6640 = (3.1415927/2); +float t6641 = (t6389-t6640); +float t6642 = (t6639-t6641); +float t6643 = abs(t6642); +float t6644 = (t6643/2); +float t6645 = sin(t6644); +float t6646 = (t6645*t6645); +float t6647 = cos(t6641); +float t6648 = cos(t6639); +float t6649 = (t6647*t6648); +float t6650 = (t6411+3.1415927); +float t6651 = (3.1415927*2); +float t6652 = mod(t6650,t6651); +float t6653 = (t6652-3.1415927); +float t6654 = (t6427+3.1415927); +float t6655 = (3.1415927*2); +float t6656 = mod(t6654,t6655); +float t6657 = (t6656-3.1415927); +float t6658 = (t6653-t6657); +float t6659 = abs(t6658); +float t6660 = (t6659/2); +float t6661 = sin(t6660); +float t6662 = (t6661*t6661); +float t6663 = (t6649*t6662); +float t6664 = (t6646+t6663); +float t6665 = sqrt(t6664); +float t6666 = asin(t6665); +float t6667 = (2*t6666); +float t6668 = (t6667/t5448); +float t6669 = (1-t6668); +float t6670 = (t5450/85); +float t6671 = (t6670*float(842.378)); +float t6672 = fract(t6671); +float t6673 = (t6672+float(45.32)); +float t6674 = (t6673+u6.u0); +float t6675 = (t6672*t6674); +float t6676 = (t5466/t5463); +float t6677 = (t6676*float(1734.048)); +float t6678 = fract(t6677); +float t6679 = (t6678+float(45.32)); +float t6680 = (t6679+u6.u0); +float t6681 = (t6678*t6680); +float t6682 = (t6675+t6681); +float t6683 = (t6672+t6682); +float t6684 = (t6678+t6682); +float t6685 = (t6683*t6684); +float t6686 = fract(t6685); +float t6687 = (t6686*float(8.0e-3)); +float t6688 = (float(1.0e-3)+t6687); +float t6689 = (t6686*173); +float t6690 = fract(t6689); +float t6691 = step(float(0.66),t6690); +float t6692 = (t6691*float(3.0e-3)); +float t6693 = (t6688-t6692); +float t6694 = (t6693*float(0.45)); +float t6695 = (t5450/85); +float t6696 = (t6695*float(842.378)); +float t6697 = fract(t6696); +float t6698 = (t6697+float(45.32)); +float t6699 = (t6698+u6.u0); +float t6700 = (t6697*t6699); +float t6701 = (t5684/t5463); +float t6702 = (t6701*float(1734.048)); +float t6703 = fract(t6702); +float t6704 = (t6703+float(45.32)); +float t6705 = (t6704+u6.u0); +float t6706 = (t6703*t6705); +float t6707 = (t6700+t6706); +float t6708 = (t6697+t6707); +float t6709 = (t6703+t6707); +float t6710 = (t6708*t6709); +float t6711 = fract(t6710); +float t6712 = (t6711*float(8.0e-3)); +float t6713 = (float(1.0e-3)+t6712); +float t6714 = (t6711*173); +float t6715 = fract(t6714); +float t6716 = step(float(0.66),t6715); +float t6717 = (t6716*float(3.0e-3)); +float t6718 = (t6713-t6717); +float t6719 = (t6718*float(0.45)); +float t6720 = (t6694-t6719); +float t6721 = abs(t6720); +float t6722 = (t6721-float(1.0e-3)); +float t6723 = (t6722/float(8.0e-3)); +float t6724 = (1-t6723); +float t6725 = (t6724*t6724); +float t6726 = (t6669*t6725); +float t6727 = (t6637*t6726); +float t6728 = (u4.u0*t6635); +float t6729 = (t6728*3); +float t6730 = sin(t6729); +float t6731 = (t6730+1); +float t6732 = (t6731/2); +float t6733 = (t6732*float(0.66)); +float t6734 = (t6733+float(0.33)); +float t6735 = (t6727*t6734); +float t6736 = (float(0.2)*t6735); +bool t6737 = (0>=t6736); +float t6738; +if(t6737){ +t6738 = 0; +} else { +t6738 = t6736; +} +float t6739 = (t6738*0); +float t6740 = (t6339+t6739); +float t6741 = (t6113*t5448); +float t6742 = (t6113/85); +float t6743 = (t6742*float(842.378)); +float t6744 = fract(t6743); +float t6745 = (t6744+float(45.32)); +float t6746 = (t6745+u6.u0); +float t6747 = (t6744*t6746); +float t6748 = (t6129/t6126); +float t6749 = (t6748*float(1734.048)); +float t6750 = fract(t6749); +float t6751 = (t6750+float(45.32)); +float t6752 = (t6751+u6.u0); +float t6753 = (t6750*t6752); +float t6754 = (t6747+t6753); +float t6755 = (t6744+t6754); +float t6756 = (t6750+t6754); +float t6757 = (t6755*t6756); +float t6758 = fract(t6757); +float t6759 = (t6758*float(2852.02)); +float t6760 = fract(t6759); +float t6761 = (t6760-float(0.5)); +float t6762 = (t6761*t5448); +float t6763 = (t6762*float(0.75)); +float t6764 = (t6741+t6763); +float t6765 = (3.1415927/2); +float t6766 = (t6764-t6765); +float t6767 = (t5450*t5448); +float t6768 = (t5450/85); +float t6769 = (t6768*float(842.378)); +float t6770 = fract(t6769); +float t6771 = (t6770+float(45.32)); +float t6772 = (t6771+u6.u0); +float t6773 = (t6770*t6772); +float t6774 = (t5466/t5463); +float t6775 = (t6774*float(1734.048)); +float t6776 = fract(t6775); +float t6777 = (t6776+float(45.32)); +float t6778 = (t6777+u6.u0); +float t6779 = (t6776*t6778); +float t6780 = (t6773+t6779); +float t6781 = (t6770+t6780); +float t6782 = (t6776+t6780); +float t6783 = (t6781*t6782); +float t6784 = fract(t6783); +float t6785 = (t6784*float(2852.02)); +float t6786 = fract(t6785); +float t6787 = (t6786-float(0.5)); +float t6788 = (t6787*t5448); +float t6789 = (t6788*float(0.75)); +float t6790 = (t6767+t6789); +float t6791 = (3.1415927/2); +float t6792 = (t6790-t6791); +float t6793 = (t6766-t6792); +float t6794 = abs(t6793); +float t6795 = (t6794/2); +float t6796 = sin(t6795); +float t6797 = (t6796*t6796); +float t6798 = cos(t6792); +float t6799 = cos(t6766); +float t6800 = (t6798*t6799); +float t6801 = (3.1415927/t6126); +float t6802 = (t6129*t6801); +float t6803 = (t6758*float(97372.83)); +float t6804 = fract(t6803); +float t6805 = (t6804-float(0.5)); +float t6806 = (3.1415927/t6126); +float t6807 = (t6805*t6806); +float t6808 = (t6807*float(0.75)); +float t6809 = (t6802+t6808); +float t6810 = (t6809+3.1415927); +float t6811 = mod(t6810,t1433); +float t6812 = (t6811-3.1415927); +float t6813 = (t6812+3.1415927); +float t6814 = (3.1415927*2); +float t6815 = mod(t6813,t6814); +float t6816 = (t6815-3.1415927); +float t6817 = (3.1415927/t5463); +float t6818 = (t5466*t6817); +float t6819 = (t6784*float(97372.83)); +float t6820 = fract(t6819); +float t6821 = (t6820-float(0.5)); +float t6822 = (3.1415927/t5463); +float t6823 = (t6821*t6822); +float t6824 = (t6823*float(0.75)); +float t6825 = (t6818+t6824); +float t6826 = (t6825+3.1415927); +float t6827 = mod(t6826,t1433); +float t6828 = (t6827-3.1415927); +float t6829 = (t6828+3.1415927); +float t6830 = (3.1415927*2); +float t6831 = mod(t6829,t6830); +float t6832 = (t6831-3.1415927); +float t6833 = (t6816-t6832); +float t6834 = abs(t6833); +float t6835 = (t6834/2); +float t6836 = sin(t6835); +float t6837 = (t6836*t6836); +float t6838 = (t6800*t6837); +float t6839 = (t6797+t6838); +float t6840 = sqrt(t6839); +float t6841 = asin(t6840); +float t6842 = (2*t6841); +float t6843 = (3.1415927/2); +float t6844 = (t8-t6843); +float t6845 = (3.1415927/2); +float t6846 = (t6790-t6845); +float t6847 = (t6844-t6846); +float t6848 = abs(t6847); +float t6849 = (t6848/2); +float t6850 = sin(t6849); +float t6851 = (t6850*t6850); +float t6852 = cos(t6846); +float t6853 = cos(t6844); +float t6854 = (t6852*t6853); +float t6855 = (t118+3.1415927); +float t6856 = (3.1415927*2); +float t6857 = mod(t6855,t6856); +float t6858 = (t6857-3.1415927); +float t6859 = (t6828+3.1415927); +float t6860 = (3.1415927*2); +float t6861 = mod(t6859,t6860); +float t6862 = (t6861-3.1415927); +float t6863 = (t6858-t6862); +float t6864 = abs(t6863); +float t6865 = (t6864/2); +float t6866 = sin(t6865); +float t6867 = (t6866*t6866); +float t6868 = (t6854*t6867); +float t6869 = (t6851+t6868); +float t6870 = sqrt(t6869); +float t6871 = asin(t6870); +float t6872 = (2*t6871); +float t6873 = (t6842-t6872); +float t6874 = (3.1415927/2); +float t6875 = (t8-t6874); +float t6876 = (3.1415927/2); +float t6877 = (t6764-t6876); +float t6878 = (t6875-t6877); +float t6879 = abs(t6878); +float t6880 = (t6879/2); +float t6881 = sin(t6880); +float t6882 = (t6881*t6881); +float t6883 = cos(t6877); +float t6884 = cos(t6875); +float t6885 = (t6883*t6884); +float t6886 = (t118+3.1415927); +float t6887 = (3.1415927*2); +float t6888 = mod(t6886,t6887); +float t6889 = (t6888-3.1415927); +float t6890 = (t6812+3.1415927); +float t6891 = (3.1415927*2); +float t6892 = mod(t6890,t6891); +float t6893 = (t6892-3.1415927); +float t6894 = (t6889-t6893); +float t6895 = abs(t6894); +float t6896 = (t6895/2); +float t6897 = sin(t6896); +float t6898 = (t6897*t6897); +float t6899 = (t6885*t6898); +float t6900 = (t6882+t6899); +float t6901 = sqrt(t6900); +float t6902 = asin(t6901); +float t6903 = (2*t6902); +float t6904 = (t6873-t6903); +float t6905 = abs(t6904); +bool t6906 = (float(1.0e-4)>t6905); +float t6907; +if(t6906){ +float t6908 = cos(t6790); +float t6909 = (1*t6908); +float t6910 = sin(t6764); +float t6911 = (1*t6910); +float t6912 = cos(t6812); +float t6913 = (t6911*t6912); +float t6914 = (t6909*t6913); +float t6915 = sin(t6790); +float t6916 = (1*t6915); +float t6917 = cos(t6828); +float t6918 = (t6916*t6917); +float t6919 = cos(t6764); +float t6920 = (1*t6919); +float t6921 = (t6918*t6920); +float t6922 = (t6914-t6921); +float t6923 = sin(t8); +float t6924 = (1*t6923); +float t6925 = sin(t118); +float t6926 = (t6924*t6925); +float t6927 = (t6922*t6926); +float t6928 = sin(t6764); +float t6929 = (1*t6928); +float t6930 = sin(t6812); +float t6931 = (t6929*t6930); +float t6932 = (t6918*t6931); +float t6933 = sin(t6790); +float t6934 = (1*t6933); +float t6935 = sin(t6828); +float t6936 = (t6934*t6935); +float t6937 = (t6936*t6913); +float t6938 = (t6932-t6937); +float t6939 = cos(t8); +float t6940 = (1*t6939); +float t6941 = (t6938*t6940); +float t6942 = (t6927+t6941); +float t6943 = (t6936*t6920); +float t6944 = (t6909*t6931); +float t6945 = (t6943-t6944); +float t6946 = sin(t8); +float t6947 = (1*t6946); +float t6948 = cos(t118); +float t6949 = (t6947*t6948); +float t6950 = (t6945*t6949); +float t6951 = (t6942+t6950); +float t6952 = abs(t6951); +t6907 = t6952; +} else { +float t6953 = (3.1415927/2); +float t6954 = (t8-t6953); +float t6955 = (3.1415927/2); +float t6956 = (t6764-t6955); +float t6957 = (t6954-t6956); +float t6958 = abs(t6957); +float t6959 = (t6958/2); +float t6960 = sin(t6959); +float t6961 = (t6960*t6960); +float t6962 = cos(t6956); +float t6963 = cos(t6954); +float t6964 = (t6962*t6963); +float t6965 = (t118+3.1415927); +float t6966 = (3.1415927*2); +float t6967 = mod(t6965,t6966); +float t6968 = (t6967-3.1415927); +float t6969 = (t6812+3.1415927); +float t6970 = (3.1415927*2); +float t6971 = mod(t6969,t6970); +float t6972 = (t6971-3.1415927); +float t6973 = (t6968-t6972); +float t6974 = abs(t6973); +float t6975 = (t6974/2); +float t6976 = sin(t6975); +float t6977 = (t6976*t6976); +float t6978 = (t6964*t6977); +float t6979 = (t6961+t6978); +float t6980 = sqrt(t6979); +float t6981 = asin(t6980); +float t6982 = (2*t6981); +float t6983 = abs(t6982); +float t6984 = (3.1415927/2); +float t6985 = (t8-t6984); +float t6986 = (3.1415927/2); +float t6987 = (t6790-t6986); +float t6988 = (t6985-t6987); +float t6989 = abs(t6988); +float t6990 = (t6989/2); +float t6991 = sin(t6990); +float t6992 = (t6991*t6991); +float t6993 = cos(t6987); +float t6994 = cos(t6985); +float t6995 = (t6993*t6994); +float t6996 = (t118+3.1415927); +float t6997 = (3.1415927*2); +float t6998 = mod(t6996,t6997); +float t6999 = (t6998-3.1415927); +float t7000 = (t6828+3.1415927); +float t7001 = (3.1415927*2); +float t7002 = mod(t7000,t7001); +float t7003 = (t7002-3.1415927); +float t7004 = (t6999-t7003); +float t7005 = abs(t7004); +float t7006 = (t7005/2); +float t7007 = sin(t7006); +float t7008 = (t7007*t7007); +float t7009 = (t6995*t7008); +float t7010 = (t6992+t7009); +float t7011 = sqrt(t7010); +float t7012 = asin(t7011); +float t7013 = (2*t7012); +float t7014 = abs(t7013); +bool t7015 = (t6983>=t7014); +float t7016; +if(t7015){ +t7016 = t6983; +} else { +t7016 = t7014; +} +t6907 = t7016; +} +float t7017 = abs(t6907); +float t7018 = step(float(2.0e-4),t7017); +float t7019 = (1-t7018); +float t7020 = (t5450*t6129); +float t7021 = (t7020*float(842.378)); +float t7022 = fract(t7021); +float t7023 = (t7022+float(45.32)); +float t7024 = (t7023+u6.u0); +float t7025 = (t7022*t7024); +float t7026 = (t5466*t6113); +float t7027 = (t7026*float(1734.048)); +float t7028 = fract(t7027); +float t7029 = (t7028+float(45.32)); +float t7030 = (t7029+u6.u0); +float t7031 = (t7028*t7030); +float t7032 = (t7025+t7031); +float t7033 = (t7022+t7032); +float t7034 = (t7028+t7032); +float t7035 = (t7033*t7034); +float t7036 = fract(t7035); +float t7037 = step(float(0.2),t7036); +float t7038 = (t7019*t7037); +float t7039 = (3.1415927/2); +float t7040 = (t6764-t7039); +float t7041 = (3.1415927/2); +float t7042 = (t6790-t7041); +float t7043 = (t7040-t7042); +float t7044 = abs(t7043); +float t7045 = (t7044/2); +float t7046 = sin(t7045); +float t7047 = (t7046*t7046); +float t7048 = cos(t7042); +float t7049 = cos(t7040); +float t7050 = (t7048*t7049); +float t7051 = (t6812+3.1415927); +float t7052 = (3.1415927*2); +float t7053 = mod(t7051,t7052); +float t7054 = (t7053-3.1415927); +float t7055 = (t6828+3.1415927); +float t7056 = (3.1415927*2); +float t7057 = mod(t7055,t7056); +float t7058 = (t7057-3.1415927); +float t7059 = (t7054-t7058); +float t7060 = abs(t7059); +float t7061 = (t7060/2); +float t7062 = sin(t7061); +float t7063 = (t7062*t7062); +float t7064 = (t7050*t7063); +float t7065 = (t7047+t7064); +float t7066 = sqrt(t7065); +float t7067 = asin(t7066); +float t7068 = (2*t7067); +float t7069 = (t7068/t5448); +float t7070 = (1-t7069); +float t7071 = (t5450/85); +float t7072 = (t7071*float(842.378)); +float t7073 = fract(t7072); +float t7074 = (t7073+float(45.32)); +float t7075 = (t7074+u6.u0); +float t7076 = (t7073*t7075); +float t7077 = (t5466/t5463); +float t7078 = (t7077*float(1734.048)); +float t7079 = fract(t7078); +float t7080 = (t7079+float(45.32)); +float t7081 = (t7080+u6.u0); +float t7082 = (t7079*t7081); +float t7083 = (t7076+t7082); +float t7084 = (t7073+t7083); +float t7085 = (t7079+t7083); +float t7086 = (t7084*t7085); +float t7087 = fract(t7086); +float t7088 = (t7087*float(8.0e-3)); +float t7089 = (float(1.0e-3)+t7088); +float t7090 = (t7087*173); +float t7091 = fract(t7090); +float t7092 = step(float(0.66),t7091); +float t7093 = (t7092*float(3.0e-3)); +float t7094 = (t7089-t7093); +float t7095 = (t7094*float(0.45)); +float t7096 = (t6113/85); +float t7097 = (t7096*float(842.378)); +float t7098 = fract(t7097); +float t7099 = (t7098+float(45.32)); +float t7100 = (t7099+u6.u0); +float t7101 = (t7098*t7100); +float t7102 = (t6129/t6126); +float t7103 = (t7102*float(1734.048)); +float t7104 = fract(t7103); +float t7105 = (t7104+float(45.32)); +float t7106 = (t7105+u6.u0); +float t7107 = (t7104*t7106); +float t7108 = (t7101+t7107); +float t7109 = (t7098+t7108); +float t7110 = (t7104+t7108); +float t7111 = (t7109*t7110); +float t7112 = fract(t7111); +float t7113 = (t7112*float(8.0e-3)); +float t7114 = (float(1.0e-3)+t7113); +float t7115 = (t7112*173); +float t7116 = fract(t7115); +float t7117 = step(float(0.66),t7116); +float t7118 = (t7117*float(3.0e-3)); +float t7119 = (t7114-t7118); +float t7120 = (t7119*float(0.45)); +float t7121 = (t7095-t7120); +float t7122 = abs(t7121); +float t7123 = (t7122-float(1.0e-3)); +float t7124 = (t7123/float(8.0e-3)); +float t7125 = (1-t7124); +float t7126 = (t7125*t7125); +float t7127 = (t7070*t7126); +float t7128 = (t7038*t7127); +float t7129 = (u4.u0*t7036); +float t7130 = (t7129*3); +float t7131 = sin(t7130); +float t7132 = (t7131+1); +float t7133 = (t7132/2); +float t7134 = (t7133*float(0.66)); +float t7135 = (t7134+float(0.33)); +float t7136 = (t7128*t7135); +float t7137 = (float(0.2)*t7136); +bool t7138 = (0>=t7137); +float t7139; +if(t7138){ +t7139 = 0; +} else { +t7139 = t7137; +} +float t7140 = (t7139*0); +float t7141 = (t6740+t7140); +float t7142 = (t6113*t5448); +float t7143 = (t6113/85); +float t7144 = (t7143*float(842.378)); +float t7145 = fract(t7144); +float t7146 = (t7145+float(45.32)); +float t7147 = (t7146+u6.u0); +float t7148 = (t7145*t7147); +float t7149 = (t6129+1); +float t7150 = (t7149/t6126); +float t7151 = (t7150*float(1734.048)); +float t7152 = fract(t7151); +float t7153 = (t7152+float(45.32)); +float t7154 = (t7153+u6.u0); +float t7155 = (t7152*t7154); +float t7156 = (t7148+t7155); +float t7157 = (t7145+t7156); +float t7158 = (t7152+t7156); +float t7159 = (t7157*t7158); +float t7160 = fract(t7159); +float t7161 = (t7160*float(2852.02)); +float t7162 = fract(t7161); +float t7163 = (t7162-float(0.5)); +float t7164 = (t7163*t5448); +float t7165 = (t7164*float(0.75)); +float t7166 = (t7142+t7165); +float t7167 = (3.1415927/2); +float t7168 = (t7166-t7167); +float t7169 = (t6113*t5448); +float t7170 = (t6113/85); +float t7171 = (t7170*float(842.378)); +float t7172 = fract(t7171); +float t7173 = (t7172+float(45.32)); +float t7174 = (t7173+u6.u0); +float t7175 = (t7172*t7174); +float t7176 = (t6129/t6126); +float t7177 = (t7176*float(1734.048)); +float t7178 = fract(t7177); +float t7179 = (t7178+float(45.32)); +float t7180 = (t7179+u6.u0); +float t7181 = (t7178*t7180); +float t7182 = (t7175+t7181); +float t7183 = (t7172+t7182); +float t7184 = (t7178+t7182); +float t7185 = (t7183*t7184); +float t7186 = fract(t7185); +float t7187 = (t7186*float(2852.02)); +float t7188 = fract(t7187); +float t7189 = (t7188-float(0.5)); +float t7190 = (t7189*t5448); +float t7191 = (t7190*float(0.75)); +float t7192 = (t7169+t7191); +float t7193 = (3.1415927/2); +float t7194 = (t7192-t7193); +float t7195 = (t7168-t7194); +float t7196 = abs(t7195); +float t7197 = (t7196/2); +float t7198 = sin(t7197); +float t7199 = (t7198*t7198); +float t7200 = cos(t7194); +float t7201 = cos(t7168); +float t7202 = (t7200*t7201); +float t7203 = (3.1415927/t6126); +float t7204 = (t7149*t7203); +float t7205 = (t7160*float(97372.83)); +float t7206 = fract(t7205); +float t7207 = (t7206-float(0.5)); +float t7208 = (3.1415927/t6126); +float t7209 = (t7207*t7208); +float t7210 = (t7209*float(0.75)); +float t7211 = (t7204+t7210); +float t7212 = (t7211+3.1415927); +float t7213 = mod(t7212,t1433); +float t7214 = (t7213-3.1415927); +float t7215 = (t7214+3.1415927); +float t7216 = (3.1415927*2); +float t7217 = mod(t7215,t7216); +float t7218 = (t7217-3.1415927); +float t7219 = (3.1415927/t6126); +float t7220 = (t6129*t7219); +float t7221 = (t7186*float(97372.83)); +float t7222 = fract(t7221); +float t7223 = (t7222-float(0.5)); +float t7224 = (3.1415927/t6126); +float t7225 = (t7223*t7224); +float t7226 = (t7225*float(0.75)); +float t7227 = (t7220+t7226); +float t7228 = (t7227+3.1415927); +float t7229 = mod(t7228,t1433); +float t7230 = (t7229-3.1415927); +float t7231 = (t7230+3.1415927); +float t7232 = (3.1415927*2); +float t7233 = mod(t7231,t7232); +float t7234 = (t7233-3.1415927); +float t7235 = (t7218-t7234); +float t7236 = abs(t7235); +float t7237 = (t7236/2); +float t7238 = sin(t7237); +float t7239 = (t7238*t7238); +float t7240 = (t7202*t7239); +float t7241 = (t7199+t7240); +float t7242 = sqrt(t7241); +float t7243 = asin(t7242); +float t7244 = (2*t7243); +float t7245 = (3.1415927/2); +float t7246 = (t8-t7245); +float t7247 = (3.1415927/2); +float t7248 = (t7192-t7247); +float t7249 = (t7246-t7248); +float t7250 = abs(t7249); +float t7251 = (t7250/2); +float t7252 = sin(t7251); +float t7253 = (t7252*t7252); +float t7254 = cos(t7248); +float t7255 = cos(t7246); +float t7256 = (t7254*t7255); +float t7257 = (t118+3.1415927); +float t7258 = (3.1415927*2); +float t7259 = mod(t7257,t7258); +float t7260 = (t7259-3.1415927); +float t7261 = (t7230+3.1415927); +float t7262 = (3.1415927*2); +float t7263 = mod(t7261,t7262); +float t7264 = (t7263-3.1415927); +float t7265 = (t7260-t7264); +float t7266 = abs(t7265); +float t7267 = (t7266/2); +float t7268 = sin(t7267); +float t7269 = (t7268*t7268); +float t7270 = (t7256*t7269); +float t7271 = (t7253+t7270); +float t7272 = sqrt(t7271); +float t7273 = asin(t7272); +float t7274 = (2*t7273); +float t7275 = (t7244-t7274); +float t7276 = (3.1415927/2); +float t7277 = (t8-t7276); +float t7278 = (3.1415927/2); +float t7279 = (t7166-t7278); +float t7280 = (t7277-t7279); +float t7281 = abs(t7280); +float t7282 = (t7281/2); +float t7283 = sin(t7282); +float t7284 = (t7283*t7283); +float t7285 = cos(t7279); +float t7286 = cos(t7277); +float t7287 = (t7285*t7286); +float t7288 = (t118+3.1415927); +float t7289 = (3.1415927*2); +float t7290 = mod(t7288,t7289); +float t7291 = (t7290-3.1415927); +float t7292 = (t7214+3.1415927); +float t7293 = (3.1415927*2); +float t7294 = mod(t7292,t7293); +float t7295 = (t7294-3.1415927); +float t7296 = (t7291-t7295); +float t7297 = abs(t7296); +float t7298 = (t7297/2); +float t7299 = sin(t7298); +float t7300 = (t7299*t7299); +float t7301 = (t7287*t7300); +float t7302 = (t7284+t7301); +float t7303 = sqrt(t7302); +float t7304 = asin(t7303); +float t7305 = (2*t7304); +float t7306 = (t7275-t7305); +float t7307 = abs(t7306); +bool t7308 = (float(1.0e-4)>t7307); +float t7309; +if(t7308){ +float t7310 = cos(t7192); +float t7311 = (1*t7310); +float t7312 = sin(t7166); +float t7313 = (1*t7312); +float t7314 = cos(t7214); +float t7315 = (t7313*t7314); +float t7316 = (t7311*t7315); +float t7317 = sin(t7192); +float t7318 = (1*t7317); +float t7319 = cos(t7230); +float t7320 = (t7318*t7319); +float t7321 = cos(t7166); +float t7322 = (1*t7321); +float t7323 = (t7320*t7322); +float t7324 = (t7316-t7323); +float t7325 = sin(t8); +float t7326 = (1*t7325); +float t7327 = sin(t118); +float t7328 = (t7326*t7327); +float t7329 = (t7324*t7328); +float t7330 = sin(t7166); +float t7331 = (1*t7330); +float t7332 = sin(t7214); +float t7333 = (t7331*t7332); +float t7334 = (t7320*t7333); +float t7335 = sin(t7192); +float t7336 = (1*t7335); +float t7337 = sin(t7230); +float t7338 = (t7336*t7337); +float t7339 = (t7338*t7315); +float t7340 = (t7334-t7339); +float t7341 = cos(t8); +float t7342 = (1*t7341); +float t7343 = (t7340*t7342); +float t7344 = (t7329+t7343); +float t7345 = (t7338*t7322); +float t7346 = (t7311*t7333); +float t7347 = (t7345-t7346); +float t7348 = sin(t8); +float t7349 = (1*t7348); +float t7350 = cos(t118); +float t7351 = (t7349*t7350); +float t7352 = (t7347*t7351); +float t7353 = (t7344+t7352); +float t7354 = abs(t7353); +t7309 = t7354; +} else { +float t7355 = (3.1415927/2); +float t7356 = (t8-t7355); +float t7357 = (3.1415927/2); +float t7358 = (t7166-t7357); +float t7359 = (t7356-t7358); +float t7360 = abs(t7359); +float t7361 = (t7360/2); +float t7362 = sin(t7361); +float t7363 = (t7362*t7362); +float t7364 = cos(t7358); +float t7365 = cos(t7356); +float t7366 = (t7364*t7365); +float t7367 = (t118+3.1415927); +float t7368 = (3.1415927*2); +float t7369 = mod(t7367,t7368); +float t7370 = (t7369-3.1415927); +float t7371 = (t7214+3.1415927); +float t7372 = (3.1415927*2); +float t7373 = mod(t7371,t7372); +float t7374 = (t7373-3.1415927); +float t7375 = (t7370-t7374); +float t7376 = abs(t7375); +float t7377 = (t7376/2); +float t7378 = sin(t7377); +float t7379 = (t7378*t7378); +float t7380 = (t7366*t7379); +float t7381 = (t7363+t7380); +float t7382 = sqrt(t7381); +float t7383 = asin(t7382); +float t7384 = (2*t7383); +float t7385 = abs(t7384); +float t7386 = (3.1415927/2); +float t7387 = (t8-t7386); +float t7388 = (3.1415927/2); +float t7389 = (t7192-t7388); +float t7390 = (t7387-t7389); +float t7391 = abs(t7390); +float t7392 = (t7391/2); +float t7393 = sin(t7392); +float t7394 = (t7393*t7393); +float t7395 = cos(t7389); +float t7396 = cos(t7387); +float t7397 = (t7395*t7396); +float t7398 = (t118+3.1415927); +float t7399 = (3.1415927*2); +float t7400 = mod(t7398,t7399); +float t7401 = (t7400-3.1415927); +float t7402 = (t7230+3.1415927); +float t7403 = (3.1415927*2); +float t7404 = mod(t7402,t7403); +float t7405 = (t7404-3.1415927); +float t7406 = (t7401-t7405); +float t7407 = abs(t7406); +float t7408 = (t7407/2); +float t7409 = sin(t7408); +float t7410 = (t7409*t7409); +float t7411 = (t7397*t7410); +float t7412 = (t7394+t7411); +float t7413 = sqrt(t7412); +float t7414 = asin(t7413); +float t7415 = (2*t7414); +float t7416 = abs(t7415); +bool t7417 = (t7385>=t7416); +float t7418; +if(t7417){ +t7418 = t7385; +} else { +t7418 = t7416; +} +t7309 = t7418; +} +float t7419 = abs(t7309); +float t7420 = step(float(2.0e-4),t7419); +float t7421 = (1-t7420); +float t7422 = (t6113*t7149); +float t7423 = (t7422*float(842.378)); +float t7424 = fract(t7423); +float t7425 = (t7424+float(45.32)); +float t7426 = (t7425+u6.u0); +float t7427 = (t7424*t7426); +float t7428 = (t6129*t6113); +float t7429 = (t7428*float(1734.048)); +float t7430 = fract(t7429); +float t7431 = (t7430+float(45.32)); +float t7432 = (t7431+u6.u0); +float t7433 = (t7430*t7432); +float t7434 = (t7427+t7433); +float t7435 = (t7424+t7434); +float t7436 = (t7430+t7434); +float t7437 = (t7435*t7436); +float t7438 = fract(t7437); +float t7439 = step(float(0.2),t7438); +float t7440 = (t7421*t7439); +float t7441 = (3.1415927/2); +float t7442 = (t7166-t7441); +float t7443 = (3.1415927/2); +float t7444 = (t7192-t7443); +float t7445 = (t7442-t7444); +float t7446 = abs(t7445); +float t7447 = (t7446/2); +float t7448 = sin(t7447); +float t7449 = (t7448*t7448); +float t7450 = cos(t7444); +float t7451 = cos(t7442); +float t7452 = (t7450*t7451); +float t7453 = (t7214+3.1415927); +float t7454 = (3.1415927*2); +float t7455 = mod(t7453,t7454); +float t7456 = (t7455-3.1415927); +float t7457 = (t7230+3.1415927); +float t7458 = (3.1415927*2); +float t7459 = mod(t7457,t7458); +float t7460 = (t7459-3.1415927); +float t7461 = (t7456-t7460); +float t7462 = abs(t7461); +float t7463 = (t7462/2); +float t7464 = sin(t7463); +float t7465 = (t7464*t7464); +float t7466 = (t7452*t7465); +float t7467 = (t7449+t7466); +float t7468 = sqrt(t7467); +float t7469 = asin(t7468); +float t7470 = (2*t7469); +float t7471 = (t7470/t5448); +float t7472 = (1-t7471); +float t7473 = (t6113/85); +float t7474 = (t7473*float(842.378)); +float t7475 = fract(t7474); +float t7476 = (t7475+float(45.32)); +float t7477 = (t7476+u6.u0); +float t7478 = (t7475*t7477); +float t7479 = (t6129/t6126); +float t7480 = (t7479*float(1734.048)); +float t7481 = fract(t7480); +float t7482 = (t7481+float(45.32)); +float t7483 = (t7482+u6.u0); +float t7484 = (t7481*t7483); +float t7485 = (t7478+t7484); +float t7486 = (t7475+t7485); +float t7487 = (t7481+t7485); +float t7488 = (t7486*t7487); +float t7489 = fract(t7488); +float t7490 = (t7489*float(8.0e-3)); +float t7491 = (float(1.0e-3)+t7490); +float t7492 = (t7489*173); +float t7493 = fract(t7492); +float t7494 = step(float(0.66),t7493); +float t7495 = (t7494*float(3.0e-3)); +float t7496 = (t7491-t7495); +float t7497 = (t7496*float(0.45)); +float t7498 = (t6113/85); +float t7499 = (t7498*float(842.378)); +float t7500 = fract(t7499); +float t7501 = (t7500+float(45.32)); +float t7502 = (t7501+u6.u0); +float t7503 = (t7500*t7502); +float t7504 = (t7149/t6126); +float t7505 = (t7504*float(1734.048)); +float t7506 = fract(t7505); +float t7507 = (t7506+float(45.32)); +float t7508 = (t7507+u6.u0); +float t7509 = (t7506*t7508); +float t7510 = (t7503+t7509); +float t7511 = (t7500+t7510); +float t7512 = (t7506+t7510); +float t7513 = (t7511*t7512); +float t7514 = fract(t7513); +float t7515 = (t7514*float(8.0e-3)); +float t7516 = (float(1.0e-3)+t7515); +float t7517 = (t7514*173); +float t7518 = fract(t7517); +float t7519 = step(float(0.66),t7518); +float t7520 = (t7519*float(3.0e-3)); +float t7521 = (t7516-t7520); +float t7522 = (t7521*float(0.45)); +float t7523 = (t7497-t7522); +float t7524 = abs(t7523); +float t7525 = (t7524-float(1.0e-3)); +float t7526 = (t7525/float(8.0e-3)); +float t7527 = (1-t7526); +float t7528 = (t7527*t7527); +float t7529 = (t7472*t7528); +float t7530 = (t7440*t7529); +float t7531 = (u4.u0*t7438); +float t7532 = (t7531*3); +float t7533 = sin(t7532); +float t7534 = (t7533+1); +float t7535 = (t7534/2); +float t7536 = (t7535*float(0.66)); +float t7537 = (t7536+float(0.33)); +float t7538 = (t7530*t7537); +float t7539 = (float(0.2)*t7538); +bool t7540 = (0>=t7539); +float t7541; +if(t7540){ +t7541 = 0; +} else { +t7541 = t7539; +} +float t7542 = (t7541*0); +float t7543 = (t7141+t7542); +float t7544 = (t6113*t5448); +float t7545 = (t6113/85); +float t7546 = (t7545*float(842.378)); +float t7547 = fract(t7546); +float t7548 = (t7547+float(45.32)); +float t7549 = (t7548+u6.u0); +float t7550 = (t7547*t7549); +float t7551 = (t7149/t6126); +float t7552 = (t7551*float(1734.048)); +float t7553 = fract(t7552); +float t7554 = (t7553+float(45.32)); +float t7555 = (t7554+u6.u0); +float t7556 = (t7553*t7555); +float t7557 = (t7550+t7556); +float t7558 = (t7547+t7557); +float t7559 = (t7553+t7557); +float t7560 = (t7558*t7559); +float t7561 = fract(t7560); +float t7562 = (t7561*float(2852.02)); +float t7563 = fract(t7562); +float t7564 = (t7563-float(0.5)); +float t7565 = (t7564*t5448); +float t7566 = (t7565*float(0.75)); +float t7567 = (t7544+t7566); +float t7568 = (3.1415927/2); +float t7569 = (t7567-t7568); +float t7570 = (t5450*t5448); +float t7571 = (t5450/85); +float t7572 = (t7571*float(842.378)); +float t7573 = fract(t7572); +float t7574 = (t7573+float(45.32)); +float t7575 = (t7574+u6.u0); +float t7576 = (t7573*t7575); +float t7577 = (t5684/t5463); +float t7578 = (t7577*float(1734.048)); +float t7579 = fract(t7578); +float t7580 = (t7579+float(45.32)); +float t7581 = (t7580+u6.u0); +float t7582 = (t7579*t7581); +float t7583 = (t7576+t7582); +float t7584 = (t7573+t7583); +float t7585 = (t7579+t7583); +float t7586 = (t7584*t7585); +float t7587 = fract(t7586); +float t7588 = (t7587*float(2852.02)); +float t7589 = fract(t7588); +float t7590 = (t7589-float(0.5)); +float t7591 = (t7590*t5448); +float t7592 = (t7591*float(0.75)); +float t7593 = (t7570+t7592); +float t7594 = (3.1415927/2); +float t7595 = (t7593-t7594); +float t7596 = (t7569-t7595); +float t7597 = abs(t7596); +float t7598 = (t7597/2); +float t7599 = sin(t7598); +float t7600 = (t7599*t7599); +float t7601 = cos(t7595); +float t7602 = cos(t7569); +float t7603 = (t7601*t7602); +float t7604 = (3.1415927/t6126); +float t7605 = (t7149*t7604); +float t7606 = (t7561*float(97372.83)); +float t7607 = fract(t7606); +float t7608 = (t7607-float(0.5)); +float t7609 = (3.1415927/t6126); +float t7610 = (t7608*t7609); +float t7611 = (t7610*float(0.75)); +float t7612 = (t7605+t7611); +float t7613 = (t7612+3.1415927); +float t7614 = mod(t7613,t1433); +float t7615 = (t7614-3.1415927); +float t7616 = (t7615+3.1415927); +float t7617 = (3.1415927*2); +float t7618 = mod(t7616,t7617); +float t7619 = (t7618-3.1415927); +float t7620 = (3.1415927/t5463); +float t7621 = (t5684*t7620); +float t7622 = (t7587*float(97372.83)); +float t7623 = fract(t7622); +float t7624 = (t7623-float(0.5)); +float t7625 = (3.1415927/t5463); +float t7626 = (t7624*t7625); +float t7627 = (t7626*float(0.75)); +float t7628 = (t7621+t7627); +float t7629 = (t7628+3.1415927); +float t7630 = mod(t7629,t1433); +float t7631 = (t7630-3.1415927); +float t7632 = (t7631+3.1415927); +float t7633 = (3.1415927*2); +float t7634 = mod(t7632,t7633); +float t7635 = (t7634-3.1415927); +float t7636 = (t7619-t7635); +float t7637 = abs(t7636); +float t7638 = (t7637/2); +float t7639 = sin(t7638); +float t7640 = (t7639*t7639); +float t7641 = (t7603*t7640); +float t7642 = (t7600+t7641); +float t7643 = sqrt(t7642); +float t7644 = asin(t7643); +float t7645 = (2*t7644); +float t7646 = (3.1415927/2); +float t7647 = (t8-t7646); +float t7648 = (3.1415927/2); +float t7649 = (t7593-t7648); +float t7650 = (t7647-t7649); +float t7651 = abs(t7650); +float t7652 = (t7651/2); +float t7653 = sin(t7652); +float t7654 = (t7653*t7653); +float t7655 = cos(t7649); +float t7656 = cos(t7647); +float t7657 = (t7655*t7656); +float t7658 = (t118+3.1415927); +float t7659 = (3.1415927*2); +float t7660 = mod(t7658,t7659); +float t7661 = (t7660-3.1415927); +float t7662 = (t7631+3.1415927); +float t7663 = (3.1415927*2); +float t7664 = mod(t7662,t7663); +float t7665 = (t7664-3.1415927); +float t7666 = (t7661-t7665); +float t7667 = abs(t7666); +float t7668 = (t7667/2); +float t7669 = sin(t7668); +float t7670 = (t7669*t7669); +float t7671 = (t7657*t7670); +float t7672 = (t7654+t7671); +float t7673 = sqrt(t7672); +float t7674 = asin(t7673); +float t7675 = (2*t7674); +float t7676 = (t7645-t7675); +float t7677 = (3.1415927/2); +float t7678 = (t8-t7677); +float t7679 = (3.1415927/2); +float t7680 = (t7567-t7679); +float t7681 = (t7678-t7680); +float t7682 = abs(t7681); +float t7683 = (t7682/2); +float t7684 = sin(t7683); +float t7685 = (t7684*t7684); +float t7686 = cos(t7680); +float t7687 = cos(t7678); +float t7688 = (t7686*t7687); +float t7689 = (t118+3.1415927); +float t7690 = (3.1415927*2); +float t7691 = mod(t7689,t7690); +float t7692 = (t7691-3.1415927); +float t7693 = (t7615+3.1415927); +float t7694 = (3.1415927*2); +float t7695 = mod(t7693,t7694); +float t7696 = (t7695-3.1415927); +float t7697 = (t7692-t7696); +float t7698 = abs(t7697); +float t7699 = (t7698/2); +float t7700 = sin(t7699); +float t7701 = (t7700*t7700); +float t7702 = (t7688*t7701); +float t7703 = (t7685+t7702); +float t7704 = sqrt(t7703); +float t7705 = asin(t7704); +float t7706 = (2*t7705); +float t7707 = (t7676-t7706); +float t7708 = abs(t7707); +bool t7709 = (float(1.0e-4)>t7708); +float t7710; +if(t7709){ +float t7711 = cos(t7593); +float t7712 = (1*t7711); +float t7713 = sin(t7567); +float t7714 = (1*t7713); +float t7715 = cos(t7615); +float t7716 = (t7714*t7715); +float t7717 = (t7712*t7716); +float t7718 = sin(t7593); +float t7719 = (1*t7718); +float t7720 = cos(t7631); +float t7721 = (t7719*t7720); +float t7722 = cos(t7567); +float t7723 = (1*t7722); +float t7724 = (t7721*t7723); +float t7725 = (t7717-t7724); +float t7726 = sin(t8); +float t7727 = (1*t7726); +float t7728 = sin(t118); +float t7729 = (t7727*t7728); +float t7730 = (t7725*t7729); +float t7731 = sin(t7567); +float t7732 = (1*t7731); +float t7733 = sin(t7615); +float t7734 = (t7732*t7733); +float t7735 = (t7721*t7734); +float t7736 = sin(t7593); +float t7737 = (1*t7736); +float t7738 = sin(t7631); +float t7739 = (t7737*t7738); +float t7740 = (t7739*t7716); +float t7741 = (t7735-t7740); +float t7742 = cos(t8); +float t7743 = (1*t7742); +float t7744 = (t7741*t7743); +float t7745 = (t7730+t7744); +float t7746 = (t7739*t7723); +float t7747 = (t7712*t7734); +float t7748 = (t7746-t7747); +float t7749 = sin(t8); +float t7750 = (1*t7749); +float t7751 = cos(t118); +float t7752 = (t7750*t7751); +float t7753 = (t7748*t7752); +float t7754 = (t7745+t7753); +float t7755 = abs(t7754); +t7710 = t7755; +} else { +float t7756 = (3.1415927/2); +float t7757 = (t8-t7756); +float t7758 = (3.1415927/2); +float t7759 = (t7567-t7758); +float t7760 = (t7757-t7759); +float t7761 = abs(t7760); +float t7762 = (t7761/2); +float t7763 = sin(t7762); +float t7764 = (t7763*t7763); +float t7765 = cos(t7759); +float t7766 = cos(t7757); +float t7767 = (t7765*t7766); +float t7768 = (t118+3.1415927); +float t7769 = (3.1415927*2); +float t7770 = mod(t7768,t7769); +float t7771 = (t7770-3.1415927); +float t7772 = (t7615+3.1415927); +float t7773 = (3.1415927*2); +float t7774 = mod(t7772,t7773); +float t7775 = (t7774-3.1415927); +float t7776 = (t7771-t7775); +float t7777 = abs(t7776); +float t7778 = (t7777/2); +float t7779 = sin(t7778); +float t7780 = (t7779*t7779); +float t7781 = (t7767*t7780); +float t7782 = (t7764+t7781); +float t7783 = sqrt(t7782); +float t7784 = asin(t7783); +float t7785 = (2*t7784); +float t7786 = abs(t7785); +float t7787 = (3.1415927/2); +float t7788 = (t8-t7787); +float t7789 = (3.1415927/2); +float t7790 = (t7593-t7789); +float t7791 = (t7788-t7790); +float t7792 = abs(t7791); +float t7793 = (t7792/2); +float t7794 = sin(t7793); +float t7795 = (t7794*t7794); +float t7796 = cos(t7790); +float t7797 = cos(t7788); +float t7798 = (t7796*t7797); +float t7799 = (t118+3.1415927); +float t7800 = (3.1415927*2); +float t7801 = mod(t7799,t7800); +float t7802 = (t7801-3.1415927); +float t7803 = (t7631+3.1415927); +float t7804 = (3.1415927*2); +float t7805 = mod(t7803,t7804); +float t7806 = (t7805-3.1415927); +float t7807 = (t7802-t7806); +float t7808 = abs(t7807); +float t7809 = (t7808/2); +float t7810 = sin(t7809); +float t7811 = (t7810*t7810); +float t7812 = (t7798*t7811); +float t7813 = (t7795+t7812); +float t7814 = sqrt(t7813); +float t7815 = asin(t7814); +float t7816 = (2*t7815); +float t7817 = abs(t7816); +bool t7818 = (t7786>=t7817); +float t7819; +if(t7818){ +t7819 = t7786; +} else { +t7819 = t7817; +} +t7710 = t7819; +} +float t7820 = abs(t7710); +float t7821 = step(float(2.0e-4),t7820); +float t7822 = (1-t7821); +float t7823 = (t5450*t7149); +float t7824 = (t7823*float(842.378)); +float t7825 = fract(t7824); +float t7826 = (t7825+float(45.32)); +float t7827 = (t7826+u6.u0); +float t7828 = (t7825*t7827); +float t7829 = (t5684*t6113); +float t7830 = (t7829*float(1734.048)); +float t7831 = fract(t7830); +float t7832 = (t7831+float(45.32)); +float t7833 = (t7832+u6.u0); +float t7834 = (t7831*t7833); +float t7835 = (t7828+t7834); +float t7836 = (t7825+t7835); +float t7837 = (t7831+t7835); +float t7838 = (t7836*t7837); +float t7839 = fract(t7838); +float t7840 = step(float(0.2),t7839); +float t7841 = (t7822*t7840); +float t7842 = (3.1415927/2); +float t7843 = (t7567-t7842); +float t7844 = (3.1415927/2); +float t7845 = (t7593-t7844); +float t7846 = (t7843-t7845); +float t7847 = abs(t7846); +float t7848 = (t7847/2); +float t7849 = sin(t7848); +float t7850 = (t7849*t7849); +float t7851 = cos(t7845); +float t7852 = cos(t7843); +float t7853 = (t7851*t7852); +float t7854 = (t7615+3.1415927); +float t7855 = (3.1415927*2); +float t7856 = mod(t7854,t7855); +float t7857 = (t7856-3.1415927); +float t7858 = (t7631+3.1415927); +float t7859 = (3.1415927*2); +float t7860 = mod(t7858,t7859); +float t7861 = (t7860-3.1415927); +float t7862 = (t7857-t7861); +float t7863 = abs(t7862); +float t7864 = (t7863/2); +float t7865 = sin(t7864); +float t7866 = (t7865*t7865); +float t7867 = (t7853*t7866); +float t7868 = (t7850+t7867); +float t7869 = sqrt(t7868); +float t7870 = asin(t7869); +float t7871 = (2*t7870); +float t7872 = (t7871/t5448); +float t7873 = (1-t7872); +float t7874 = (t5450/85); +float t7875 = (t7874*float(842.378)); +float t7876 = fract(t7875); +float t7877 = (t7876+float(45.32)); +float t7878 = (t7877+u6.u0); +float t7879 = (t7876*t7878); +float t7880 = (t5684/t5463); +float t7881 = (t7880*float(1734.048)); +float t7882 = fract(t7881); +float t7883 = (t7882+float(45.32)); +float t7884 = (t7883+u6.u0); +float t7885 = (t7882*t7884); +float t7886 = (t7879+t7885); +float t7887 = (t7876+t7886); +float t7888 = (t7882+t7886); +float t7889 = (t7887*t7888); +float t7890 = fract(t7889); +float t7891 = (t7890*float(8.0e-3)); +float t7892 = (float(1.0e-3)+t7891); +float t7893 = (t7890*173); +float t7894 = fract(t7893); +float t7895 = step(float(0.66),t7894); +float t7896 = (t7895*float(3.0e-3)); +float t7897 = (t7892-t7896); +float t7898 = (t7897*float(0.45)); +float t7899 = (t6113/85); +float t7900 = (t7899*float(842.378)); +float t7901 = fract(t7900); +float t7902 = (t7901+float(45.32)); +float t7903 = (t7902+u6.u0); +float t7904 = (t7901*t7903); +float t7905 = (t7149/t6126); +float t7906 = (t7905*float(1734.048)); +float t7907 = fract(t7906); +float t7908 = (t7907+float(45.32)); +float t7909 = (t7908+u6.u0); +float t7910 = (t7907*t7909); +float t7911 = (t7904+t7910); +float t7912 = (t7901+t7911); +float t7913 = (t7907+t7911); +float t7914 = (t7912*t7913); +float t7915 = fract(t7914); +float t7916 = (t7915*float(8.0e-3)); +float t7917 = (float(1.0e-3)+t7916); +float t7918 = (t7915*173); +float t7919 = fract(t7918); +float t7920 = step(float(0.66),t7919); +float t7921 = (t7920*float(3.0e-3)); +float t7922 = (t7917-t7921); +float t7923 = (t7922*float(0.45)); +float t7924 = (t7898-t7923); +float t7925 = abs(t7924); +float t7926 = (t7925-float(1.0e-3)); +float t7927 = (t7926/float(8.0e-3)); +float t7928 = (1-t7927); +float t7929 = (t7928*t7928); +float t7930 = (t7873*t7929); +float t7931 = (t7841*t7930); +float t7932 = (u4.u0*t7839); +float t7933 = (t7932*3); +float t7934 = sin(t7933); +float t7935 = (t7934+1); +float t7936 = (t7935/2); +float t7937 = (t7936*float(0.66)); +float t7938 = (t7937+float(0.33)); +float t7939 = (t7931*t7938); +float t7940 = (float(0.2)*t7939); +bool t7941 = (0>=t7940); +float t7942; +if(t7941){ +t7942 = 0; +} else { +t7942 = t7940; +} +float t7943 = (t7942*0); +float t7944 = (t7543+t7943); +float t7945 = (t6113*t5448); +float t7946 = (t6113/85); +float t7947 = (t7946*float(842.378)); +float t7948 = fract(t7947); +float t7949 = (t7948+float(45.32)); +float t7950 = (t7949+u6.u0); +float t7951 = (t7948*t7950); +float t7952 = (t7149/t6126); +float t7953 = (t7952*float(1734.048)); +float t7954 = fract(t7953); +float t7955 = (t7954+float(45.32)); +float t7956 = (t7955+u6.u0); +float t7957 = (t7954*t7956); +float t7958 = (t7951+t7957); +float t7959 = (t7948+t7958); +float t7960 = (t7954+t7958); +float t7961 = (t7959*t7960); +float t7962 = fract(t7961); +float t7963 = (t7962*float(2852.02)); +float t7964 = fract(t7963); +float t7965 = (t7964-float(0.5)); +float t7966 = (t7965*t5448); +float t7967 = (t7966*float(0.75)); +float t7968 = (t7945+t7967); +float t7969 = (3.1415927/2); +float t7970 = (t7968-t7969); +float t7971 = (t5450*t5448); +float t7972 = (t5450/85); +float t7973 = (t7972*float(842.378)); +float t7974 = fract(t7973); +float t7975 = (t7974+float(45.32)); +float t7976 = (t7975+u6.u0); +float t7977 = (t7974*t7976); +float t7978 = (t5466/t5463); +float t7979 = (t7978*float(1734.048)); +float t7980 = fract(t7979); +float t7981 = (t7980+float(45.32)); +float t7982 = (t7981+u6.u0); +float t7983 = (t7980*t7982); +float t7984 = (t7977+t7983); +float t7985 = (t7974+t7984); +float t7986 = (t7980+t7984); +float t7987 = (t7985*t7986); +float t7988 = fract(t7987); +float t7989 = (t7988*float(2852.02)); +float t7990 = fract(t7989); +float t7991 = (t7990-float(0.5)); +float t7992 = (t7991*t5448); +float t7993 = (t7992*float(0.75)); +float t7994 = (t7971+t7993); +float t7995 = (3.1415927/2); +float t7996 = (t7994-t7995); +float t7997 = (t7970-t7996); +float t7998 = abs(t7997); +float t7999 = (t7998/2); +float t8000 = sin(t7999); +float t8001 = (t8000*t8000); +float t8002 = cos(t7996); +float t8003 = cos(t7970); +float t8004 = (t8002*t8003); +float t8005 = (3.1415927/t6126); +float t8006 = (t7149*t8005); +float t8007 = (t7962*float(97372.83)); +float t8008 = fract(t8007); +float t8009 = (t8008-float(0.5)); +float t8010 = (3.1415927/t6126); +float t8011 = (t8009*t8010); +float t8012 = (t8011*float(0.75)); +float t8013 = (t8006+t8012); +float t8014 = (t8013+3.1415927); +float t8015 = mod(t8014,t1433); +float t8016 = (t8015-3.1415927); +float t8017 = (t8016+3.1415927); +float t8018 = (3.1415927*2); +float t8019 = mod(t8017,t8018); +float t8020 = (t8019-3.1415927); +float t8021 = (3.1415927/t5463); +float t8022 = (t5466*t8021); +float t8023 = (t7988*float(97372.83)); +float t8024 = fract(t8023); +float t8025 = (t8024-float(0.5)); +float t8026 = (3.1415927/t5463); +float t8027 = (t8025*t8026); +float t8028 = (t8027*float(0.75)); +float t8029 = (t8022+t8028); +float t8030 = (t8029+3.1415927); +float t8031 = mod(t8030,t1433); +float t8032 = (t8031-3.1415927); +float t8033 = (t8032+3.1415927); +float t8034 = (3.1415927*2); +float t8035 = mod(t8033,t8034); +float t8036 = (t8035-3.1415927); +float t8037 = (t8020-t8036); +float t8038 = abs(t8037); +float t8039 = (t8038/2); +float t8040 = sin(t8039); +float t8041 = (t8040*t8040); +float t8042 = (t8004*t8041); +float t8043 = (t8001+t8042); +float t8044 = sqrt(t8043); +float t8045 = asin(t8044); +float t8046 = (2*t8045); +float t8047 = (3.1415927/2); +float t8048 = (t8-t8047); +float t8049 = (3.1415927/2); +float t8050 = (t7994-t8049); +float t8051 = (t8048-t8050); +float t8052 = abs(t8051); +float t8053 = (t8052/2); +float t8054 = sin(t8053); +float t8055 = (t8054*t8054); +float t8056 = cos(t8050); +float t8057 = cos(t8048); +float t8058 = (t8056*t8057); +float t8059 = (t118+3.1415927); +float t8060 = (3.1415927*2); +float t8061 = mod(t8059,t8060); +float t8062 = (t8061-3.1415927); +float t8063 = (t8032+3.1415927); +float t8064 = (3.1415927*2); +float t8065 = mod(t8063,t8064); +float t8066 = (t8065-3.1415927); +float t8067 = (t8062-t8066); +float t8068 = abs(t8067); +float t8069 = (t8068/2); +float t8070 = sin(t8069); +float t8071 = (t8070*t8070); +float t8072 = (t8058*t8071); +float t8073 = (t8055+t8072); +float t8074 = sqrt(t8073); +float t8075 = asin(t8074); +float t8076 = (2*t8075); +float t8077 = (t8046-t8076); +float t8078 = (3.1415927/2); +float t8079 = (t8-t8078); +float t8080 = (3.1415927/2); +float t8081 = (t7968-t8080); +float t8082 = (t8079-t8081); +float t8083 = abs(t8082); +float t8084 = (t8083/2); +float t8085 = sin(t8084); +float t8086 = (t8085*t8085); +float t8087 = cos(t8081); +float t8088 = cos(t8079); +float t8089 = (t8087*t8088); +float t8090 = (t118+3.1415927); +float t8091 = (3.1415927*2); +float t8092 = mod(t8090,t8091); +float t8093 = (t8092-3.1415927); +float t8094 = (t8016+3.1415927); +float t8095 = (3.1415927*2); +float t8096 = mod(t8094,t8095); +float t8097 = (t8096-3.1415927); +float t8098 = (t8093-t8097); +float t8099 = abs(t8098); +float t8100 = (t8099/2); +float t8101 = sin(t8100); +float t8102 = (t8101*t8101); +float t8103 = (t8089*t8102); +float t8104 = (t8086+t8103); +float t8105 = sqrt(t8104); +float t8106 = asin(t8105); +float t8107 = (2*t8106); +float t8108 = (t8077-t8107); +float t8109 = abs(t8108); +bool t8110 = (float(1.0e-4)>t8109); +float t8111; +if(t8110){ +float t8112 = cos(t7994); +float t8113 = (1*t8112); +float t8114 = sin(t7968); +float t8115 = (1*t8114); +float t8116 = cos(t8016); +float t8117 = (t8115*t8116); +float t8118 = (t8113*t8117); +float t8119 = sin(t7994); +float t8120 = (1*t8119); +float t8121 = cos(t8032); +float t8122 = (t8120*t8121); +float t8123 = cos(t7968); +float t8124 = (1*t8123); +float t8125 = (t8122*t8124); +float t8126 = (t8118-t8125); +float t8127 = sin(t8); +float t8128 = (1*t8127); +float t8129 = sin(t118); +float t8130 = (t8128*t8129); +float t8131 = (t8126*t8130); +float t8132 = sin(t7968); +float t8133 = (1*t8132); +float t8134 = sin(t8016); +float t8135 = (t8133*t8134); +float t8136 = (t8122*t8135); +float t8137 = sin(t7994); +float t8138 = (1*t8137); +float t8139 = sin(t8032); +float t8140 = (t8138*t8139); +float t8141 = (t8140*t8117); +float t8142 = (t8136-t8141); +float t8143 = cos(t8); +float t8144 = (1*t8143); +float t8145 = (t8142*t8144); +float t8146 = (t8131+t8145); +float t8147 = (t8140*t8124); +float t8148 = (t8113*t8135); +float t8149 = (t8147-t8148); +float t8150 = sin(t8); +float t8151 = (1*t8150); +float t8152 = cos(t118); +float t8153 = (t8151*t8152); +float t8154 = (t8149*t8153); +float t8155 = (t8146+t8154); +float t8156 = abs(t8155); +t8111 = t8156; +} else { +float t8157 = (3.1415927/2); +float t8158 = (t8-t8157); +float t8159 = (3.1415927/2); +float t8160 = (t7968-t8159); +float t8161 = (t8158-t8160); +float t8162 = abs(t8161); +float t8163 = (t8162/2); +float t8164 = sin(t8163); +float t8165 = (t8164*t8164); +float t8166 = cos(t8160); +float t8167 = cos(t8158); +float t8168 = (t8166*t8167); +float t8169 = (t118+3.1415927); +float t8170 = (3.1415927*2); +float t8171 = mod(t8169,t8170); +float t8172 = (t8171-3.1415927); +float t8173 = (t8016+3.1415927); +float t8174 = (3.1415927*2); +float t8175 = mod(t8173,t8174); +float t8176 = (t8175-3.1415927); +float t8177 = (t8172-t8176); +float t8178 = abs(t8177); +float t8179 = (t8178/2); +float t8180 = sin(t8179); +float t8181 = (t8180*t8180); +float t8182 = (t8168*t8181); +float t8183 = (t8165+t8182); +float t8184 = sqrt(t8183); +float t8185 = asin(t8184); +float t8186 = (2*t8185); +float t8187 = abs(t8186); +float t8188 = (3.1415927/2); +float t8189 = (t8-t8188); +float t8190 = (3.1415927/2); +float t8191 = (t7994-t8190); +float t8192 = (t8189-t8191); +float t8193 = abs(t8192); +float t8194 = (t8193/2); +float t8195 = sin(t8194); +float t8196 = (t8195*t8195); +float t8197 = cos(t8191); +float t8198 = cos(t8189); +float t8199 = (t8197*t8198); +float t8200 = (t118+3.1415927); +float t8201 = (3.1415927*2); +float t8202 = mod(t8200,t8201); +float t8203 = (t8202-3.1415927); +float t8204 = (t8032+3.1415927); +float t8205 = (3.1415927*2); +float t8206 = mod(t8204,t8205); +float t8207 = (t8206-3.1415927); +float t8208 = (t8203-t8207); +float t8209 = abs(t8208); +float t8210 = (t8209/2); +float t8211 = sin(t8210); +float t8212 = (t8211*t8211); +float t8213 = (t8199*t8212); +float t8214 = (t8196+t8213); +float t8215 = sqrt(t8214); +float t8216 = asin(t8215); +float t8217 = (2*t8216); +float t8218 = abs(t8217); +bool t8219 = (t8187>=t8218); +float t8220; +if(t8219){ +t8220 = t8187; +} else { +t8220 = t8218; +} +t8111 = t8220; +} +float t8221 = abs(t8111); +float t8222 = step(float(2.0e-4),t8221); +float t8223 = (1-t8222); +float t8224 = (t5450*t7149); +float t8225 = (t8224*float(842.378)); +float t8226 = fract(t8225); +float t8227 = (t8226+float(45.32)); +float t8228 = (t8227+u6.u0); +float t8229 = (t8226*t8228); +float t8230 = (t5466*t6113); +float t8231 = (t8230*float(1734.048)); +float t8232 = fract(t8231); +float t8233 = (t8232+float(45.32)); +float t8234 = (t8233+u6.u0); +float t8235 = (t8232*t8234); +float t8236 = (t8229+t8235); +float t8237 = (t8226+t8236); +float t8238 = (t8232+t8236); +float t8239 = (t8237*t8238); +float t8240 = fract(t8239); +float t8241 = step(float(0.2),t8240); +float t8242 = (t8223*t8241); +float t8243 = (3.1415927/2); +float t8244 = (t7968-t8243); +float t8245 = (3.1415927/2); +float t8246 = (t7994-t8245); +float t8247 = (t8244-t8246); +float t8248 = abs(t8247); +float t8249 = (t8248/2); +float t8250 = sin(t8249); +float t8251 = (t8250*t8250); +float t8252 = cos(t8246); +float t8253 = cos(t8244); +float t8254 = (t8252*t8253); +float t8255 = (t8016+3.1415927); +float t8256 = (3.1415927*2); +float t8257 = mod(t8255,t8256); +float t8258 = (t8257-3.1415927); +float t8259 = (t8032+3.1415927); +float t8260 = (3.1415927*2); +float t8261 = mod(t8259,t8260); +float t8262 = (t8261-3.1415927); +float t8263 = (t8258-t8262); +float t8264 = abs(t8263); +float t8265 = (t8264/2); +float t8266 = sin(t8265); +float t8267 = (t8266*t8266); +float t8268 = (t8254*t8267); +float t8269 = (t8251+t8268); +float t8270 = sqrt(t8269); +float t8271 = asin(t8270); +float t8272 = (2*t8271); +float t8273 = (t8272/t5448); +float t8274 = (1-t8273); +float t8275 = (t5450/85); +float t8276 = (t8275*float(842.378)); +float t8277 = fract(t8276); +float t8278 = (t8277+float(45.32)); +float t8279 = (t8278+u6.u0); +float t8280 = (t8277*t8279); +float t8281 = (t5466/t5463); +float t8282 = (t8281*float(1734.048)); +float t8283 = fract(t8282); +float t8284 = (t8283+float(45.32)); +float t8285 = (t8284+u6.u0); +float t8286 = (t8283*t8285); +float t8287 = (t8280+t8286); +float t8288 = (t8277+t8287); +float t8289 = (t8283+t8287); +float t8290 = (t8288*t8289); +float t8291 = fract(t8290); +float t8292 = (t8291*float(8.0e-3)); +float t8293 = (float(1.0e-3)+t8292); +float t8294 = (t8291*173); +float t8295 = fract(t8294); +float t8296 = step(float(0.66),t8295); +float t8297 = (t8296*float(3.0e-3)); +float t8298 = (t8293-t8297); +float t8299 = (t8298*float(0.45)); +float t8300 = (t6113/85); +float t8301 = (t8300*float(842.378)); +float t8302 = fract(t8301); +float t8303 = (t8302+float(45.32)); +float t8304 = (t8303+u6.u0); +float t8305 = (t8302*t8304); +float t8306 = (t7149/t6126); +float t8307 = (t8306*float(1734.048)); +float t8308 = fract(t8307); +float t8309 = (t8308+float(45.32)); +float t8310 = (t8309+u6.u0); +float t8311 = (t8308*t8310); +float t8312 = (t8305+t8311); +float t8313 = (t8302+t8312); +float t8314 = (t8308+t8312); +float t8315 = (t8313*t8314); +float t8316 = fract(t8315); +float t8317 = (t8316*float(8.0e-3)); +float t8318 = (float(1.0e-3)+t8317); +float t8319 = (t8316*173); +float t8320 = fract(t8319); +float t8321 = step(float(0.66),t8320); +float t8322 = (t8321*float(3.0e-3)); +float t8323 = (t8318-t8322); +float t8324 = (t8323*float(0.45)); +float t8325 = (t8299-t8324); +float t8326 = abs(t8325); +float t8327 = (t8326-float(1.0e-3)); +float t8328 = (t8327/float(8.0e-3)); +float t8329 = (1-t8328); +float t8330 = (t8329*t8329); +float t8331 = (t8274*t8330); +float t8332 = (t8242*t8331); +float t8333 = (u4.u0*t8240); +float t8334 = (t8333*3); +float t8335 = sin(t8334); +float t8336 = (t8335+1); +float t8337 = (t8336/2); +float t8338 = (t8337*float(0.66)); +float t8339 = (t8338+float(0.33)); +float t8340 = (t8332*t8339); +float t8341 = (float(0.2)*t8340); +bool t8342 = (0>=t8341); +float t8343; +if(t8342){ +t8343 = 0; +} else { +t8343 = t8341; +} +float t8344 = (t8343*0); +float t8345 = (t7944+t8344); +float t8346 = (t5450*t5448); +float t8347 = (t5450/85); +float t8348 = (t8347*float(842.378)); +float t8349 = fract(t8348); +float t8350 = (t8349+float(45.32)); +float t8351 = (t8350+u6.u0); +float t8352 = (t8349*t8351); +float t8353 = (t5902/t5463); +float t8354 = (t8353*float(1734.048)); +float t8355 = fract(t8354); +float t8356 = (t8355+float(45.32)); +float t8357 = (t8356+u6.u0); +float t8358 = (t8355*t8357); +float t8359 = (t8352+t8358); +float t8360 = (t8349+t8359); +float t8361 = (t8355+t8359); +float t8362 = (t8360*t8361); +float t8363 = fract(t8362); +float t8364 = (t8363*float(2852.02)); +float t8365 = fract(t8364); +float t8366 = (t8365-float(0.5)); +float t8367 = (t8366*t5448); +float t8368 = (t8367*float(0.75)); +float t8369 = (t8346+t8368); +float t8370 = (3.1415927/2); +float t8371 = (t8369-t8370); +float t8372 = (t5450*t5448); +float t8373 = (t5450/85); +float t8374 = (t8373*float(842.378)); +float t8375 = fract(t8374); +float t8376 = (t8375+float(45.32)); +float t8377 = (t8376+u6.u0); +float t8378 = (t8375*t8377); +float t8379 = (t5684/t5463); +float t8380 = (t8379*float(1734.048)); +float t8381 = fract(t8380); +float t8382 = (t8381+float(45.32)); +float t8383 = (t8382+u6.u0); +float t8384 = (t8381*t8383); +float t8385 = (t8378+t8384); +float t8386 = (t8375+t8385); +float t8387 = (t8381+t8385); +float t8388 = (t8386*t8387); +float t8389 = fract(t8388); +float t8390 = (t8389*float(2852.02)); +float t8391 = fract(t8390); +float t8392 = (t8391-float(0.5)); +float t8393 = (t8392*t5448); +float t8394 = (t8393*float(0.75)); +float t8395 = (t8372+t8394); +float t8396 = (3.1415927/2); +float t8397 = (t8395-t8396); +float t8398 = (t8371-t8397); +float t8399 = abs(t8398); +float t8400 = (t8399/2); +float t8401 = sin(t8400); +float t8402 = (t8401*t8401); +float t8403 = cos(t8397); +float t8404 = cos(t8371); +float t8405 = (t8403*t8404); +float t8406 = (3.1415927/t5463); +float t8407 = (t5902*t8406); +float t8408 = (t8363*float(97372.83)); +float t8409 = fract(t8408); +float t8410 = (t8409-float(0.5)); +float t8411 = (3.1415927/t5463); +float t8412 = (t8410*t8411); +float t8413 = (t8412*float(0.75)); +float t8414 = (t8407+t8413); +float t8415 = (t8414+3.1415927); +float t8416 = mod(t8415,t1433); +float t8417 = (t8416-3.1415927); +float t8418 = (t8417+3.1415927); +float t8419 = (3.1415927*2); +float t8420 = mod(t8418,t8419); +float t8421 = (t8420-3.1415927); +float t8422 = (3.1415927/t5463); +float t8423 = (t5684*t8422); +float t8424 = (t8389*float(97372.83)); +float t8425 = fract(t8424); +float t8426 = (t8425-float(0.5)); +float t8427 = (3.1415927/t5463); +float t8428 = (t8426*t8427); +float t8429 = (t8428*float(0.75)); +float t8430 = (t8423+t8429); +float t8431 = (t8430+3.1415927); +float t8432 = mod(t8431,t1433); +float t8433 = (t8432-3.1415927); +float t8434 = (t8433+3.1415927); +float t8435 = (3.1415927*2); +float t8436 = mod(t8434,t8435); +float t8437 = (t8436-3.1415927); +float t8438 = (t8421-t8437); +float t8439 = abs(t8438); +float t8440 = (t8439/2); +float t8441 = sin(t8440); +float t8442 = (t8441*t8441); +float t8443 = (t8405*t8442); +float t8444 = (t8402+t8443); +float t8445 = sqrt(t8444); +float t8446 = asin(t8445); +float t8447 = (2*t8446); +float t8448 = (3.1415927/2); +float t8449 = (t8-t8448); +float t8450 = (3.1415927/2); +float t8451 = (t8395-t8450); +float t8452 = (t8449-t8451); +float t8453 = abs(t8452); +float t8454 = (t8453/2); +float t8455 = sin(t8454); +float t8456 = (t8455*t8455); +float t8457 = cos(t8451); +float t8458 = cos(t8449); +float t8459 = (t8457*t8458); +float t8460 = (t118+3.1415927); +float t8461 = (3.1415927*2); +float t8462 = mod(t8460,t8461); +float t8463 = (t8462-3.1415927); +float t8464 = (t8433+3.1415927); +float t8465 = (3.1415927*2); +float t8466 = mod(t8464,t8465); +float t8467 = (t8466-3.1415927); +float t8468 = (t8463-t8467); +float t8469 = abs(t8468); +float t8470 = (t8469/2); +float t8471 = sin(t8470); +float t8472 = (t8471*t8471); +float t8473 = (t8459*t8472); +float t8474 = (t8456+t8473); +float t8475 = sqrt(t8474); +float t8476 = asin(t8475); +float t8477 = (2*t8476); +float t8478 = (t8447-t8477); +float t8479 = (3.1415927/2); +float t8480 = (t8-t8479); +float t8481 = (3.1415927/2); +float t8482 = (t8369-t8481); +float t8483 = (t8480-t8482); +float t8484 = abs(t8483); +float t8485 = (t8484/2); +float t8486 = sin(t8485); +float t8487 = (t8486*t8486); +float t8488 = cos(t8482); +float t8489 = cos(t8480); +float t8490 = (t8488*t8489); +float t8491 = (t118+3.1415927); +float t8492 = (3.1415927*2); +float t8493 = mod(t8491,t8492); +float t8494 = (t8493-3.1415927); +float t8495 = (t8417+3.1415927); +float t8496 = (3.1415927*2); +float t8497 = mod(t8495,t8496); +float t8498 = (t8497-3.1415927); +float t8499 = (t8494-t8498); +float t8500 = abs(t8499); +float t8501 = (t8500/2); +float t8502 = sin(t8501); +float t8503 = (t8502*t8502); +float t8504 = (t8490*t8503); +float t8505 = (t8487+t8504); +float t8506 = sqrt(t8505); +float t8507 = asin(t8506); +float t8508 = (2*t8507); +float t8509 = (t8478-t8508); +float t8510 = abs(t8509); +bool t8511 = (float(1.0e-4)>t8510); +float t8512; +if(t8511){ +float t8513 = cos(t8395); +float t8514 = (1*t8513); +float t8515 = sin(t8369); +float t8516 = (1*t8515); +float t8517 = cos(t8417); +float t8518 = (t8516*t8517); +float t8519 = (t8514*t8518); +float t8520 = sin(t8395); +float t8521 = (1*t8520); +float t8522 = cos(t8433); +float t8523 = (t8521*t8522); +float t8524 = cos(t8369); +float t8525 = (1*t8524); +float t8526 = (t8523*t8525); +float t8527 = (t8519-t8526); +float t8528 = sin(t8); +float t8529 = (1*t8528); +float t8530 = sin(t118); +float t8531 = (t8529*t8530); +float t8532 = (t8527*t8531); +float t8533 = sin(t8369); +float t8534 = (1*t8533); +float t8535 = sin(t8417); +float t8536 = (t8534*t8535); +float t8537 = (t8523*t8536); +float t8538 = sin(t8395); +float t8539 = (1*t8538); +float t8540 = sin(t8433); +float t8541 = (t8539*t8540); +float t8542 = (t8541*t8518); +float t8543 = (t8537-t8542); +float t8544 = cos(t8); +float t8545 = (1*t8544); +float t8546 = (t8543*t8545); +float t8547 = (t8532+t8546); +float t8548 = (t8541*t8525); +float t8549 = (t8514*t8536); +float t8550 = (t8548-t8549); +float t8551 = sin(t8); +float t8552 = (1*t8551); +float t8553 = cos(t118); +float t8554 = (t8552*t8553); +float t8555 = (t8550*t8554); +float t8556 = (t8547+t8555); +float t8557 = abs(t8556); +t8512 = t8557; +} else { +float t8558 = (3.1415927/2); +float t8559 = (t8-t8558); +float t8560 = (3.1415927/2); +float t8561 = (t8369-t8560); +float t8562 = (t8559-t8561); +float t8563 = abs(t8562); +float t8564 = (t8563/2); +float t8565 = sin(t8564); +float t8566 = (t8565*t8565); +float t8567 = cos(t8561); +float t8568 = cos(t8559); +float t8569 = (t8567*t8568); +float t8570 = (t118+3.1415927); +float t8571 = (3.1415927*2); +float t8572 = mod(t8570,t8571); +float t8573 = (t8572-3.1415927); +float t8574 = (t8417+3.1415927); +float t8575 = (3.1415927*2); +float t8576 = mod(t8574,t8575); +float t8577 = (t8576-3.1415927); +float t8578 = (t8573-t8577); +float t8579 = abs(t8578); +float t8580 = (t8579/2); +float t8581 = sin(t8580); +float t8582 = (t8581*t8581); +float t8583 = (t8569*t8582); +float t8584 = (t8566+t8583); +float t8585 = sqrt(t8584); +float t8586 = asin(t8585); +float t8587 = (2*t8586); +float t8588 = abs(t8587); +float t8589 = (3.1415927/2); +float t8590 = (t8-t8589); +float t8591 = (3.1415927/2); +float t8592 = (t8395-t8591); +float t8593 = (t8590-t8592); +float t8594 = abs(t8593); +float t8595 = (t8594/2); +float t8596 = sin(t8595); +float t8597 = (t8596*t8596); +float t8598 = cos(t8592); +float t8599 = cos(t8590); +float t8600 = (t8598*t8599); +float t8601 = (t118+3.1415927); +float t8602 = (3.1415927*2); +float t8603 = mod(t8601,t8602); +float t8604 = (t8603-3.1415927); +float t8605 = (t8433+3.1415927); +float t8606 = (3.1415927*2); +float t8607 = mod(t8605,t8606); +float t8608 = (t8607-3.1415927); +float t8609 = (t8604-t8608); +float t8610 = abs(t8609); +float t8611 = (t8610/2); +float t8612 = sin(t8611); +float t8613 = (t8612*t8612); +float t8614 = (t8600*t8613); +float t8615 = (t8597+t8614); +float t8616 = sqrt(t8615); +float t8617 = asin(t8616); +float t8618 = (2*t8617); +float t8619 = abs(t8618); +bool t8620 = (t8588>=t8619); +float t8621; +if(t8620){ +t8621 = t8588; +} else { +t8621 = t8619; +} +t8512 = t8621; +} +float t8622 = abs(t8512); +float t8623 = step(float(2.0e-4),t8622); +float t8624 = (1-t8623); +float t8625 = (t5450*t5902); +float t8626 = (t8625*float(842.378)); +float t8627 = fract(t8626); +float t8628 = (t8627+float(45.32)); +float t8629 = (t8628+u6.u0); +float t8630 = (t8627*t8629); +float t8631 = (t5684*t5450); +float t8632 = (t8631*float(1734.048)); +float t8633 = fract(t8632); +float t8634 = (t8633+float(45.32)); +float t8635 = (t8634+u6.u0); +float t8636 = (t8633*t8635); +float t8637 = (t8630+t8636); +float t8638 = (t8627+t8637); +float t8639 = (t8633+t8637); +float t8640 = (t8638*t8639); +float t8641 = fract(t8640); +float t8642 = step(float(0.2),t8641); +float t8643 = (t8624*t8642); +float t8644 = (3.1415927/2); +float t8645 = (t8369-t8644); +float t8646 = (3.1415927/2); +float t8647 = (t8395-t8646); +float t8648 = (t8645-t8647); +float t8649 = abs(t8648); +float t8650 = (t8649/2); +float t8651 = sin(t8650); +float t8652 = (t8651*t8651); +float t8653 = cos(t8647); +float t8654 = cos(t8645); +float t8655 = (t8653*t8654); +float t8656 = (t8417+3.1415927); +float t8657 = (3.1415927*2); +float t8658 = mod(t8656,t8657); +float t8659 = (t8658-3.1415927); +float t8660 = (t8433+3.1415927); +float t8661 = (3.1415927*2); +float t8662 = mod(t8660,t8661); +float t8663 = (t8662-3.1415927); +float t8664 = (t8659-t8663); +float t8665 = abs(t8664); +float t8666 = (t8665/2); +float t8667 = sin(t8666); +float t8668 = (t8667*t8667); +float t8669 = (t8655*t8668); +float t8670 = (t8652+t8669); +float t8671 = sqrt(t8670); +float t8672 = asin(t8671); +float t8673 = (2*t8672); +float t8674 = (t8673/t5448); +float t8675 = (1-t8674); +float t8676 = (t5450/85); +float t8677 = (t8676*float(842.378)); +float t8678 = fract(t8677); +float t8679 = (t8678+float(45.32)); +float t8680 = (t8679+u6.u0); +float t8681 = (t8678*t8680); +float t8682 = (t5684/t5463); +float t8683 = (t8682*float(1734.048)); +float t8684 = fract(t8683); +float t8685 = (t8684+float(45.32)); +float t8686 = (t8685+u6.u0); +float t8687 = (t8684*t8686); +float t8688 = (t8681+t8687); +float t8689 = (t8678+t8688); +float t8690 = (t8684+t8688); +float t8691 = (t8689*t8690); +float t8692 = fract(t8691); +float t8693 = (t8692*float(8.0e-3)); +float t8694 = (float(1.0e-3)+t8693); +float t8695 = (t8692*173); +float t8696 = fract(t8695); +float t8697 = step(float(0.66),t8696); +float t8698 = (t8697*float(3.0e-3)); +float t8699 = (t8694-t8698); +float t8700 = (t8699*float(0.45)); +float t8701 = (t5450/85); +float t8702 = (t8701*float(842.378)); +float t8703 = fract(t8702); +float t8704 = (t8703+float(45.32)); +float t8705 = (t8704+u6.u0); +float t8706 = (t8703*t8705); +float t8707 = (t5902/t5463); +float t8708 = (t8707*float(1734.048)); +float t8709 = fract(t8708); +float t8710 = (t8709+float(45.32)); +float t8711 = (t8710+u6.u0); +float t8712 = (t8709*t8711); +float t8713 = (t8706+t8712); +float t8714 = (t8703+t8713); +float t8715 = (t8709+t8713); +float t8716 = (t8714*t8715); +float t8717 = fract(t8716); +float t8718 = (t8717*float(8.0e-3)); +float t8719 = (float(1.0e-3)+t8718); +float t8720 = (t8717*173); +float t8721 = fract(t8720); +float t8722 = step(float(0.66),t8721); +float t8723 = (t8722*float(3.0e-3)); +float t8724 = (t8719-t8723); +float t8725 = (t8724*float(0.45)); +float t8726 = (t8700-t8725); +float t8727 = abs(t8726); +float t8728 = (t8727-float(1.0e-3)); +float t8729 = (t8728/float(8.0e-3)); +float t8730 = (1-t8729); +float t8731 = (t8730*t8730); +float t8732 = (t8675*t8731); +float t8733 = (t8643*t8732); +float t8734 = (u4.u0*t8641); +float t8735 = (t8734*3); +float t8736 = sin(t8735); +float t8737 = (t8736+1); +float t8738 = (t8737/2); +float t8739 = (t8738*float(0.66)); +float t8740 = (t8739+float(0.33)); +float t8741 = (t8733*t8740); +float t8742 = (float(0.2)*t8741); +bool t8743 = (0>=t8742); +float t8744; +if(t8743){ +t8744 = 0; +} else { +t8744 = t8742; +} +float t8745 = (t8744*0); +float t8746 = (t8345+t8745); +float t8747 = (t5450*t5448); +float t8748 = (t5450/85); +float t8749 = (t8748*float(842.378)); +float t8750 = fract(t8749); +float t8751 = (t8750+float(45.32)); +float t8752 = (t8751+u6.u0); +float t8753 = (t8750*t8752); +float t8754 = (t5466+2); +float t8755 = (t8754/t6126); +float t8756 = (t8755*float(1734.048)); +float t8757 = fract(t8756); +float t8758 = (t8757+float(45.32)); +float t8759 = (t8758+u6.u0); +float t8760 = (t8757*t8759); +float t8761 = (t8753+t8760); +float t8762 = (t8750+t8761); +float t8763 = (t8757+t8761); +float t8764 = (t8762*t8763); +float t8765 = fract(t8764); +float t8766 = (t8765*float(2852.02)); +float t8767 = fract(t8766); +float t8768 = (t8767-float(0.5)); +float t8769 = (t8768*t5448); +float t8770 = (t8769*float(0.75)); +float t8771 = (t8747+t8770); +float t8772 = (3.1415927/2); +float t8773 = (t8771-t8772); +float t8774 = (t6113*t5448); +float t8775 = (t6113/85); +float t8776 = (t8775*float(842.378)); +float t8777 = fract(t8776); +float t8778 = (t8777+float(45.32)); +float t8779 = (t8778+u6.u0); +float t8780 = (t8777*t8779); +float t8781 = (t7149/t6126); +float t8782 = (t8781*float(1734.048)); +float t8783 = fract(t8782); +float t8784 = (t8783+float(45.32)); +float t8785 = (t8784+u6.u0); +float t8786 = (t8783*t8785); +float t8787 = (t8780+t8786); +float t8788 = (t8777+t8787); +float t8789 = (t8783+t8787); +float t8790 = (t8788*t8789); +float t8791 = fract(t8790); +float t8792 = (t8791*float(2852.02)); +float t8793 = fract(t8792); +float t8794 = (t8793-float(0.5)); +float t8795 = (t8794*t5448); +float t8796 = (t8795*float(0.75)); +float t8797 = (t8774+t8796); +float t8798 = (3.1415927/2); +float t8799 = (t8797-t8798); +float t8800 = (t8773-t8799); +float t8801 = abs(t8800); +float t8802 = (t8801/2); +float t8803 = sin(t8802); +float t8804 = (t8803*t8803); +float t8805 = cos(t8799); +float t8806 = cos(t8773); +float t8807 = (t8805*t8806); +float t8808 = (3.1415927/t6126); +float t8809 = (t8754*t8808); +float t8810 = (t8765*float(97372.83)); +float t8811 = fract(t8810); +float t8812 = (t8811-float(0.5)); +float t8813 = (3.1415927/t6126); +float t8814 = (t8812*t8813); +float t8815 = (t8814*float(0.75)); +float t8816 = (t8809+t8815); +float t8817 = (t8816+3.1415927); +float t8818 = mod(t8817,t1433); +float t8819 = (t8818-3.1415927); +float t8820 = (t8819+3.1415927); +float t8821 = (3.1415927*2); +float t8822 = mod(t8820,t8821); +float t8823 = (t8822-3.1415927); +float t8824 = (3.1415927/t6126); +float t8825 = (t7149*t8824); +float t8826 = (t8791*float(97372.83)); +float t8827 = fract(t8826); +float t8828 = (t8827-float(0.5)); +float t8829 = (3.1415927/t6126); +float t8830 = (t8828*t8829); +float t8831 = (t8830*float(0.75)); +float t8832 = (t8825+t8831); +float t8833 = (t8832+3.1415927); +float t8834 = mod(t8833,t1433); +float t8835 = (t8834-3.1415927); +float t8836 = (t8835+3.1415927); +float t8837 = (3.1415927*2); +float t8838 = mod(t8836,t8837); +float t8839 = (t8838-3.1415927); +float t8840 = (t8823-t8839); +float t8841 = abs(t8840); +float t8842 = (t8841/2); +float t8843 = sin(t8842); +float t8844 = (t8843*t8843); +float t8845 = (t8807*t8844); +float t8846 = (t8804+t8845); +float t8847 = sqrt(t8846); +float t8848 = asin(t8847); +float t8849 = (2*t8848); +float t8850 = (3.1415927/2); +float t8851 = (t8-t8850); +float t8852 = (3.1415927/2); +float t8853 = (t8797-t8852); +float t8854 = (t8851-t8853); +float t8855 = abs(t8854); +float t8856 = (t8855/2); +float t8857 = sin(t8856); +float t8858 = (t8857*t8857); +float t8859 = cos(t8853); +float t8860 = cos(t8851); +float t8861 = (t8859*t8860); +float t8862 = (t118+3.1415927); +float t8863 = (3.1415927*2); +float t8864 = mod(t8862,t8863); +float t8865 = (t8864-3.1415927); +float t8866 = (t8835+3.1415927); +float t8867 = (3.1415927*2); +float t8868 = mod(t8866,t8867); +float t8869 = (t8868-3.1415927); +float t8870 = (t8865-t8869); +float t8871 = abs(t8870); +float t8872 = (t8871/2); +float t8873 = sin(t8872); +float t8874 = (t8873*t8873); +float t8875 = (t8861*t8874); +float t8876 = (t8858+t8875); +float t8877 = sqrt(t8876); +float t8878 = asin(t8877); +float t8879 = (2*t8878); +float t8880 = (t8849-t8879); +float t8881 = (3.1415927/2); +float t8882 = (t8-t8881); +float t8883 = (3.1415927/2); +float t8884 = (t8771-t8883); +float t8885 = (t8882-t8884); +float t8886 = abs(t8885); +float t8887 = (t8886/2); +float t8888 = sin(t8887); +float t8889 = (t8888*t8888); +float t8890 = cos(t8884); +float t8891 = cos(t8882); +float t8892 = (t8890*t8891); +float t8893 = (t118+3.1415927); +float t8894 = (3.1415927*2); +float t8895 = mod(t8893,t8894); +float t8896 = (t8895-3.1415927); +float t8897 = (t8819+3.1415927); +float t8898 = (3.1415927*2); +float t8899 = mod(t8897,t8898); +float t8900 = (t8899-3.1415927); +float t8901 = (t8896-t8900); +float t8902 = abs(t8901); +float t8903 = (t8902/2); +float t8904 = sin(t8903); +float t8905 = (t8904*t8904); +float t8906 = (t8892*t8905); +float t8907 = (t8889+t8906); +float t8908 = sqrt(t8907); +float t8909 = asin(t8908); +float t8910 = (2*t8909); +float t8911 = (t8880-t8910); +float t8912 = abs(t8911); +bool t8913 = (float(1.0e-4)>t8912); +float t8914; +if(t8913){ +float t8915 = cos(t8797); +float t8916 = (1*t8915); +float t8917 = sin(t8771); +float t8918 = (1*t8917); +float t8919 = cos(t8819); +float t8920 = (t8918*t8919); +float t8921 = (t8916*t8920); +float t8922 = sin(t8797); +float t8923 = (1*t8922); +float t8924 = cos(t8835); +float t8925 = (t8923*t8924); +float t8926 = cos(t8771); +float t8927 = (1*t8926); +float t8928 = (t8925*t8927); +float t8929 = (t8921-t8928); +float t8930 = sin(t8); +float t8931 = (1*t8930); +float t8932 = sin(t118); +float t8933 = (t8931*t8932); +float t8934 = (t8929*t8933); +float t8935 = sin(t8771); +float t8936 = (1*t8935); +float t8937 = sin(t8819); +float t8938 = (t8936*t8937); +float t8939 = (t8925*t8938); +float t8940 = sin(t8797); +float t8941 = (1*t8940); +float t8942 = sin(t8835); +float t8943 = (t8941*t8942); +float t8944 = (t8943*t8920); +float t8945 = (t8939-t8944); +float t8946 = cos(t8); +float t8947 = (1*t8946); +float t8948 = (t8945*t8947); +float t8949 = (t8934+t8948); +float t8950 = (t8943*t8927); +float t8951 = (t8916*t8938); +float t8952 = (t8950-t8951); +float t8953 = sin(t8); +float t8954 = (1*t8953); +float t8955 = cos(t118); +float t8956 = (t8954*t8955); +float t8957 = (t8952*t8956); +float t8958 = (t8949+t8957); +float t8959 = abs(t8958); +t8914 = t8959; +} else { +float t8960 = (3.1415927/2); +float t8961 = (t8-t8960); +float t8962 = (3.1415927/2); +float t8963 = (t8771-t8962); +float t8964 = (t8961-t8963); +float t8965 = abs(t8964); +float t8966 = (t8965/2); +float t8967 = sin(t8966); +float t8968 = (t8967*t8967); +float t8969 = cos(t8963); +float t8970 = cos(t8961); +float t8971 = (t8969*t8970); +float t8972 = (t118+3.1415927); +float t8973 = (3.1415927*2); +float t8974 = mod(t8972,t8973); +float t8975 = (t8974-3.1415927); +float t8976 = (t8819+3.1415927); +float t8977 = (3.1415927*2); +float t8978 = mod(t8976,t8977); +float t8979 = (t8978-3.1415927); +float t8980 = (t8975-t8979); +float t8981 = abs(t8980); +float t8982 = (t8981/2); +float t8983 = sin(t8982); +float t8984 = (t8983*t8983); +float t8985 = (t8971*t8984); +float t8986 = (t8968+t8985); +float t8987 = sqrt(t8986); +float t8988 = asin(t8987); +float t8989 = (2*t8988); +float t8990 = abs(t8989); +float t8991 = (3.1415927/2); +float t8992 = (t8-t8991); +float t8993 = (3.1415927/2); +float t8994 = (t8797-t8993); +float t8995 = (t8992-t8994); +float t8996 = abs(t8995); +float t8997 = (t8996/2); +float t8998 = sin(t8997); +float t8999 = (t8998*t8998); +float t9000 = cos(t8994); +float t9001 = cos(t8992); +float t9002 = (t9000*t9001); +float t9003 = (t118+3.1415927); +float t9004 = (3.1415927*2); +float t9005 = mod(t9003,t9004); +float t9006 = (t9005-3.1415927); +float t9007 = (t8835+3.1415927); +float t9008 = (3.1415927*2); +float t9009 = mod(t9007,t9008); +float t9010 = (t9009-3.1415927); +float t9011 = (t9006-t9010); +float t9012 = abs(t9011); +float t9013 = (t9012/2); +float t9014 = sin(t9013); +float t9015 = (t9014*t9014); +float t9016 = (t9002*t9015); +float t9017 = (t8999+t9016); +float t9018 = sqrt(t9017); +float t9019 = asin(t9018); +float t9020 = (2*t9019); +float t9021 = abs(t9020); +bool t9022 = (t8990>=t9021); +float t9023; +if(t9022){ +t9023 = t8990; +} else { +t9023 = t9021; +} +t8914 = t9023; +} +float t9024 = abs(t8914); +float t9025 = step(float(2.0e-4),t9024); +float t9026 = (1-t9025); +float t9027 = (t6113*t8754); +float t9028 = (t9027*float(842.378)); +float t9029 = fract(t9028); +float t9030 = (t9029+float(45.32)); +float t9031 = (t9030+u6.u0); +float t9032 = (t9029*t9031); +float t9033 = (t7149*t5450); +float t9034 = (t9033*float(1734.048)); +float t9035 = fract(t9034); +float t9036 = (t9035+float(45.32)); +float t9037 = (t9036+u6.u0); +float t9038 = (t9035*t9037); +float t9039 = (t9032+t9038); +float t9040 = (t9029+t9039); +float t9041 = (t9035+t9039); +float t9042 = (t9040*t9041); +float t9043 = fract(t9042); +float t9044 = step(float(0.2),t9043); +float t9045 = (t9026*t9044); +float t9046 = (3.1415927/2); +float t9047 = (t8771-t9046); +float t9048 = (3.1415927/2); +float t9049 = (t8797-t9048); +float t9050 = (t9047-t9049); +float t9051 = abs(t9050); +float t9052 = (t9051/2); +float t9053 = sin(t9052); +float t9054 = (t9053*t9053); +float t9055 = cos(t9049); +float t9056 = cos(t9047); +float t9057 = (t9055*t9056); +float t9058 = (t8819+3.1415927); +float t9059 = (3.1415927*2); +float t9060 = mod(t9058,t9059); +float t9061 = (t9060-3.1415927); +float t9062 = (t8835+3.1415927); +float t9063 = (3.1415927*2); +float t9064 = mod(t9062,t9063); +float t9065 = (t9064-3.1415927); +float t9066 = (t9061-t9065); +float t9067 = abs(t9066); +float t9068 = (t9067/2); +float t9069 = sin(t9068); +float t9070 = (t9069*t9069); +float t9071 = (t9057*t9070); +float t9072 = (t9054+t9071); +float t9073 = sqrt(t9072); +float t9074 = asin(t9073); +float t9075 = (2*t9074); +float t9076 = (t9075/t5448); +float t9077 = (1-t9076); +float t9078 = (t6113/85); +float t9079 = (t9078*float(842.378)); +float t9080 = fract(t9079); +float t9081 = (t9080+float(45.32)); +float t9082 = (t9081+u6.u0); +float t9083 = (t9080*t9082); +float t9084 = (t7149/t6126); +float t9085 = (t9084*float(1734.048)); +float t9086 = fract(t9085); +float t9087 = (t9086+float(45.32)); +float t9088 = (t9087+u6.u0); +float t9089 = (t9086*t9088); +float t9090 = (t9083+t9089); +float t9091 = (t9080+t9090); +float t9092 = (t9086+t9090); +float t9093 = (t9091*t9092); +float t9094 = fract(t9093); +float t9095 = (t9094*float(8.0e-3)); +float t9096 = (float(1.0e-3)+t9095); +float t9097 = (t9094*173); +float t9098 = fract(t9097); +float t9099 = step(float(0.66),t9098); +float t9100 = (t9099*float(3.0e-3)); +float t9101 = (t9096-t9100); +float t9102 = (t9101*float(0.45)); +float t9103 = (t5450/85); +float t9104 = (t9103*float(842.378)); +float t9105 = fract(t9104); +float t9106 = (t9105+float(45.32)); +float t9107 = (t9106+u6.u0); +float t9108 = (t9105*t9107); +float t9109 = (t8754/t6126); +float t9110 = (t9109*float(1734.048)); +float t9111 = fract(t9110); +float t9112 = (t9111+float(45.32)); +float t9113 = (t9112+u6.u0); +float t9114 = (t9111*t9113); +float t9115 = (t9108+t9114); +float t9116 = (t9105+t9115); +float t9117 = (t9111+t9115); +float t9118 = (t9116*t9117); +float t9119 = fract(t9118); +float t9120 = (t9119*float(8.0e-3)); +float t9121 = (float(1.0e-3)+t9120); +float t9122 = (t9119*173); +float t9123 = fract(t9122); +float t9124 = step(float(0.66),t9123); +float t9125 = (t9124*float(3.0e-3)); +float t9126 = (t9121-t9125); +float t9127 = (t9126*float(0.45)); +float t9128 = (t9102-t9127); +float t9129 = abs(t9128); +float t9130 = (t9129-float(1.0e-3)); +float t9131 = (t9130/float(8.0e-3)); +float t9132 = (1-t9131); +float t9133 = (t9132*t9132); +float t9134 = (t9077*t9133); +float t9135 = (t9045*t9134); +float t9136 = (u4.u0*t9043); +float t9137 = (t9136*3); +float t9138 = sin(t9137); +float t9139 = (t9138+1); +float t9140 = (t9139/2); +float t9141 = (t9140*float(0.66)); +float t9142 = (t9141+float(0.33)); +float t9143 = (t9135*t9142); +float t9144 = (float(0.2)*t9143); +bool t9145 = (0>=t9144); +float t9146; +if(t9145){ +t9146 = 0; +} else { +t9146 = t9144; +} +float t9147 = (t9146*0); +float t9148 = (t8746+t9147); +float t9149 = (t5450*t5448); +float t9150 = (t5450/85); +float t9151 = (t9150*float(842.378)); +float t9152 = fract(t9151); +float t9153 = (t9152+float(45.32)); +float t9154 = (t9153+u6.u0); +float t9155 = (t9152*t9154); +float t9156 = (t8754/t6126); +float t9157 = (t9156*float(1734.048)); +float t9158 = fract(t9157); +float t9159 = (t9158+float(45.32)); +float t9160 = (t9159+u6.u0); +float t9161 = (t9158*t9160); +float t9162 = (t9155+t9161); +float t9163 = (t9152+t9162); +float t9164 = (t9158+t9162); +float t9165 = (t9163*t9164); +float t9166 = fract(t9165); +float t9167 = (t9166*float(2852.02)); +float t9168 = fract(t9167); +float t9169 = (t9168-float(0.5)); +float t9170 = (t9169*t5448); +float t9171 = (t9170*float(0.75)); +float t9172 = (t9149+t9171); +float t9173 = (3.1415927/2); +float t9174 = (t9172-t9173); +float t9175 = (t5450*t5448); +float t9176 = (t5450/85); +float t9177 = (t9176*float(842.378)); +float t9178 = fract(t9177); +float t9179 = (t9178+float(45.32)); +float t9180 = (t9179+u6.u0); +float t9181 = (t9178*t9180); +float t9182 = (t5902/t5463); +float t9183 = (t9182*float(1734.048)); +float t9184 = fract(t9183); +float t9185 = (t9184+float(45.32)); +float t9186 = (t9185+u6.u0); +float t9187 = (t9184*t9186); +float t9188 = (t9181+t9187); +float t9189 = (t9178+t9188); +float t9190 = (t9184+t9188); +float t9191 = (t9189*t9190); +float t9192 = fract(t9191); +float t9193 = (t9192*float(2852.02)); +float t9194 = fract(t9193); +float t9195 = (t9194-float(0.5)); +float t9196 = (t9195*t5448); +float t9197 = (t9196*float(0.75)); +float t9198 = (t9175+t9197); +float t9199 = (3.1415927/2); +float t9200 = (t9198-t9199); +float t9201 = (t9174-t9200); +float t9202 = abs(t9201); +float t9203 = (t9202/2); +float t9204 = sin(t9203); +float t9205 = (t9204*t9204); +float t9206 = cos(t9200); +float t9207 = cos(t9174); +float t9208 = (t9206*t9207); +float t9209 = (3.1415927/t6126); +float t9210 = (t8754*t9209); +float t9211 = (t9166*float(97372.83)); +float t9212 = fract(t9211); +float t9213 = (t9212-float(0.5)); +float t9214 = (3.1415927/t6126); +float t9215 = (t9213*t9214); +float t9216 = (t9215*float(0.75)); +float t9217 = (t9210+t9216); +float t9218 = (t9217+3.1415927); +float t9219 = mod(t9218,t1433); +float t9220 = (t9219-3.1415927); +float t9221 = (t9220+3.1415927); +float t9222 = (3.1415927*2); +float t9223 = mod(t9221,t9222); +float t9224 = (t9223-3.1415927); +float t9225 = (3.1415927/t5463); +float t9226 = (t5902*t9225); +float t9227 = (t9192*float(97372.83)); +float t9228 = fract(t9227); +float t9229 = (t9228-float(0.5)); +float t9230 = (3.1415927/t5463); +float t9231 = (t9229*t9230); +float t9232 = (t9231*float(0.75)); +float t9233 = (t9226+t9232); +float t9234 = (t9233+3.1415927); +float t9235 = mod(t9234,t1433); +float t9236 = (t9235-3.1415927); +float t9237 = (t9236+3.1415927); +float t9238 = (3.1415927*2); +float t9239 = mod(t9237,t9238); +float t9240 = (t9239-3.1415927); +float t9241 = (t9224-t9240); +float t9242 = abs(t9241); +float t9243 = (t9242/2); +float t9244 = sin(t9243); +float t9245 = (t9244*t9244); +float t9246 = (t9208*t9245); +float t9247 = (t9205+t9246); +float t9248 = sqrt(t9247); +float t9249 = asin(t9248); +float t9250 = (2*t9249); +float t9251 = (3.1415927/2); +float t9252 = (t8-t9251); +float t9253 = (3.1415927/2); +float t9254 = (t9198-t9253); +float t9255 = (t9252-t9254); +float t9256 = abs(t9255); +float t9257 = (t9256/2); +float t9258 = sin(t9257); +float t9259 = (t9258*t9258); +float t9260 = cos(t9254); +float t9261 = cos(t9252); +float t9262 = (t9260*t9261); +float t9263 = (t118+3.1415927); +float t9264 = (3.1415927*2); +float t9265 = mod(t9263,t9264); +float t9266 = (t9265-3.1415927); +float t9267 = (t9236+3.1415927); +float t9268 = (3.1415927*2); +float t9269 = mod(t9267,t9268); +float t9270 = (t9269-3.1415927); +float t9271 = (t9266-t9270); +float t9272 = abs(t9271); +float t9273 = (t9272/2); +float t9274 = sin(t9273); +float t9275 = (t9274*t9274); +float t9276 = (t9262*t9275); +float t9277 = (t9259+t9276); +float t9278 = sqrt(t9277); +float t9279 = asin(t9278); +float t9280 = (2*t9279); +float t9281 = (t9250-t9280); +float t9282 = (3.1415927/2); +float t9283 = (t8-t9282); +float t9284 = (3.1415927/2); +float t9285 = (t9172-t9284); +float t9286 = (t9283-t9285); +float t9287 = abs(t9286); +float t9288 = (t9287/2); +float t9289 = sin(t9288); +float t9290 = (t9289*t9289); +float t9291 = cos(t9285); +float t9292 = cos(t9283); +float t9293 = (t9291*t9292); +float t9294 = (t118+3.1415927); +float t9295 = (3.1415927*2); +float t9296 = mod(t9294,t9295); +float t9297 = (t9296-3.1415927); +float t9298 = (t9220+3.1415927); +float t9299 = (3.1415927*2); +float t9300 = mod(t9298,t9299); +float t9301 = (t9300-3.1415927); +float t9302 = (t9297-t9301); +float t9303 = abs(t9302); +float t9304 = (t9303/2); +float t9305 = sin(t9304); +float t9306 = (t9305*t9305); +float t9307 = (t9293*t9306); +float t9308 = (t9290+t9307); +float t9309 = sqrt(t9308); +float t9310 = asin(t9309); +float t9311 = (2*t9310); +float t9312 = (t9281-t9311); +float t9313 = abs(t9312); +bool t9314 = (float(1.0e-4)>t9313); +float t9315; +if(t9314){ +float t9316 = cos(t9198); +float t9317 = (1*t9316); +float t9318 = sin(t9172); +float t9319 = (1*t9318); +float t9320 = cos(t9220); +float t9321 = (t9319*t9320); +float t9322 = (t9317*t9321); +float t9323 = sin(t9198); +float t9324 = (1*t9323); +float t9325 = cos(t9236); +float t9326 = (t9324*t9325); +float t9327 = cos(t9172); +float t9328 = (1*t9327); +float t9329 = (t9326*t9328); +float t9330 = (t9322-t9329); +float t9331 = sin(t8); +float t9332 = (1*t9331); +float t9333 = sin(t118); +float t9334 = (t9332*t9333); +float t9335 = (t9330*t9334); +float t9336 = sin(t9172); +float t9337 = (1*t9336); +float t9338 = sin(t9220); +float t9339 = (t9337*t9338); +float t9340 = (t9326*t9339); +float t9341 = sin(t9198); +float t9342 = (1*t9341); +float t9343 = sin(t9236); +float t9344 = (t9342*t9343); +float t9345 = (t9344*t9321); +float t9346 = (t9340-t9345); +float t9347 = cos(t8); +float t9348 = (1*t9347); +float t9349 = (t9346*t9348); +float t9350 = (t9335+t9349); +float t9351 = (t9344*t9328); +float t9352 = (t9317*t9339); +float t9353 = (t9351-t9352); +float t9354 = sin(t8); +float t9355 = (1*t9354); +float t9356 = cos(t118); +float t9357 = (t9355*t9356); +float t9358 = (t9353*t9357); +float t9359 = (t9350+t9358); +float t9360 = abs(t9359); +t9315 = t9360; +} else { +float t9361 = (3.1415927/2); +float t9362 = (t8-t9361); +float t9363 = (3.1415927/2); +float t9364 = (t9172-t9363); +float t9365 = (t9362-t9364); +float t9366 = abs(t9365); +float t9367 = (t9366/2); +float t9368 = sin(t9367); +float t9369 = (t9368*t9368); +float t9370 = cos(t9364); +float t9371 = cos(t9362); +float t9372 = (t9370*t9371); +float t9373 = (t118+3.1415927); +float t9374 = (3.1415927*2); +float t9375 = mod(t9373,t9374); +float t9376 = (t9375-3.1415927); +float t9377 = (t9220+3.1415927); +float t9378 = (3.1415927*2); +float t9379 = mod(t9377,t9378); +float t9380 = (t9379-3.1415927); +float t9381 = (t9376-t9380); +float t9382 = abs(t9381); +float t9383 = (t9382/2); +float t9384 = sin(t9383); +float t9385 = (t9384*t9384); +float t9386 = (t9372*t9385); +float t9387 = (t9369+t9386); +float t9388 = sqrt(t9387); +float t9389 = asin(t9388); +float t9390 = (2*t9389); +float t9391 = abs(t9390); +float t9392 = (3.1415927/2); +float t9393 = (t8-t9392); +float t9394 = (3.1415927/2); +float t9395 = (t9198-t9394); +float t9396 = (t9393-t9395); +float t9397 = abs(t9396); +float t9398 = (t9397/2); +float t9399 = sin(t9398); +float t9400 = (t9399*t9399); +float t9401 = cos(t9395); +float t9402 = cos(t9393); +float t9403 = (t9401*t9402); +float t9404 = (t118+3.1415927); +float t9405 = (3.1415927*2); +float t9406 = mod(t9404,t9405); +float t9407 = (t9406-3.1415927); +float t9408 = (t9236+3.1415927); +float t9409 = (3.1415927*2); +float t9410 = mod(t9408,t9409); +float t9411 = (t9410-3.1415927); +float t9412 = (t9407-t9411); +float t9413 = abs(t9412); +float t9414 = (t9413/2); +float t9415 = sin(t9414); +float t9416 = (t9415*t9415); +float t9417 = (t9403*t9416); +float t9418 = (t9400+t9417); +float t9419 = sqrt(t9418); +float t9420 = asin(t9419); +float t9421 = (2*t9420); +float t9422 = abs(t9421); +bool t9423 = (t9391>=t9422); +float t9424; +if(t9423){ +t9424 = t9391; +} else { +t9424 = t9422; +} +t9315 = t9424; +} +float t9425 = abs(t9315); +float t9426 = step(float(2.0e-4),t9425); +float t9427 = (1-t9426); +float t9428 = (t5450*t8754); +float t9429 = (t9428*float(842.378)); +float t9430 = fract(t9429); +float t9431 = (t9430+float(45.32)); +float t9432 = (t9431+u6.u0); +float t9433 = (t9430*t9432); +float t9434 = (t5902*t5450); +float t9435 = (t9434*float(1734.048)); +float t9436 = fract(t9435); +float t9437 = (t9436+float(45.32)); +float t9438 = (t9437+u6.u0); +float t9439 = (t9436*t9438); +float t9440 = (t9433+t9439); +float t9441 = (t9430+t9440); +float t9442 = (t9436+t9440); +float t9443 = (t9441*t9442); +float t9444 = fract(t9443); +float t9445 = step(float(0.2),t9444); +float t9446 = (t9427*t9445); +float t9447 = (3.1415927/2); +float t9448 = (t9172-t9447); +float t9449 = (3.1415927/2); +float t9450 = (t9198-t9449); +float t9451 = (t9448-t9450); +float t9452 = abs(t9451); +float t9453 = (t9452/2); +float t9454 = sin(t9453); +float t9455 = (t9454*t9454); +float t9456 = cos(t9450); +float t9457 = cos(t9448); +float t9458 = (t9456*t9457); +float t9459 = (t9220+3.1415927); +float t9460 = (3.1415927*2); +float t9461 = mod(t9459,t9460); +float t9462 = (t9461-3.1415927); +float t9463 = (t9236+3.1415927); +float t9464 = (3.1415927*2); +float t9465 = mod(t9463,t9464); +float t9466 = (t9465-3.1415927); +float t9467 = (t9462-t9466); +float t9468 = abs(t9467); +float t9469 = (t9468/2); +float t9470 = sin(t9469); +float t9471 = (t9470*t9470); +float t9472 = (t9458*t9471); +float t9473 = (t9455+t9472); +float t9474 = sqrt(t9473); +float t9475 = asin(t9474); +float t9476 = (2*t9475); +float t9477 = (t9476/t5448); +float t9478 = (1-t9477); +float t9479 = (t5450/85); +float t9480 = (t9479*float(842.378)); +float t9481 = fract(t9480); +float t9482 = (t9481+float(45.32)); +float t9483 = (t9482+u6.u0); +float t9484 = (t9481*t9483); +float t9485 = (t5902/t5463); +float t9486 = (t9485*float(1734.048)); +float t9487 = fract(t9486); +float t9488 = (t9487+float(45.32)); +float t9489 = (t9488+u6.u0); +float t9490 = (t9487*t9489); +float t9491 = (t9484+t9490); +float t9492 = (t9481+t9491); +float t9493 = (t9487+t9491); +float t9494 = (t9492*t9493); +float t9495 = fract(t9494); +float t9496 = (t9495*float(8.0e-3)); +float t9497 = (float(1.0e-3)+t9496); +float t9498 = (t9495*173); +float t9499 = fract(t9498); +float t9500 = step(float(0.66),t9499); +float t9501 = (t9500*float(3.0e-3)); +float t9502 = (t9497-t9501); +float t9503 = (t9502*float(0.45)); +float t9504 = (t5450/85); +float t9505 = (t9504*float(842.378)); +float t9506 = fract(t9505); +float t9507 = (t9506+float(45.32)); +float t9508 = (t9507+u6.u0); +float t9509 = (t9506*t9508); +float t9510 = (t8754/t6126); +float t9511 = (t9510*float(1734.048)); +float t9512 = fract(t9511); +float t9513 = (t9512+float(45.32)); +float t9514 = (t9513+u6.u0); +float t9515 = (t9512*t9514); +float t9516 = (t9509+t9515); +float t9517 = (t9506+t9516); +float t9518 = (t9512+t9516); +float t9519 = (t9517*t9518); +float t9520 = fract(t9519); +float t9521 = (t9520*float(8.0e-3)); +float t9522 = (float(1.0e-3)+t9521); +float t9523 = (t9520*173); +float t9524 = fract(t9523); +float t9525 = step(float(0.66),t9524); +float t9526 = (t9525*float(3.0e-3)); +float t9527 = (t9522-t9526); +float t9528 = (t9527*float(0.45)); +float t9529 = (t9503-t9528); +float t9530 = abs(t9529); +float t9531 = (t9530-float(1.0e-3)); +float t9532 = (t9531/float(8.0e-3)); +float t9533 = (1-t9532); +float t9534 = (t9533*t9533); +float t9535 = (t9478*t9534); +float t9536 = (t9446*t9535); +float t9537 = (u4.u0*t9444); +float t9538 = (t9537*3); +float t9539 = sin(t9538); +float t9540 = (t9539+1); +float t9541 = (t9540/2); +float t9542 = (t9541*float(0.66)); +float t9543 = (t9542+float(0.33)); +float t9544 = (t9536*t9543); +float t9545 = (float(0.2)*t9544); +bool t9546 = (0>=t9545); +float t9547; +if(t9546){ +t9547 = 0; +} else { +t9547 = t9545; +} +float t9548 = (t9547*0); +float t9549 = (t9148+t9548); +float t9550 = (t9549*float(0.33)); +float t9551 = (t5447+t9550); +float t9552 = cos(float(1.46)); +float t9553 = (1*t9552); +float t9554 = sin(float(1.15)); +float t9555 = (1*t9554); +float t9556 = (-float(0.24)); +float t9557 = cos(t9556); +float t9558 = (t9555*t9557); +float t9559 = (t9553*t9558); +float t9560 = sin(float(1.46)); +float t9561 = (1*t9560); +float t9562 = (float(0.93)*float(842.378)); +float t9563 = fract(t9562); +float t9564 = (t9563+float(45.32)); +float t9565 = (t9564+u6.u0); +float t9566 = (t9563*t9565); +float t9567 = (float(1.245)*float(1734.048)); +float t9568 = fract(t9567); +float t9569 = (t9568+float(45.32)); +float t9570 = (t9569+u6.u0); +float t9571 = (t9568*t9570); +float t9572 = (t9566+t9571); +float t9573 = (t9563+t9572); +float t9574 = (t9568+t9572); +float t9575 = (t9573*t9574); +float t9576 = fract(t9575); +float t9577 = (t9576*3.1415927); +float t9578 = cos(t9577); +float t9579 = (t9561*t9578); +float t9580 = cos(float(1.15)); +float t9581 = (1*t9580); +float t9582 = (t9579*t9581); +float t9583 = (t9559-t9582); +float t9584 = sin(t8); +float t9585 = (1*t9584); +float t9586 = sin(t118); +float t9587 = (t9585*t9586); +float t9588 = (t9583*t9587); +float t9589 = sin(float(1.15)); +float t9590 = (1*t9589); +float t9591 = sin(t9556); +float t9592 = (t9590*t9591); +float t9593 = (t9579*t9592); +float t9594 = sin(float(1.46)); +float t9595 = (1*t9594); +float t9596 = sin(t9577); +float t9597 = (t9595*t9596); +float t9598 = (t9597*t9558); +float t9599 = (t9593-t9598); +float t9600 = cos(t8); +float t9601 = (1*t9600); +float t9602 = (t9599*t9601); +float t9603 = (t9588+t9602); +float t9604 = (t9597*t9581); +float t9605 = (t9553*t9592); +float t9606 = (t9604-t9605); +float t9607 = sin(t8); +float t9608 = (1*t9607); +float t9609 = cos(t118); +float t9610 = (t9608*t9609); +float t9611 = (t9606*t9610); +float t9612 = (t9603+t9611); +float t9613 = abs(t9612); +float t9614 = (t8/3.1415927); +float t9615 = fract(t9614); +float t9616 = (t9615*16); +float t9617 = floor(t9616); +float t9618 = (t9617*float(842.378)); +float t9619 = fract(t9618); +float t9620 = (t9619+float(45.32)); +float t9621 = (t9620+u6.u0); +float t9622 = (t9619*t9621); +float t9623 = (t118/3.1415927); +float t9624 = fract(t9623); +float t9625 = (t9624*16); +float t9626 = floor(t9625); +float t9627 = (t9626*float(1734.048)); +float t9628 = fract(t9627); +float t9629 = (t9628+float(45.32)); +float t9630 = (t9629+u6.u0); +float t9631 = (t9628*t9630); +float t9632 = (t9622+t9631); +float t9633 = (t9619+t9632); +float t9634 = (t9628+t9632); +float t9635 = (t9633*t9634); +float t9636 = fract(t9635); +float t9637 = fract(t9616); +float t9638 = (t9637*3.1415927); +float t9639 = cos(t9638); +float t9640 = (t9639/2); +float t9641 = (t9640+float(0.5)); +float t9642 = (1-t9641); +float t9643 = (1-t9642); +float t9644 = (t9636*t9643); +float t9645 = (t9617+1); +float t9646 = mod(t9645,16); +float t9647 = (t9646*float(842.378)); +float t9648 = fract(t9647); +float t9649 = (t9648+float(45.32)); +float t9650 = (t9649+u6.u0); +float t9651 = (t9648*t9650); +float t9652 = (t9626*float(1734.048)); +float t9653 = fract(t9652); +float t9654 = (t9653+float(45.32)); +float t9655 = (t9654+u6.u0); +float t9656 = (t9653*t9655); +float t9657 = (t9651+t9656); +float t9658 = (t9648+t9657); +float t9659 = (t9653+t9657); +float t9660 = (t9658*t9659); +float t9661 = fract(t9660); +float t9662 = (t9661*t9642); +float t9663 = (t9644+t9662); +float t9664 = fract(t9625); +float t9665 = (t9664*3.1415927); +float t9666 = cos(t9665); +float t9667 = (t9666/2); +float t9668 = (t9667+float(0.5)); +float t9669 = (1-t9668); +float t9670 = (1-t9669); +float t9671 = (t9663*t9670); +float t9672 = (t9617*float(842.378)); +float t9673 = fract(t9672); +float t9674 = (t9673+float(45.32)); +float t9675 = (t9674+u6.u0); +float t9676 = (t9673*t9675); +float t9677 = (t9626+1); +float t9678 = mod(t9677,16); +float t9679 = (t9678*float(1734.048)); +float t9680 = fract(t9679); +float t9681 = (t9680+float(45.32)); +float t9682 = (t9681+u6.u0); +float t9683 = (t9680*t9682); +float t9684 = (t9676+t9683); +float t9685 = (t9673+t9684); +float t9686 = (t9680+t9684); +float t9687 = (t9685*t9686); +float t9688 = fract(t9687); +float t9689 = (t9688*t9643); +float t9690 = (t9646*float(842.378)); +float t9691 = fract(t9690); +float t9692 = (t9691+float(45.32)); +float t9693 = (t9692+u6.u0); +float t9694 = (t9691*t9693); +float t9695 = (t9678*float(1734.048)); +float t9696 = fract(t9695); +float t9697 = (t9696+float(45.32)); +float t9698 = (t9697+u6.u0); +float t9699 = (t9696*t9698); +float t9700 = (t9694+t9699); +float t9701 = (t9691+t9700); +float t9702 = (t9696+t9700); +float t9703 = (t9701*t9702); +float t9704 = fract(t9703); +float t9705 = (t9704*t9642); +float t9706 = (t9689+t9705); +float t9707 = (t9706*t9669); +float t9708 = (t9671+t9707); +float t9709 = (t9708*float(0.5)); +float t9710 = (t9615*32); +float t9711 = floor(t9710); +float t9712 = (t9711*float(842.378)); +float t9713 = fract(t9712); +float t9714 = (t9713+float(45.32)); +float t9715 = (t9714+u6.u0); +float t9716 = (t9713*t9715); +float t9717 = (t9624*32); +float t9718 = floor(t9717); +float t9719 = (t9718*float(1734.048)); +float t9720 = fract(t9719); +float t9721 = (t9720+float(45.32)); +float t9722 = (t9721+u6.u0); +float t9723 = (t9720*t9722); +float t9724 = (t9716+t9723); +float t9725 = (t9713+t9724); +float t9726 = (t9720+t9724); +float t9727 = (t9725*t9726); +float t9728 = fract(t9727); +float t9729 = fract(t9710); +float t9730 = (t9729*3.1415927); +float t9731 = cos(t9730); +float t9732 = (t9731/2); +float t9733 = (t9732+float(0.5)); +float t9734 = (1-t9733); +float t9735 = (1-t9734); +float t9736 = (t9728*t9735); +float t9737 = (t9711+1); +float t9738 = mod(t9737,32); +float t9739 = (t9738*float(842.378)); +float t9740 = fract(t9739); +float t9741 = (t9740+float(45.32)); +float t9742 = (t9741+u6.u0); +float t9743 = (t9740*t9742); +float t9744 = (t9718*float(1734.048)); +float t9745 = fract(t9744); +float t9746 = (t9745+float(45.32)); +float t9747 = (t9746+u6.u0); +float t9748 = (t9745*t9747); +float t9749 = (t9743+t9748); +float t9750 = (t9740+t9749); +float t9751 = (t9745+t9749); +float t9752 = (t9750*t9751); +float t9753 = fract(t9752); +float t9754 = (t9753*t9734); +float t9755 = (t9736+t9754); +float t9756 = fract(t9717); +float t9757 = (t9756*3.1415927); +float t9758 = cos(t9757); +float t9759 = (t9758/2); +float t9760 = (t9759+float(0.5)); +float t9761 = (1-t9760); +float t9762 = (1-t9761); +float t9763 = (t9755*t9762); +float t9764 = (t9711*float(842.378)); +float t9765 = fract(t9764); +float t9766 = (t9765+float(45.32)); +float t9767 = (t9766+u6.u0); +float t9768 = (t9765*t9767); +float t9769 = (t9718+1); +float t9770 = mod(t9769,32); +float t9771 = (t9770*float(1734.048)); +float t9772 = fract(t9771); +float t9773 = (t9772+float(45.32)); +float t9774 = (t9773+u6.u0); +float t9775 = (t9772*t9774); +float t9776 = (t9768+t9775); +float t9777 = (t9765+t9776); +float t9778 = (t9772+t9776); +float t9779 = (t9777*t9778); +float t9780 = fract(t9779); +float t9781 = (t9780*t9735); +float t9782 = (t9738*float(842.378)); +float t9783 = fract(t9782); +float t9784 = (t9783+float(45.32)); +float t9785 = (t9784+u6.u0); +float t9786 = (t9783*t9785); +float t9787 = (t9770*float(1734.048)); +float t9788 = fract(t9787); +float t9789 = (t9788+float(45.32)); +float t9790 = (t9789+u6.u0); +float t9791 = (t9788*t9790); +float t9792 = (t9786+t9791); +float t9793 = (t9783+t9792); +float t9794 = (t9788+t9792); +float t9795 = (t9793*t9794); +float t9796 = fract(t9795); +float t9797 = (t9796*t9734); +float t9798 = (t9781+t9797); +float t9799 = (t9798*t9761); +float t9800 = (t9763+t9799); +float t9801 = (t9800*float(0.25)); +float t9802 = (t9709+t9801); +float t9803 = (t9615*64); +float t9804 = floor(t9803); +float t9805 = (t9804*float(842.378)); +float t9806 = fract(t9805); +float t9807 = (t9806+float(45.32)); +float t9808 = (t9807+u6.u0); +float t9809 = (t9806*t9808); +float t9810 = (t9624*64); +float t9811 = floor(t9810); +float t9812 = (t9811*float(1734.048)); +float t9813 = fract(t9812); +float t9814 = (t9813+float(45.32)); +float t9815 = (t9814+u6.u0); +float t9816 = (t9813*t9815); +float t9817 = (t9809+t9816); +float t9818 = (t9806+t9817); +float t9819 = (t9813+t9817); +float t9820 = (t9818*t9819); +float t9821 = fract(t9820); +float t9822 = fract(t9803); +float t9823 = (t9822*3.1415927); +float t9824 = cos(t9823); +float t9825 = (t9824/2); +float t9826 = (t9825+float(0.5)); +float t9827 = (1-t9826); +float t9828 = (1-t9827); +float t9829 = (t9821*t9828); +float t9830 = (t9804+1); +float t9831 = mod(t9830,64); +float t9832 = (t9831*float(842.378)); +float t9833 = fract(t9832); +float t9834 = (t9833+float(45.32)); +float t9835 = (t9834+u6.u0); +float t9836 = (t9833*t9835); +float t9837 = (t9811*float(1734.048)); +float t9838 = fract(t9837); +float t9839 = (t9838+float(45.32)); +float t9840 = (t9839+u6.u0); +float t9841 = (t9838*t9840); +float t9842 = (t9836+t9841); +float t9843 = (t9833+t9842); +float t9844 = (t9838+t9842); +float t9845 = (t9843*t9844); +float t9846 = fract(t9845); +float t9847 = (t9846*t9827); +float t9848 = (t9829+t9847); +float t9849 = fract(t9810); +float t9850 = (t9849*3.1415927); +float t9851 = cos(t9850); +float t9852 = (t9851/2); +float t9853 = (t9852+float(0.5)); +float t9854 = (1-t9853); +float t9855 = (1-t9854); +float t9856 = (t9848*t9855); +float t9857 = (t9804*float(842.378)); +float t9858 = fract(t9857); +float t9859 = (t9858+float(45.32)); +float t9860 = (t9859+u6.u0); +float t9861 = (t9858*t9860); +float t9862 = (t9811+1); +float t9863 = mod(t9862,64); +float t9864 = (t9863*float(1734.048)); +float t9865 = fract(t9864); +float t9866 = (t9865+float(45.32)); +float t9867 = (t9866+u6.u0); +float t9868 = (t9865*t9867); +float t9869 = (t9861+t9868); +float t9870 = (t9858+t9869); +float t9871 = (t9865+t9869); +float t9872 = (t9870*t9871); +float t9873 = fract(t9872); +float t9874 = (t9873*t9828); +float t9875 = (t9831*float(842.378)); +float t9876 = fract(t9875); +float t9877 = (t9876+float(45.32)); +float t9878 = (t9877+u6.u0); +float t9879 = (t9876*t9878); +float t9880 = (t9863*float(1734.048)); +float t9881 = fract(t9880); +float t9882 = (t9881+float(45.32)); +float t9883 = (t9882+u6.u0); +float t9884 = (t9881*t9883); +float t9885 = (t9879+t9884); +float t9886 = (t9876+t9885); +float t9887 = (t9881+t9885); +float t9888 = (t9886*t9887); +float t9889 = fract(t9888); +float t9890 = (t9889*t9827); +float t9891 = (t9874+t9890); +float t9892 = (t9891*t9854); +float t9893 = (t9856+t9892); +float t9894 = (t9893*float(0.125)); +float t9895 = (t9802+t9894); +float t9896 = (t9615*128); +float t9897 = floor(t9896); +float t9898 = (t9897*float(842.378)); +float t9899 = fract(t9898); +float t9900 = (t9899+float(45.32)); +float t9901 = (t9900+u6.u0); +float t9902 = (t9899*t9901); +float t9903 = (t9624*128); +float t9904 = floor(t9903); +float t9905 = (t9904*float(1734.048)); +float t9906 = fract(t9905); +float t9907 = (t9906+float(45.32)); +float t9908 = (t9907+u6.u0); +float t9909 = (t9906*t9908); +float t9910 = (t9902+t9909); +float t9911 = (t9899+t9910); +float t9912 = (t9906+t9910); +float t9913 = (t9911*t9912); +float t9914 = fract(t9913); +float t9915 = fract(t9896); +float t9916 = (t9915*3.1415927); +float t9917 = cos(t9916); +float t9918 = (t9917/2); +float t9919 = (t9918+float(0.5)); +float t9920 = (1-t9919); +float t9921 = (1-t9920); +float t9922 = (t9914*t9921); +float t9923 = (t9897+1); +float t9924 = mod(t9923,128); +float t9925 = (t9924*float(842.378)); +float t9926 = fract(t9925); +float t9927 = (t9926+float(45.32)); +float t9928 = (t9927+u6.u0); +float t9929 = (t9926*t9928); +float t9930 = (t9904*float(1734.048)); +float t9931 = fract(t9930); +float t9932 = (t9931+float(45.32)); +float t9933 = (t9932+u6.u0); +float t9934 = (t9931*t9933); +float t9935 = (t9929+t9934); +float t9936 = (t9926+t9935); +float t9937 = (t9931+t9935); +float t9938 = (t9936*t9937); +float t9939 = fract(t9938); +float t9940 = (t9939*t9920); +float t9941 = (t9922+t9940); +float t9942 = fract(t9903); +float t9943 = (t9942*3.1415927); +float t9944 = cos(t9943); +float t9945 = (t9944/2); +float t9946 = (t9945+float(0.5)); +float t9947 = (1-t9946); +float t9948 = (1-t9947); +float t9949 = (t9941*t9948); +float t9950 = (t9897*float(842.378)); +float t9951 = fract(t9950); +float t9952 = (t9951+float(45.32)); +float t9953 = (t9952+u6.u0); +float t9954 = (t9951*t9953); +float t9955 = (t9904+1); +float t9956 = mod(t9955,128); +float t9957 = (t9956*float(1734.048)); +float t9958 = fract(t9957); +float t9959 = (t9958+float(45.32)); +float t9960 = (t9959+u6.u0); +float t9961 = (t9958*t9960); +float t9962 = (t9954+t9961); +float t9963 = (t9951+t9962); +float t9964 = (t9958+t9962); +float t9965 = (t9963*t9964); +float t9966 = fract(t9965); +float t9967 = (t9966*t9921); +float t9968 = (t9924*float(842.378)); +float t9969 = fract(t9968); +float t9970 = (t9969+float(45.32)); +float t9971 = (t9970+u6.u0); +float t9972 = (t9969*t9971); +float t9973 = (t9956*float(1734.048)); +float t9974 = fract(t9973); +float t9975 = (t9974+float(45.32)); +float t9976 = (t9975+u6.u0); +float t9977 = (t9974*t9976); +float t9978 = (t9972+t9977); +float t9979 = (t9969+t9978); +float t9980 = (t9974+t9978); +float t9981 = (t9979*t9980); +float t9982 = fract(t9981); +float t9983 = (t9982*t9920); +float t9984 = (t9967+t9983); +float t9985 = (t9984*t9947); +float t9986 = (t9949+t9985); +float t9987 = (t9986*float(6.25e-2)); +float t9988 = (t9895+t9987); +float t9989 = (t9988*float(0.25)); +float t9990 = (t9989-float(0.125)); +float t9991 = (t9613+t9990); +float t9992 = smoothstep(float(0.0),float(0.32),t9991); +float t9993 = (1-t9992); +float t9994 = (t9993*float(1.1)); +float t9995 = fract(t9994); +float t9996 = (t9995*t9995); +float t9997 = (t9996*float(5.0e-2)); +float t9998 = (3.1415927/245); +float t9999 = (t8/t9998); +float t10000 = floor(t9999); +float t10001 = (t10000/245); +float t10002 = (t10000/245); +float t10003 = (t10002*float(842.378)); +float t10004 = fract(t10003); +float t10005 = (t10004+float(45.32)); +float t10006 = (t10005+u6.u0); +float t10007 = (t10004*t10006); +float t10008 = (t10000/245); +float t10009 = (t10008*3.1415927); +float t10010 = sin(t10009); +float t10011 = (245*t10010); +float t10012 = floor(t10011); +float t10013 = (t10012+1); +float t10014 = (3.1415927/t10013); +float t10015 = (t118/t10014); +float t10016 = floor(t10015); +float t10017 = (t10016/t10013); +float t10018 = (t10017*float(1734.048)); +float t10019 = fract(t10018); +float t10020 = (t10019+float(45.32)); +float t10021 = (t10020+u6.u0); +float t10022 = (t10019*t10021); +float t10023 = (t10007+t10022); +float t10024 = (t10004+t10023); +float t10025 = (t10019+t10023); +float t10026 = (t10024*t10025); +float t10027 = fract(t10026); +float t10028 = (t10027*5); +float t10029 = (t10001+t10028); +float t10030 = fract(t10029); +float t10031 = (t10030*12000); +float t10032 = (t10031/1000); +bool t10033 = (1<=t10032); +float t10034; +if(t10033){ +t10034 = 1; +} else { +t10034 = t10032; +} +float t10035 = (t10031-6000); +float t10036 = (t10035/8000); +bool t10037 = (0>=t10036); +float t10038; +if(t10037){ +t10038 = 0; +} else { +t10038 = t10036; +} +float t10039 = (t10034-t10038); +float t10040 = (t10027*173); +float t10041 = fract(t10040); +float t10042 = step(float(0.66),t10041); +float t10043 = (t10042*3); +float t10044 = (3+t10043); +float t10045 = (3.1415927/t10044); +float t10046 = cos(t10045); +float t10047 = (1-t10046); +float t10048 = (t10000*t9998); +float t10049 = (t10000/245); +float t10050 = (t10049*float(842.378)); +float t10051 = fract(t10050); +float t10052 = (t10051+float(45.32)); +float t10053 = (t10052+u6.u0); +float t10054 = (t10051*t10053); +float t10055 = (t10016/t10013); +float t10056 = (t10055*float(1734.048)); +float t10057 = fract(t10056); +float t10058 = (t10057+float(45.32)); +float t10059 = (t10058+u6.u0); +float t10060 = (t10057*t10059); +float t10061 = (t10054+t10060); +float t10062 = (t10051+t10061); +float t10063 = (t10057+t10061); +float t10064 = (t10062*t10063); +float t10065 = fract(t10064); +float t10066 = (t10065*float(2852.02)); +float t10067 = fract(t10066); +float t10068 = (t10067-float(0.5)); +float t10069 = (t10068*t9998); +float t10070 = (t10069*float(0.75)); +float t10071 = (t10048+t10070); +float t10072 = cos(t10071); +float t10073 = (1*t10072); +float t10074 = (t10073*0); +float t10075 = sin(t10071); +float t10076 = (1*t10075); +float t10077 = (3.1415927/t10013); +float t10078 = (t10016*t10077); +float t10079 = (t10065*float(97372.83)); +float t10080 = fract(t10079); +float t10081 = (t10080-float(0.5)); +float t10082 = (3.1415927/t10013); +float t10083 = (t10081*t10082); +float t10084 = (t10083*float(0.75)); +float t10085 = (t10078+t10084); +float t10086 = (t10085+3.1415927); +float t10087 = mod(t10086,t1433); +float t10088 = (t10087-3.1415927); +float t10089 = cos(t10088); +float t10090 = (t10076*t10089); +float t10091 = (t10090*1); +float t10092 = (t10074-t10091); +float t10093 = sin(t8); +float t10094 = (1*t10093); +float t10095 = sin(t118); +float t10096 = (t10094*t10095); +float t10097 = (t10092*t10096); +float t10098 = (t10090*0); +float t10099 = sin(t10071); +float t10100 = (1*t10099); +float t10101 = sin(t10088); +float t10102 = (t10100*t10101); +float t10103 = (t10102*0); +float t10104 = (t10098-t10103); +float t10105 = cos(t8); +float t10106 = (1*t10105); +float t10107 = (t10104*t10106); +float t10108 = (t10097+t10107); +float t10109 = (t10102*1); +float t10110 = (t10073*0); +float t10111 = (t10109-t10110); +float t10112 = sin(t8); +float t10113 = (1*t10112); +float t10114 = cos(t118); +float t10115 = (t10113*t10114); +float t10116 = (t10111*t10115); +float t10117 = (t10108+t10116); +float t10118 = (t10104*t10090); +float t10119 = (t10111*t10073); +float t10120 = (t10118-t10119); +float t10121 = (t10120*t10096); +float t10122 = (t10111*t10102); +float t10123 = (t10092*t10090); +float t10124 = (t10122-t10123); +float t10125 = (t10124*t10106); +float t10126 = (t10121+t10125); +float t10127 = (t10092*t10073); +float t10128 = (t10104*t10102); +float t10129 = (t10127-t10128); +float t10130 = (t10129*t10115); +float t10131 = (t10126+t10130); +float t10132 = atan(t10117,t10131); +float t10133 = (t10132+3.1415927); +float t10134 = (t10041*3.1415927); +float t10135 = (t10133+t10134); +float t10136 = (t10135/t1483); +float t10137 = fract(t10136); +float t10138 = (t10137*t10044); +float t10139 = fract(t10138); +float t10140 = (t10139*2); +float t10141 = (t10140-1); +float t10142 = abs(t10141); +float t10143 = (t10142*t10142); +float t10144 = (t10047*t10143); +float t10145 = (t10046+t10144); +float t10146 = (t10027*float(8.0e-3)); +float t10147 = (float(1.0e-3)+t10146); +float t10148 = step(float(0.66),t10041); +float t10149 = (t10148*float(3.0e-3)); +float t10150 = (t10147-t10149); +float t10151 = (t10150*float(0.4)); +float t10152 = (t10145*t10151); +float t10153 = (3.1415927/2); +float t10154 = (t10071-t10153); +float t10155 = (3.1415927/2); +float t10156 = (t8-t10155); +float t10157 = (t10154-t10156); +float t10158 = abs(t10157); +float t10159 = (t10158/2); +float t10160 = sin(t10159); +float t10161 = (t10160*t10160); +float t10162 = cos(t10156); +float t10163 = cos(t10154); +float t10164 = (t10162*t10163); +float t10165 = (t10088+3.1415927); +float t10166 = (3.1415927*2); +float t10167 = mod(t10165,t10166); +float t10168 = (t10167-3.1415927); +float t10169 = (t118+3.1415927); +float t10170 = (3.1415927*2); +float t10171 = mod(t10169,t10170); +float t10172 = (t10171-3.1415927); +float t10173 = (t10168-t10172); +float t10174 = abs(t10173); +float t10175 = (t10174/2); +float t10176 = sin(t10175); +float t10177 = (t10176*t10176); +float t10178 = (t10164*t10177); +float t10179 = (t10161+t10178); +float t10180 = sqrt(t10179); +float t10181 = asin(t10180); +float t10182 = (2*t10181); +float t10183 = step(t10152,t10182); +float t10184 = (1-t10183); +float t10185 = (t10039*t10184); +float t10186 = (3.1415927/2); +float t10187 = (t8-t10186); +float t10188 = (3.1415927/2); +float t10189 = (t10071-t10188); +float t10190 = (t10187-t10189); +float t10191 = abs(t10190); +float t10192 = (t10191/2); +float t10193 = sin(t10192); +float t10194 = (t10193*t10193); +float t10195 = cos(t10189); +float t10196 = cos(t10187); +float t10197 = (t10195*t10196); +float t10198 = (t118+3.1415927); +float t10199 = (3.1415927*2); +float t10200 = mod(t10198,t10199); +float t10201 = (t10200-3.1415927); +float t10202 = (t10088+3.1415927); +float t10203 = (3.1415927*2); +float t10204 = mod(t10202,t10203); +float t10205 = (t10204-3.1415927); +float t10206 = (t10201-t10205); +float t10207 = abs(t10206); +float t10208 = (t10207/2); +float t10209 = sin(t10208); +float t10210 = (t10209*t10209); +float t10211 = (t10197*t10210); +float t10212 = (t10194+t10211); +float t10213 = sqrt(t10212); +float t10214 = asin(t10213); +float t10215 = (2*t10214); +float t10216 = (1/t10215); +float t10217 = (t10216*t10151); +float t10218 = (t10217*float(1.25e-2)); +float t10219 = (u4.u0*t10027); +float t10220 = cos(t10219); +float t10221 = (t10220+1); +float t10222 = (t10221/2); +float t10223 = (t10218*t10222); +float t10224 = (t10223*t10039); +float t10225 = (t10185+t10224); +float t10226 = (0+t10225); +float t10227 = (t10000/245); +float t10228 = (t10000/245); +float t10229 = (t10228*float(842.378)); +float t10230 = fract(t10229); +float t10231 = (t10230+float(45.32)); +float t10232 = (t10231+u6.u0); +float t10233 = (t10230*t10232); +float t10234 = (t10016+1); +float t10235 = (t10234/t10013); +float t10236 = (t10235*float(1734.048)); +float t10237 = fract(t10236); +float t10238 = (t10237+float(45.32)); +float t10239 = (t10238+u6.u0); +float t10240 = (t10237*t10239); +float t10241 = (t10233+t10240); +float t10242 = (t10230+t10241); +float t10243 = (t10237+t10241); +float t10244 = (t10242*t10243); +float t10245 = fract(t10244); +float t10246 = (t10245*5); +float t10247 = (t10227+t10246); +float t10248 = fract(t10247); +float t10249 = (t10248*12000); +float t10250 = (t10249/1000); +bool t10251 = (1<=t10250); +float t10252; +if(t10251){ +t10252 = 1; +} else { +t10252 = t10250; +} +float t10253 = (t10249-6000); +float t10254 = (t10253/8000); +bool t10255 = (0>=t10254); +float t10256; +if(t10255){ +t10256 = 0; +} else { +t10256 = t10254; +} +float t10257 = (t10252-t10256); +float t10258 = (t10245*173); +float t10259 = fract(t10258); +float t10260 = step(float(0.66),t10259); +float t10261 = (t10260*3); +float t10262 = (3+t10261); +float t10263 = (3.1415927/t10262); +float t10264 = cos(t10263); +float t10265 = (1-t10264); +float t10266 = (t10000*t9998); +float t10267 = (t10000/245); +float t10268 = (t10267*float(842.378)); +float t10269 = fract(t10268); +float t10270 = (t10269+float(45.32)); +float t10271 = (t10270+u6.u0); +float t10272 = (t10269*t10271); +float t10273 = (t10234/t10013); +float t10274 = (t10273*float(1734.048)); +float t10275 = fract(t10274); +float t10276 = (t10275+float(45.32)); +float t10277 = (t10276+u6.u0); +float t10278 = (t10275*t10277); +float t10279 = (t10272+t10278); +float t10280 = (t10269+t10279); +float t10281 = (t10275+t10279); +float t10282 = (t10280*t10281); +float t10283 = fract(t10282); +float t10284 = (t10283*float(2852.02)); +float t10285 = fract(t10284); +float t10286 = (t10285-float(0.5)); +float t10287 = (t10286*t9998); +float t10288 = (t10287*float(0.75)); +float t10289 = (t10266+t10288); +float t10290 = cos(t10289); +float t10291 = (1*t10290); +float t10292 = (t10291*0); +float t10293 = sin(t10289); +float t10294 = (1*t10293); +float t10295 = (3.1415927/t10013); +float t10296 = (t10234*t10295); +float t10297 = (t10283*float(97372.83)); +float t10298 = fract(t10297); +float t10299 = (t10298-float(0.5)); +float t10300 = (3.1415927/t10013); +float t10301 = (t10299*t10300); +float t10302 = (t10301*float(0.75)); +float t10303 = (t10296+t10302); +float t10304 = (t10303+3.1415927); +float t10305 = mod(t10304,t1433); +float t10306 = (t10305-3.1415927); +float t10307 = cos(t10306); +float t10308 = (t10294*t10307); +float t10309 = (t10308*1); +float t10310 = (t10292-t10309); +float t10311 = sin(t8); +float t10312 = (1*t10311); +float t10313 = sin(t118); +float t10314 = (t10312*t10313); +float t10315 = (t10310*t10314); +float t10316 = (t10308*0); +float t10317 = sin(t10289); +float t10318 = (1*t10317); +float t10319 = sin(t10306); +float t10320 = (t10318*t10319); +float t10321 = (t10320*0); +float t10322 = (t10316-t10321); +float t10323 = cos(t8); +float t10324 = (1*t10323); +float t10325 = (t10322*t10324); +float t10326 = (t10315+t10325); +float t10327 = (t10320*1); +float t10328 = (t10291*0); +float t10329 = (t10327-t10328); +float t10330 = sin(t8); +float t10331 = (1*t10330); +float t10332 = cos(t118); +float t10333 = (t10331*t10332); +float t10334 = (t10329*t10333); +float t10335 = (t10326+t10334); +float t10336 = (t10322*t10308); +float t10337 = (t10329*t10291); +float t10338 = (t10336-t10337); +float t10339 = (t10338*t10314); +float t10340 = (t10329*t10320); +float t10341 = (t10310*t10308); +float t10342 = (t10340-t10341); +float t10343 = (t10342*t10324); +float t10344 = (t10339+t10343); +float t10345 = (t10310*t10291); +float t10346 = (t10322*t10320); +float t10347 = (t10345-t10346); +float t10348 = (t10347*t10333); +float t10349 = (t10344+t10348); +float t10350 = atan(t10335,t10349); +float t10351 = (t10350+3.1415927); +float t10352 = (t10259*3.1415927); +float t10353 = (t10351+t10352); +float t10354 = (t10353/t1483); +float t10355 = fract(t10354); +float t10356 = (t10355*t10262); +float t10357 = fract(t10356); +float t10358 = (t10357*2); +float t10359 = (t10358-1); +float t10360 = abs(t10359); +float t10361 = (t10360*t10360); +float t10362 = (t10265*t10361); +float t10363 = (t10264+t10362); +float t10364 = (t10245*float(8.0e-3)); +float t10365 = (float(1.0e-3)+t10364); +float t10366 = step(float(0.66),t10259); +float t10367 = (t10366*float(3.0e-3)); +float t10368 = (t10365-t10367); +float t10369 = (t10368*float(0.4)); +float t10370 = (t10363*t10369); +float t10371 = (3.1415927/2); +float t10372 = (t10289-t10371); +float t10373 = (3.1415927/2); +float t10374 = (t8-t10373); +float t10375 = (t10372-t10374); +float t10376 = abs(t10375); +float t10377 = (t10376/2); +float t10378 = sin(t10377); +float t10379 = (t10378*t10378); +float t10380 = cos(t10374); +float t10381 = cos(t10372); +float t10382 = (t10380*t10381); +float t10383 = (t10306+3.1415927); +float t10384 = (3.1415927*2); +float t10385 = mod(t10383,t10384); +float t10386 = (t10385-3.1415927); +float t10387 = (t118+3.1415927); +float t10388 = (3.1415927*2); +float t10389 = mod(t10387,t10388); +float t10390 = (t10389-3.1415927); +float t10391 = (t10386-t10390); +float t10392 = abs(t10391); +float t10393 = (t10392/2); +float t10394 = sin(t10393); +float t10395 = (t10394*t10394); +float t10396 = (t10382*t10395); +float t10397 = (t10379+t10396); +float t10398 = sqrt(t10397); +float t10399 = asin(t10398); +float t10400 = (2*t10399); +float t10401 = step(t10370,t10400); +float t10402 = (1-t10401); +float t10403 = (t10257*t10402); +float t10404 = (3.1415927/2); +float t10405 = (t8-t10404); +float t10406 = (3.1415927/2); +float t10407 = (t10289-t10406); +float t10408 = (t10405-t10407); +float t10409 = abs(t10408); +float t10410 = (t10409/2); +float t10411 = sin(t10410); +float t10412 = (t10411*t10411); +float t10413 = cos(t10407); +float t10414 = cos(t10405); +float t10415 = (t10413*t10414); +float t10416 = (t118+3.1415927); +float t10417 = (3.1415927*2); +float t10418 = mod(t10416,t10417); +float t10419 = (t10418-3.1415927); +float t10420 = (t10306+3.1415927); +float t10421 = (3.1415927*2); +float t10422 = mod(t10420,t10421); +float t10423 = (t10422-3.1415927); +float t10424 = (t10419-t10423); +float t10425 = abs(t10424); +float t10426 = (t10425/2); +float t10427 = sin(t10426); +float t10428 = (t10427*t10427); +float t10429 = (t10415*t10428); +float t10430 = (t10412+t10429); +float t10431 = sqrt(t10430); +float t10432 = asin(t10431); +float t10433 = (2*t10432); +float t10434 = (1/t10433); +float t10435 = (t10434*t10369); +float t10436 = (t10435*float(1.25e-2)); +float t10437 = (u4.u0*t10245); +float t10438 = cos(t10437); +float t10439 = (t10438+1); +float t10440 = (t10439/2); +float t10441 = (t10436*t10440); +float t10442 = (t10441*t10257); +float t10443 = (t10403+t10442); +float t10444 = (t10226+t10443); +float t10445 = (t10000/245); +float t10446 = (t10000/245); +float t10447 = (t10446*float(842.378)); +float t10448 = fract(t10447); +float t10449 = (t10448+float(45.32)); +float t10450 = (t10449+u6.u0); +float t10451 = (t10448*t10450); +float t10452 = (t10016+2); +float t10453 = (t10452/t10013); +float t10454 = (t10453*float(1734.048)); +float t10455 = fract(t10454); +float t10456 = (t10455+float(45.32)); +float t10457 = (t10456+u6.u0); +float t10458 = (t10455*t10457); +float t10459 = (t10451+t10458); +float t10460 = (t10448+t10459); +float t10461 = (t10455+t10459); +float t10462 = (t10460*t10461); +float t10463 = fract(t10462); +float t10464 = (t10463*5); +float t10465 = (t10445+t10464); +float t10466 = fract(t10465); +float t10467 = (t10466*12000); +float t10468 = (t10467/1000); +bool t10469 = (1<=t10468); +float t10470; +if(t10469){ +t10470 = 1; +} else { +t10470 = t10468; +} +float t10471 = (t10467-6000); +float t10472 = (t10471/8000); +bool t10473 = (0>=t10472); +float t10474; +if(t10473){ +t10474 = 0; +} else { +t10474 = t10472; +} +float t10475 = (t10470-t10474); +float t10476 = (t10463*173); +float t10477 = fract(t10476); +float t10478 = step(float(0.66),t10477); +float t10479 = (t10478*3); +float t10480 = (3+t10479); +float t10481 = (3.1415927/t10480); +float t10482 = cos(t10481); +float t10483 = (1-t10482); +float t10484 = (t10000*t9998); +float t10485 = (t10000/245); +float t10486 = (t10485*float(842.378)); +float t10487 = fract(t10486); +float t10488 = (t10487+float(45.32)); +float t10489 = (t10488+u6.u0); +float t10490 = (t10487*t10489); +float t10491 = (t10452/t10013); +float t10492 = (t10491*float(1734.048)); +float t10493 = fract(t10492); +float t10494 = (t10493+float(45.32)); +float t10495 = (t10494+u6.u0); +float t10496 = (t10493*t10495); +float t10497 = (t10490+t10496); +float t10498 = (t10487+t10497); +float t10499 = (t10493+t10497); +float t10500 = (t10498*t10499); +float t10501 = fract(t10500); +float t10502 = (t10501*float(2852.02)); +float t10503 = fract(t10502); +float t10504 = (t10503-float(0.5)); +float t10505 = (t10504*t9998); +float t10506 = (t10505*float(0.75)); +float t10507 = (t10484+t10506); +float t10508 = cos(t10507); +float t10509 = (1*t10508); +float t10510 = (t10509*0); +float t10511 = sin(t10507); +float t10512 = (1*t10511); +float t10513 = (3.1415927/t10013); +float t10514 = (t10452*t10513); +float t10515 = (t10501*float(97372.83)); +float t10516 = fract(t10515); +float t10517 = (t10516-float(0.5)); +float t10518 = (3.1415927/t10013); +float t10519 = (t10517*t10518); +float t10520 = (t10519*float(0.75)); +float t10521 = (t10514+t10520); +float t10522 = (t10521+3.1415927); +float t10523 = mod(t10522,t1433); +float t10524 = (t10523-3.1415927); +float t10525 = cos(t10524); +float t10526 = (t10512*t10525); +float t10527 = (t10526*1); +float t10528 = (t10510-t10527); +float t10529 = sin(t8); +float t10530 = (1*t10529); +float t10531 = sin(t118); +float t10532 = (t10530*t10531); +float t10533 = (t10528*t10532); +float t10534 = (t10526*0); +float t10535 = sin(t10507); +float t10536 = (1*t10535); +float t10537 = sin(t10524); +float t10538 = (t10536*t10537); +float t10539 = (t10538*0); +float t10540 = (t10534-t10539); +float t10541 = cos(t8); +float t10542 = (1*t10541); +float t10543 = (t10540*t10542); +float t10544 = (t10533+t10543); +float t10545 = (t10538*1); +float t10546 = (t10509*0); +float t10547 = (t10545-t10546); +float t10548 = sin(t8); +float t10549 = (1*t10548); +float t10550 = cos(t118); +float t10551 = (t10549*t10550); +float t10552 = (t10547*t10551); +float t10553 = (t10544+t10552); +float t10554 = (t10540*t10526); +float t10555 = (t10547*t10509); +float t10556 = (t10554-t10555); +float t10557 = (t10556*t10532); +float t10558 = (t10547*t10538); +float t10559 = (t10528*t10526); +float t10560 = (t10558-t10559); +float t10561 = (t10560*t10542); +float t10562 = (t10557+t10561); +float t10563 = (t10528*t10509); +float t10564 = (t10540*t10538); +float t10565 = (t10563-t10564); +float t10566 = (t10565*t10551); +float t10567 = (t10562+t10566); +float t10568 = atan(t10553,t10567); +float t10569 = (t10568+3.1415927); +float t10570 = (t10477*3.1415927); +float t10571 = (t10569+t10570); +float t10572 = (t10571/t1483); +float t10573 = fract(t10572); +float t10574 = (t10573*t10480); +float t10575 = fract(t10574); +float t10576 = (t10575*2); +float t10577 = (t10576-1); +float t10578 = abs(t10577); +float t10579 = (t10578*t10578); +float t10580 = (t10483*t10579); +float t10581 = (t10482+t10580); +float t10582 = (t10463*float(8.0e-3)); +float t10583 = (float(1.0e-3)+t10582); +float t10584 = step(float(0.66),t10477); +float t10585 = (t10584*float(3.0e-3)); +float t10586 = (t10583-t10585); +float t10587 = (t10586*float(0.4)); +float t10588 = (t10581*t10587); +float t10589 = (3.1415927/2); +float t10590 = (t10507-t10589); +float t10591 = (3.1415927/2); +float t10592 = (t8-t10591); +float t10593 = (t10590-t10592); +float t10594 = abs(t10593); +float t10595 = (t10594/2); +float t10596 = sin(t10595); +float t10597 = (t10596*t10596); +float t10598 = cos(t10592); +float t10599 = cos(t10590); +float t10600 = (t10598*t10599); +float t10601 = (t10524+3.1415927); +float t10602 = (3.1415927*2); +float t10603 = mod(t10601,t10602); +float t10604 = (t10603-3.1415927); +float t10605 = (t118+3.1415927); +float t10606 = (3.1415927*2); +float t10607 = mod(t10605,t10606); +float t10608 = (t10607-3.1415927); +float t10609 = (t10604-t10608); +float t10610 = abs(t10609); +float t10611 = (t10610/2); +float t10612 = sin(t10611); +float t10613 = (t10612*t10612); +float t10614 = (t10600*t10613); +float t10615 = (t10597+t10614); +float t10616 = sqrt(t10615); +float t10617 = asin(t10616); +float t10618 = (2*t10617); +float t10619 = step(t10588,t10618); +float t10620 = (1-t10619); +float t10621 = (t10475*t10620); +float t10622 = (3.1415927/2); +float t10623 = (t8-t10622); +float t10624 = (3.1415927/2); +float t10625 = (t10507-t10624); +float t10626 = (t10623-t10625); +float t10627 = abs(t10626); +float t10628 = (t10627/2); +float t10629 = sin(t10628); +float t10630 = (t10629*t10629); +float t10631 = cos(t10625); +float t10632 = cos(t10623); +float t10633 = (t10631*t10632); +float t10634 = (t118+3.1415927); +float t10635 = (3.1415927*2); +float t10636 = mod(t10634,t10635); +float t10637 = (t10636-3.1415927); +float t10638 = (t10524+3.1415927); +float t10639 = (3.1415927*2); +float t10640 = mod(t10638,t10639); +float t10641 = (t10640-3.1415927); +float t10642 = (t10637-t10641); +float t10643 = abs(t10642); +float t10644 = (t10643/2); +float t10645 = sin(t10644); +float t10646 = (t10645*t10645); +float t10647 = (t10633*t10646); +float t10648 = (t10630+t10647); +float t10649 = sqrt(t10648); +float t10650 = asin(t10649); +float t10651 = (2*t10650); +float t10652 = (1/t10651); +float t10653 = (t10652*t10587); +float t10654 = (t10653*float(1.25e-2)); +float t10655 = (u4.u0*t10463); +float t10656 = cos(t10655); +float t10657 = (t10656+1); +float t10658 = (t10657/2); +float t10659 = (t10654*t10658); +float t10660 = (t10659*t10475); +float t10661 = (t10621+t10660); +float t10662 = (t10444+t10661); +float t10663 = (t10000+1); +float t10664 = (t10663/245); +float t10665 = (t10663/245); +float t10666 = (t10665*float(842.378)); +float t10667 = fract(t10666); +float t10668 = (t10667+float(45.32)); +float t10669 = (t10668+u6.u0); +float t10670 = (t10667*t10669); +float t10671 = (t10663/245); +float t10672 = (t10671*3.1415927); +float t10673 = sin(t10672); +float t10674 = (245*t10673); +float t10675 = floor(t10674); +float t10676 = (t10675+1); +float t10677 = (3.1415927/t10676); +float t10678 = (t118/t10677); +float t10679 = floor(t10678); +float t10680 = (t10679/t10676); +float t10681 = (t10680*float(1734.048)); +float t10682 = fract(t10681); +float t10683 = (t10682+float(45.32)); +float t10684 = (t10683+u6.u0); +float t10685 = (t10682*t10684); +float t10686 = (t10670+t10685); +float t10687 = (t10667+t10686); +float t10688 = (t10682+t10686); +float t10689 = (t10687*t10688); +float t10690 = fract(t10689); +float t10691 = (t10690*5); +float t10692 = (t10664+t10691); +float t10693 = fract(t10692); +float t10694 = (t10693*12000); +float t10695 = (t10694/1000); +bool t10696 = (1<=t10695); +float t10697; +if(t10696){ +t10697 = 1; +} else { +t10697 = t10695; +} +float t10698 = (t10694-6000); +float t10699 = (t10698/8000); +bool t10700 = (0>=t10699); +float t10701; +if(t10700){ +t10701 = 0; +} else { +t10701 = t10699; +} +float t10702 = (t10697-t10701); +float t10703 = (t10690*173); +float t10704 = fract(t10703); +float t10705 = step(float(0.66),t10704); +float t10706 = (t10705*3); +float t10707 = (3+t10706); +float t10708 = (3.1415927/t10707); +float t10709 = cos(t10708); +float t10710 = (1-t10709); +float t10711 = (t10663*t9998); +float t10712 = (t10663/245); +float t10713 = (t10712*float(842.378)); +float t10714 = fract(t10713); +float t10715 = (t10714+float(45.32)); +float t10716 = (t10715+u6.u0); +float t10717 = (t10714*t10716); +float t10718 = (t10679/t10676); +float t10719 = (t10718*float(1734.048)); +float t10720 = fract(t10719); +float t10721 = (t10720+float(45.32)); +float t10722 = (t10721+u6.u0); +float t10723 = (t10720*t10722); +float t10724 = (t10717+t10723); +float t10725 = (t10714+t10724); +float t10726 = (t10720+t10724); +float t10727 = (t10725*t10726); +float t10728 = fract(t10727); +float t10729 = (t10728*float(2852.02)); +float t10730 = fract(t10729); +float t10731 = (t10730-float(0.5)); +float t10732 = (t10731*t9998); +float t10733 = (t10732*float(0.75)); +float t10734 = (t10711+t10733); +float t10735 = cos(t10734); +float t10736 = (1*t10735); +float t10737 = (t10736*0); +float t10738 = sin(t10734); +float t10739 = (1*t10738); +float t10740 = (3.1415927/t10676); +float t10741 = (t10679*t10740); +float t10742 = (t10728*float(97372.83)); +float t10743 = fract(t10742); +float t10744 = (t10743-float(0.5)); +float t10745 = (3.1415927/t10676); +float t10746 = (t10744*t10745); +float t10747 = (t10746*float(0.75)); +float t10748 = (t10741+t10747); +float t10749 = (t10748+3.1415927); +float t10750 = mod(t10749,t1433); +float t10751 = (t10750-3.1415927); +float t10752 = cos(t10751); +float t10753 = (t10739*t10752); +float t10754 = (t10753*1); +float t10755 = (t10737-t10754); +float t10756 = sin(t8); +float t10757 = (1*t10756); +float t10758 = sin(t118); +float t10759 = (t10757*t10758); +float t10760 = (t10755*t10759); +float t10761 = (t10753*0); +float t10762 = sin(t10734); +float t10763 = (1*t10762); +float t10764 = sin(t10751); +float t10765 = (t10763*t10764); +float t10766 = (t10765*0); +float t10767 = (t10761-t10766); +float t10768 = cos(t8); +float t10769 = (1*t10768); +float t10770 = (t10767*t10769); +float t10771 = (t10760+t10770); +float t10772 = (t10765*1); +float t10773 = (t10736*0); +float t10774 = (t10772-t10773); +float t10775 = sin(t8); +float t10776 = (1*t10775); +float t10777 = cos(t118); +float t10778 = (t10776*t10777); +float t10779 = (t10774*t10778); +float t10780 = (t10771+t10779); +float t10781 = (t10767*t10753); +float t10782 = (t10774*t10736); +float t10783 = (t10781-t10782); +float t10784 = (t10783*t10759); +float t10785 = (t10774*t10765); +float t10786 = (t10755*t10753); +float t10787 = (t10785-t10786); +float t10788 = (t10787*t10769); +float t10789 = (t10784+t10788); +float t10790 = (t10755*t10736); +float t10791 = (t10767*t10765); +float t10792 = (t10790-t10791); +float t10793 = (t10792*t10778); +float t10794 = (t10789+t10793); +float t10795 = atan(t10780,t10794); +float t10796 = (t10795+3.1415927); +float t10797 = (t10704*3.1415927); +float t10798 = (t10796+t10797); +float t10799 = (t10798/t1483); +float t10800 = fract(t10799); +float t10801 = (t10800*t10707); +float t10802 = fract(t10801); +float t10803 = (t10802*2); +float t10804 = (t10803-1); +float t10805 = abs(t10804); +float t10806 = (t10805*t10805); +float t10807 = (t10710*t10806); +float t10808 = (t10709+t10807); +float t10809 = (t10690*float(8.0e-3)); +float t10810 = (float(1.0e-3)+t10809); +float t10811 = step(float(0.66),t10704); +float t10812 = (t10811*float(3.0e-3)); +float t10813 = (t10810-t10812); +float t10814 = (t10813*float(0.4)); +float t10815 = (t10808*t10814); +float t10816 = (3.1415927/2); +float t10817 = (t10734-t10816); +float t10818 = (3.1415927/2); +float t10819 = (t8-t10818); +float t10820 = (t10817-t10819); +float t10821 = abs(t10820); +float t10822 = (t10821/2); +float t10823 = sin(t10822); +float t10824 = (t10823*t10823); +float t10825 = cos(t10819); +float t10826 = cos(t10817); +float t10827 = (t10825*t10826); +float t10828 = (t10751+3.1415927); +float t10829 = (3.1415927*2); +float t10830 = mod(t10828,t10829); +float t10831 = (t10830-3.1415927); +float t10832 = (t118+3.1415927); +float t10833 = (3.1415927*2); +float t10834 = mod(t10832,t10833); +float t10835 = (t10834-3.1415927); +float t10836 = (t10831-t10835); +float t10837 = abs(t10836); +float t10838 = (t10837/2); +float t10839 = sin(t10838); +float t10840 = (t10839*t10839); +float t10841 = (t10827*t10840); +float t10842 = (t10824+t10841); +float t10843 = sqrt(t10842); +float t10844 = asin(t10843); +float t10845 = (2*t10844); +float t10846 = step(t10815,t10845); +float t10847 = (1-t10846); +float t10848 = (t10702*t10847); +float t10849 = (3.1415927/2); +float t10850 = (t8-t10849); +float t10851 = (3.1415927/2); +float t10852 = (t10734-t10851); +float t10853 = (t10850-t10852); +float t10854 = abs(t10853); +float t10855 = (t10854/2); +float t10856 = sin(t10855); +float t10857 = (t10856*t10856); +float t10858 = cos(t10852); +float t10859 = cos(t10850); +float t10860 = (t10858*t10859); +float t10861 = (t118+3.1415927); +float t10862 = (3.1415927*2); +float t10863 = mod(t10861,t10862); +float t10864 = (t10863-3.1415927); +float t10865 = (t10751+3.1415927); +float t10866 = (3.1415927*2); +float t10867 = mod(t10865,t10866); +float t10868 = (t10867-3.1415927); +float t10869 = (t10864-t10868); +float t10870 = abs(t10869); +float t10871 = (t10870/2); +float t10872 = sin(t10871); +float t10873 = (t10872*t10872); +float t10874 = (t10860*t10873); +float t10875 = (t10857+t10874); +float t10876 = sqrt(t10875); +float t10877 = asin(t10876); +float t10878 = (2*t10877); +float t10879 = (1/t10878); +float t10880 = (t10879*t10814); +float t10881 = (t10880*float(1.25e-2)); +float t10882 = (u4.u0*t10690); +float t10883 = cos(t10882); +float t10884 = (t10883+1); +float t10885 = (t10884/2); +float t10886 = (t10881*t10885); +float t10887 = (t10886*t10702); +float t10888 = (t10848+t10887); +float t10889 = (t10662+t10888); +float t10890 = (t10000*t9998); +float t10891 = (t10000/245); +float t10892 = (t10891*float(842.378)); +float t10893 = fract(t10892); +float t10894 = (t10893+float(45.32)); +float t10895 = (t10894+u6.u0); +float t10896 = (t10893*t10895); +float t10897 = (t10234/t10013); +float t10898 = (t10897*float(1734.048)); +float t10899 = fract(t10898); +float t10900 = (t10899+float(45.32)); +float t10901 = (t10900+u6.u0); +float t10902 = (t10899*t10901); +float t10903 = (t10896+t10902); +float t10904 = (t10893+t10903); +float t10905 = (t10899+t10903); +float t10906 = (t10904*t10905); +float t10907 = fract(t10906); +float t10908 = (t10907*float(2852.02)); +float t10909 = fract(t10908); +float t10910 = (t10909-float(0.5)); +float t10911 = (t10910*t9998); +float t10912 = (t10911*float(0.75)); +float t10913 = (t10890+t10912); +float t10914 = (3.1415927/2); +float t10915 = (t10913-t10914); +float t10916 = (t10000*t9998); +float t10917 = (t10000/245); +float t10918 = (t10917*float(842.378)); +float t10919 = fract(t10918); +float t10920 = (t10919+float(45.32)); +float t10921 = (t10920+u6.u0); +float t10922 = (t10919*t10921); +float t10923 = (t10016/t10013); +float t10924 = (t10923*float(1734.048)); +float t10925 = fract(t10924); +float t10926 = (t10925+float(45.32)); +float t10927 = (t10926+u6.u0); +float t10928 = (t10925*t10927); +float t10929 = (t10922+t10928); +float t10930 = (t10919+t10929); +float t10931 = (t10925+t10929); +float t10932 = (t10930*t10931); +float t10933 = fract(t10932); +float t10934 = (t10933*float(2852.02)); +float t10935 = fract(t10934); +float t10936 = (t10935-float(0.5)); +float t10937 = (t10936*t9998); +float t10938 = (t10937*float(0.75)); +float t10939 = (t10916+t10938); +float t10940 = (3.1415927/2); +float t10941 = (t10939-t10940); +float t10942 = (t10915-t10941); +float t10943 = abs(t10942); +float t10944 = (t10943/2); +float t10945 = sin(t10944); +float t10946 = (t10945*t10945); +float t10947 = cos(t10941); +float t10948 = cos(t10915); +float t10949 = (t10947*t10948); +float t10950 = (3.1415927/t10013); +float t10951 = (t10234*t10950); +float t10952 = (t10907*float(97372.83)); +float t10953 = fract(t10952); +float t10954 = (t10953-float(0.5)); +float t10955 = (3.1415927/t10013); +float t10956 = (t10954*t10955); +float t10957 = (t10956*float(0.75)); +float t10958 = (t10951+t10957); +float t10959 = (t10958+3.1415927); +float t10960 = mod(t10959,t1433); +float t10961 = (t10960-3.1415927); +float t10962 = (t10961+3.1415927); +float t10963 = (3.1415927*2); +float t10964 = mod(t10962,t10963); +float t10965 = (t10964-3.1415927); +float t10966 = (3.1415927/t10013); +float t10967 = (t10016*t10966); +float t10968 = (t10933*float(97372.83)); +float t10969 = fract(t10968); +float t10970 = (t10969-float(0.5)); +float t10971 = (3.1415927/t10013); +float t10972 = (t10970*t10971); +float t10973 = (t10972*float(0.75)); +float t10974 = (t10967+t10973); +float t10975 = (t10974+3.1415927); +float t10976 = mod(t10975,t1433); +float t10977 = (t10976-3.1415927); +float t10978 = (t10977+3.1415927); +float t10979 = (3.1415927*2); +float t10980 = mod(t10978,t10979); +float t10981 = (t10980-3.1415927); +float t10982 = (t10965-t10981); +float t10983 = abs(t10982); +float t10984 = (t10983/2); +float t10985 = sin(t10984); +float t10986 = (t10985*t10985); +float t10987 = (t10949*t10986); +float t10988 = (t10946+t10987); +float t10989 = sqrt(t10988); +float t10990 = asin(t10989); +float t10991 = (2*t10990); +float t10992 = (3.1415927/2); +float t10993 = (t8-t10992); +float t10994 = (3.1415927/2); +float t10995 = (t10939-t10994); +float t10996 = (t10993-t10995); +float t10997 = abs(t10996); +float t10998 = (t10997/2); +float t10999 = sin(t10998); +float t11000 = (t10999*t10999); +float t11001 = cos(t10995); +float t11002 = cos(t10993); +float t11003 = (t11001*t11002); +float t11004 = (t118+3.1415927); +float t11005 = (3.1415927*2); +float t11006 = mod(t11004,t11005); +float t11007 = (t11006-3.1415927); +float t11008 = (t10977+3.1415927); +float t11009 = (3.1415927*2); +float t11010 = mod(t11008,t11009); +float t11011 = (t11010-3.1415927); +float t11012 = (t11007-t11011); +float t11013 = abs(t11012); +float t11014 = (t11013/2); +float t11015 = sin(t11014); +float t11016 = (t11015*t11015); +float t11017 = (t11003*t11016); +float t11018 = (t11000+t11017); +float t11019 = sqrt(t11018); +float t11020 = asin(t11019); +float t11021 = (2*t11020); +float t11022 = (t10991-t11021); +float t11023 = (3.1415927/2); +float t11024 = (t8-t11023); +float t11025 = (3.1415927/2); +float t11026 = (t10913-t11025); +float t11027 = (t11024-t11026); +float t11028 = abs(t11027); +float t11029 = (t11028/2); +float t11030 = sin(t11029); +float t11031 = (t11030*t11030); +float t11032 = cos(t11026); +float t11033 = cos(t11024); +float t11034 = (t11032*t11033); +float t11035 = (t118+3.1415927); +float t11036 = (3.1415927*2); +float t11037 = mod(t11035,t11036); +float t11038 = (t11037-3.1415927); +float t11039 = (t10961+3.1415927); +float t11040 = (3.1415927*2); +float t11041 = mod(t11039,t11040); +float t11042 = (t11041-3.1415927); +float t11043 = (t11038-t11042); +float t11044 = abs(t11043); +float t11045 = (t11044/2); +float t11046 = sin(t11045); +float t11047 = (t11046*t11046); +float t11048 = (t11034*t11047); +float t11049 = (t11031+t11048); +float t11050 = sqrt(t11049); +float t11051 = asin(t11050); +float t11052 = (2*t11051); +float t11053 = (t11022-t11052); +float t11054 = abs(t11053); +bool t11055 = (float(1.0e-4)>t11054); +float t11056; +if(t11055){ +float t11057 = cos(t10939); +float t11058 = (1*t11057); +float t11059 = sin(t10913); +float t11060 = (1*t11059); +float t11061 = cos(t10961); +float t11062 = (t11060*t11061); +float t11063 = (t11058*t11062); +float t11064 = sin(t10939); +float t11065 = (1*t11064); +float t11066 = cos(t10977); +float t11067 = (t11065*t11066); +float t11068 = cos(t10913); +float t11069 = (1*t11068); +float t11070 = (t11067*t11069); +float t11071 = (t11063-t11070); +float t11072 = sin(t8); +float t11073 = (1*t11072); +float t11074 = sin(t118); +float t11075 = (t11073*t11074); +float t11076 = (t11071*t11075); +float t11077 = sin(t10913); +float t11078 = (1*t11077); +float t11079 = sin(t10961); +float t11080 = (t11078*t11079); +float t11081 = (t11067*t11080); +float t11082 = sin(t10939); +float t11083 = (1*t11082); +float t11084 = sin(t10977); +float t11085 = (t11083*t11084); +float t11086 = (t11085*t11062); +float t11087 = (t11081-t11086); +float t11088 = cos(t8); +float t11089 = (1*t11088); +float t11090 = (t11087*t11089); +float t11091 = (t11076+t11090); +float t11092 = (t11085*t11069); +float t11093 = (t11058*t11080); +float t11094 = (t11092-t11093); +float t11095 = sin(t8); +float t11096 = (1*t11095); +float t11097 = cos(t118); +float t11098 = (t11096*t11097); +float t11099 = (t11094*t11098); +float t11100 = (t11091+t11099); +float t11101 = abs(t11100); +t11056 = t11101; +} else { +float t11102 = (3.1415927/2); +float t11103 = (t8-t11102); +float t11104 = (3.1415927/2); +float t11105 = (t10913-t11104); +float t11106 = (t11103-t11105); +float t11107 = abs(t11106); +float t11108 = (t11107/2); +float t11109 = sin(t11108); +float t11110 = (t11109*t11109); +float t11111 = cos(t11105); +float t11112 = cos(t11103); +float t11113 = (t11111*t11112); +float t11114 = (t118+3.1415927); +float t11115 = (3.1415927*2); +float t11116 = mod(t11114,t11115); +float t11117 = (t11116-3.1415927); +float t11118 = (t10961+3.1415927); +float t11119 = (3.1415927*2); +float t11120 = mod(t11118,t11119); +float t11121 = (t11120-3.1415927); +float t11122 = (t11117-t11121); +float t11123 = abs(t11122); +float t11124 = (t11123/2); +float t11125 = sin(t11124); +float t11126 = (t11125*t11125); +float t11127 = (t11113*t11126); +float t11128 = (t11110+t11127); +float t11129 = sqrt(t11128); +float t11130 = asin(t11129); +float t11131 = (2*t11130); +float t11132 = abs(t11131); +float t11133 = (3.1415927/2); +float t11134 = (t8-t11133); +float t11135 = (3.1415927/2); +float t11136 = (t10939-t11135); +float t11137 = (t11134-t11136); +float t11138 = abs(t11137); +float t11139 = (t11138/2); +float t11140 = sin(t11139); +float t11141 = (t11140*t11140); +float t11142 = cos(t11136); +float t11143 = cos(t11134); +float t11144 = (t11142*t11143); +float t11145 = (t118+3.1415927); +float t11146 = (3.1415927*2); +float t11147 = mod(t11145,t11146); +float t11148 = (t11147-3.1415927); +float t11149 = (t10977+3.1415927); +float t11150 = (3.1415927*2); +float t11151 = mod(t11149,t11150); +float t11152 = (t11151-3.1415927); +float t11153 = (t11148-t11152); +float t11154 = abs(t11153); +float t11155 = (t11154/2); +float t11156 = sin(t11155); +float t11157 = (t11156*t11156); +float t11158 = (t11144*t11157); +float t11159 = (t11141+t11158); +float t11160 = sqrt(t11159); +float t11161 = asin(t11160); +float t11162 = (2*t11161); +float t11163 = abs(t11162); +bool t11164 = (t11132>=t11163); +float t11165; +if(t11164){ +t11165 = t11132; +} else { +t11165 = t11163; +} +t11056 = t11165; +} +float t11166 = abs(t11056); +float t11167 = step(float(2.0e-4),t11166); +float t11168 = (1-t11167); +float t11169 = (t10000*t10234); +float t11170 = (t11169*float(842.378)); +float t11171 = fract(t11170); +float t11172 = (t11171+float(45.32)); +float t11173 = (t11172+u6.u0); +float t11174 = (t11171*t11173); +float t11175 = (t10016*t10000); +float t11176 = (t11175*float(1734.048)); +float t11177 = fract(t11176); +float t11178 = (t11177+float(45.32)); +float t11179 = (t11178+u6.u0); +float t11180 = (t11177*t11179); +float t11181 = (t11174+t11180); +float t11182 = (t11171+t11181); +float t11183 = (t11177+t11181); +float t11184 = (t11182*t11183); +float t11185 = fract(t11184); +float t11186 = step(float(0.2),t11185); +float t11187 = (t11168*t11186); +float t11188 = (3.1415927/2); +float t11189 = (t10913-t11188); +float t11190 = (3.1415927/2); +float t11191 = (t10939-t11190); +float t11192 = (t11189-t11191); +float t11193 = abs(t11192); +float t11194 = (t11193/2); +float t11195 = sin(t11194); +float t11196 = (t11195*t11195); +float t11197 = cos(t11191); +float t11198 = cos(t11189); +float t11199 = (t11197*t11198); +float t11200 = (t10961+3.1415927); +float t11201 = (3.1415927*2); +float t11202 = mod(t11200,t11201); +float t11203 = (t11202-3.1415927); +float t11204 = (t10977+3.1415927); +float t11205 = (3.1415927*2); +float t11206 = mod(t11204,t11205); +float t11207 = (t11206-3.1415927); +float t11208 = (t11203-t11207); +float t11209 = abs(t11208); +float t11210 = (t11209/2); +float t11211 = sin(t11210); +float t11212 = (t11211*t11211); +float t11213 = (t11199*t11212); +float t11214 = (t11196+t11213); +float t11215 = sqrt(t11214); +float t11216 = asin(t11215); +float t11217 = (2*t11216); +float t11218 = (t11217/t9998); +float t11219 = (1-t11218); +float t11220 = (t10000/245); +float t11221 = (t11220*float(842.378)); +float t11222 = fract(t11221); +float t11223 = (t11222+float(45.32)); +float t11224 = (t11223+u6.u0); +float t11225 = (t11222*t11224); +float t11226 = (t10016/t10013); +float t11227 = (t11226*float(1734.048)); +float t11228 = fract(t11227); +float t11229 = (t11228+float(45.32)); +float t11230 = (t11229+u6.u0); +float t11231 = (t11228*t11230); +float t11232 = (t11225+t11231); +float t11233 = (t11222+t11232); +float t11234 = (t11228+t11232); +float t11235 = (t11233*t11234); +float t11236 = fract(t11235); +float t11237 = (t11236*float(8.0e-3)); +float t11238 = (float(1.0e-3)+t11237); +float t11239 = (t11236*173); +float t11240 = fract(t11239); +float t11241 = step(float(0.66),t11240); +float t11242 = (t11241*float(3.0e-3)); +float t11243 = (t11238-t11242); +float t11244 = (t11243*float(0.4)); +float t11245 = (t10000/245); +float t11246 = (t11245*float(842.378)); +float t11247 = fract(t11246); +float t11248 = (t11247+float(45.32)); +float t11249 = (t11248+u6.u0); +float t11250 = (t11247*t11249); +float t11251 = (t10234/t10013); +float t11252 = (t11251*float(1734.048)); +float t11253 = fract(t11252); +float t11254 = (t11253+float(45.32)); +float t11255 = (t11254+u6.u0); +float t11256 = (t11253*t11255); +float t11257 = (t11250+t11256); +float t11258 = (t11247+t11257); +float t11259 = (t11253+t11257); +float t11260 = (t11258*t11259); +float t11261 = fract(t11260); +float t11262 = (t11261*float(8.0e-3)); +float t11263 = (float(1.0e-3)+t11262); +float t11264 = (t11261*173); +float t11265 = fract(t11264); +float t11266 = step(float(0.66),t11265); +float t11267 = (t11266*float(3.0e-3)); +float t11268 = (t11263-t11267); +float t11269 = (t11268*float(0.4)); +float t11270 = (t11244-t11269); +float t11271 = abs(t11270); +float t11272 = (t11271-float(1.0e-3)); +float t11273 = (t11272/float(8.0e-3)); +float t11274 = (1-t11273); +float t11275 = (t11274*t11274); +float t11276 = (t11219*t11275); +float t11277 = (t11187*t11276); +float t11278 = (u4.u0*t11185); +float t11279 = (t11278*3); +float t11280 = sin(t11279); +float t11281 = (t11280+1); +float t11282 = (t11281/2); +float t11283 = (t11282*float(0.66)); +float t11284 = (t11283+float(0.33)); +float t11285 = (t11277*t11284); +float t11286 = (float(0.2)*t11285); +bool t11287 = (0>=t11286); +float t11288; +if(t11287){ +t11288 = 0; +} else { +t11288 = t11286; +} +float t11289 = (t11288*0); +float t11290 = (t10889+t11289); +float t11291 = (t10663*t9998); +float t11292 = (t10663/245); +float t11293 = (t11292*float(842.378)); +float t11294 = fract(t11293); +float t11295 = (t11294+float(45.32)); +float t11296 = (t11295+u6.u0); +float t11297 = (t11294*t11296); +float t11298 = (t10679/t10676); +float t11299 = (t11298*float(1734.048)); +float t11300 = fract(t11299); +float t11301 = (t11300+float(45.32)); +float t11302 = (t11301+u6.u0); +float t11303 = (t11300*t11302); +float t11304 = (t11297+t11303); +float t11305 = (t11294+t11304); +float t11306 = (t11300+t11304); +float t11307 = (t11305*t11306); +float t11308 = fract(t11307); +float t11309 = (t11308*float(2852.02)); +float t11310 = fract(t11309); +float t11311 = (t11310-float(0.5)); +float t11312 = (t11311*t9998); +float t11313 = (t11312*float(0.75)); +float t11314 = (t11291+t11313); +float t11315 = (3.1415927/2); +float t11316 = (t11314-t11315); +float t11317 = (t10000*t9998); +float t11318 = (t10000/245); +float t11319 = (t11318*float(842.378)); +float t11320 = fract(t11319); +float t11321 = (t11320+float(45.32)); +float t11322 = (t11321+u6.u0); +float t11323 = (t11320*t11322); +float t11324 = (t10016/t10013); +float t11325 = (t11324*float(1734.048)); +float t11326 = fract(t11325); +float t11327 = (t11326+float(45.32)); +float t11328 = (t11327+u6.u0); +float t11329 = (t11326*t11328); +float t11330 = (t11323+t11329); +float t11331 = (t11320+t11330); +float t11332 = (t11326+t11330); +float t11333 = (t11331*t11332); +float t11334 = fract(t11333); +float t11335 = (t11334*float(2852.02)); +float t11336 = fract(t11335); +float t11337 = (t11336-float(0.5)); +float t11338 = (t11337*t9998); +float t11339 = (t11338*float(0.75)); +float t11340 = (t11317+t11339); +float t11341 = (3.1415927/2); +float t11342 = (t11340-t11341); +float t11343 = (t11316-t11342); +float t11344 = abs(t11343); +float t11345 = (t11344/2); +float t11346 = sin(t11345); +float t11347 = (t11346*t11346); +float t11348 = cos(t11342); +float t11349 = cos(t11316); +float t11350 = (t11348*t11349); +float t11351 = (3.1415927/t10676); +float t11352 = (t10679*t11351); +float t11353 = (t11308*float(97372.83)); +float t11354 = fract(t11353); +float t11355 = (t11354-float(0.5)); +float t11356 = (3.1415927/t10676); +float t11357 = (t11355*t11356); +float t11358 = (t11357*float(0.75)); +float t11359 = (t11352+t11358); +float t11360 = (t11359+3.1415927); +float t11361 = mod(t11360,t1433); +float t11362 = (t11361-3.1415927); +float t11363 = (t11362+3.1415927); +float t11364 = (3.1415927*2); +float t11365 = mod(t11363,t11364); +float t11366 = (t11365-3.1415927); +float t11367 = (3.1415927/t10013); +float t11368 = (t10016*t11367); +float t11369 = (t11334*float(97372.83)); +float t11370 = fract(t11369); +float t11371 = (t11370-float(0.5)); +float t11372 = (3.1415927/t10013); +float t11373 = (t11371*t11372); +float t11374 = (t11373*float(0.75)); +float t11375 = (t11368+t11374); +float t11376 = (t11375+3.1415927); +float t11377 = mod(t11376,t1433); +float t11378 = (t11377-3.1415927); +float t11379 = (t11378+3.1415927); +float t11380 = (3.1415927*2); +float t11381 = mod(t11379,t11380); +float t11382 = (t11381-3.1415927); +float t11383 = (t11366-t11382); +float t11384 = abs(t11383); +float t11385 = (t11384/2); +float t11386 = sin(t11385); +float t11387 = (t11386*t11386); +float t11388 = (t11350*t11387); +float t11389 = (t11347+t11388); +float t11390 = sqrt(t11389); +float t11391 = asin(t11390); +float t11392 = (2*t11391); +float t11393 = (3.1415927/2); +float t11394 = (t8-t11393); +float t11395 = (3.1415927/2); +float t11396 = (t11340-t11395); +float t11397 = (t11394-t11396); +float t11398 = abs(t11397); +float t11399 = (t11398/2); +float t11400 = sin(t11399); +float t11401 = (t11400*t11400); +float t11402 = cos(t11396); +float t11403 = cos(t11394); +float t11404 = (t11402*t11403); +float t11405 = (t118+3.1415927); +float t11406 = (3.1415927*2); +float t11407 = mod(t11405,t11406); +float t11408 = (t11407-3.1415927); +float t11409 = (t11378+3.1415927); +float t11410 = (3.1415927*2); +float t11411 = mod(t11409,t11410); +float t11412 = (t11411-3.1415927); +float t11413 = (t11408-t11412); +float t11414 = abs(t11413); +float t11415 = (t11414/2); +float t11416 = sin(t11415); +float t11417 = (t11416*t11416); +float t11418 = (t11404*t11417); +float t11419 = (t11401+t11418); +float t11420 = sqrt(t11419); +float t11421 = asin(t11420); +float t11422 = (2*t11421); +float t11423 = (t11392-t11422); +float t11424 = (3.1415927/2); +float t11425 = (t8-t11424); +float t11426 = (3.1415927/2); +float t11427 = (t11314-t11426); +float t11428 = (t11425-t11427); +float t11429 = abs(t11428); +float t11430 = (t11429/2); +float t11431 = sin(t11430); +float t11432 = (t11431*t11431); +float t11433 = cos(t11427); +float t11434 = cos(t11425); +float t11435 = (t11433*t11434); +float t11436 = (t118+3.1415927); +float t11437 = (3.1415927*2); +float t11438 = mod(t11436,t11437); +float t11439 = (t11438-3.1415927); +float t11440 = (t11362+3.1415927); +float t11441 = (3.1415927*2); +float t11442 = mod(t11440,t11441); +float t11443 = (t11442-3.1415927); +float t11444 = (t11439-t11443); +float t11445 = abs(t11444); +float t11446 = (t11445/2); +float t11447 = sin(t11446); +float t11448 = (t11447*t11447); +float t11449 = (t11435*t11448); +float t11450 = (t11432+t11449); +float t11451 = sqrt(t11450); +float t11452 = asin(t11451); +float t11453 = (2*t11452); +float t11454 = (t11423-t11453); +float t11455 = abs(t11454); +bool t11456 = (float(1.0e-4)>t11455); +float t11457; +if(t11456){ +float t11458 = cos(t11340); +float t11459 = (1*t11458); +float t11460 = sin(t11314); +float t11461 = (1*t11460); +float t11462 = cos(t11362); +float t11463 = (t11461*t11462); +float t11464 = (t11459*t11463); +float t11465 = sin(t11340); +float t11466 = (1*t11465); +float t11467 = cos(t11378); +float t11468 = (t11466*t11467); +float t11469 = cos(t11314); +float t11470 = (1*t11469); +float t11471 = (t11468*t11470); +float t11472 = (t11464-t11471); +float t11473 = sin(t8); +float t11474 = (1*t11473); +float t11475 = sin(t118); +float t11476 = (t11474*t11475); +float t11477 = (t11472*t11476); +float t11478 = sin(t11314); +float t11479 = (1*t11478); +float t11480 = sin(t11362); +float t11481 = (t11479*t11480); +float t11482 = (t11468*t11481); +float t11483 = sin(t11340); +float t11484 = (1*t11483); +float t11485 = sin(t11378); +float t11486 = (t11484*t11485); +float t11487 = (t11486*t11463); +float t11488 = (t11482-t11487); +float t11489 = cos(t8); +float t11490 = (1*t11489); +float t11491 = (t11488*t11490); +float t11492 = (t11477+t11491); +float t11493 = (t11486*t11470); +float t11494 = (t11459*t11481); +float t11495 = (t11493-t11494); +float t11496 = sin(t8); +float t11497 = (1*t11496); +float t11498 = cos(t118); +float t11499 = (t11497*t11498); +float t11500 = (t11495*t11499); +float t11501 = (t11492+t11500); +float t11502 = abs(t11501); +t11457 = t11502; +} else { +float t11503 = (3.1415927/2); +float t11504 = (t8-t11503); +float t11505 = (3.1415927/2); +float t11506 = (t11314-t11505); +float t11507 = (t11504-t11506); +float t11508 = abs(t11507); +float t11509 = (t11508/2); +float t11510 = sin(t11509); +float t11511 = (t11510*t11510); +float t11512 = cos(t11506); +float t11513 = cos(t11504); +float t11514 = (t11512*t11513); +float t11515 = (t118+3.1415927); +float t11516 = (3.1415927*2); +float t11517 = mod(t11515,t11516); +float t11518 = (t11517-3.1415927); +float t11519 = (t11362+3.1415927); +float t11520 = (3.1415927*2); +float t11521 = mod(t11519,t11520); +float t11522 = (t11521-3.1415927); +float t11523 = (t11518-t11522); +float t11524 = abs(t11523); +float t11525 = (t11524/2); +float t11526 = sin(t11525); +float t11527 = (t11526*t11526); +float t11528 = (t11514*t11527); +float t11529 = (t11511+t11528); +float t11530 = sqrt(t11529); +float t11531 = asin(t11530); +float t11532 = (2*t11531); +float t11533 = abs(t11532); +float t11534 = (3.1415927/2); +float t11535 = (t8-t11534); +float t11536 = (3.1415927/2); +float t11537 = (t11340-t11536); +float t11538 = (t11535-t11537); +float t11539 = abs(t11538); +float t11540 = (t11539/2); +float t11541 = sin(t11540); +float t11542 = (t11541*t11541); +float t11543 = cos(t11537); +float t11544 = cos(t11535); +float t11545 = (t11543*t11544); +float t11546 = (t118+3.1415927); +float t11547 = (3.1415927*2); +float t11548 = mod(t11546,t11547); +float t11549 = (t11548-3.1415927); +float t11550 = (t11378+3.1415927); +float t11551 = (3.1415927*2); +float t11552 = mod(t11550,t11551); +float t11553 = (t11552-3.1415927); +float t11554 = (t11549-t11553); +float t11555 = abs(t11554); +float t11556 = (t11555/2); +float t11557 = sin(t11556); +float t11558 = (t11557*t11557); +float t11559 = (t11545*t11558); +float t11560 = (t11542+t11559); +float t11561 = sqrt(t11560); +float t11562 = asin(t11561); +float t11563 = (2*t11562); +float t11564 = abs(t11563); +bool t11565 = (t11533>=t11564); +float t11566; +if(t11565){ +t11566 = t11533; +} else { +t11566 = t11564; +} +t11457 = t11566; +} +float t11567 = abs(t11457); +float t11568 = step(float(2.0e-4),t11567); +float t11569 = (1-t11568); +float t11570 = (t10000*t10679); +float t11571 = (t11570*float(842.378)); +float t11572 = fract(t11571); +float t11573 = (t11572+float(45.32)); +float t11574 = (t11573+u6.u0); +float t11575 = (t11572*t11574); +float t11576 = (t10016*t10663); +float t11577 = (t11576*float(1734.048)); +float t11578 = fract(t11577); +float t11579 = (t11578+float(45.32)); +float t11580 = (t11579+u6.u0); +float t11581 = (t11578*t11580); +float t11582 = (t11575+t11581); +float t11583 = (t11572+t11582); +float t11584 = (t11578+t11582); +float t11585 = (t11583*t11584); +float t11586 = fract(t11585); +float t11587 = step(float(0.2),t11586); +float t11588 = (t11569*t11587); +float t11589 = (3.1415927/2); +float t11590 = (t11314-t11589); +float t11591 = (3.1415927/2); +float t11592 = (t11340-t11591); +float t11593 = (t11590-t11592); +float t11594 = abs(t11593); +float t11595 = (t11594/2); +float t11596 = sin(t11595); +float t11597 = (t11596*t11596); +float t11598 = cos(t11592); +float t11599 = cos(t11590); +float t11600 = (t11598*t11599); +float t11601 = (t11362+3.1415927); +float t11602 = (3.1415927*2); +float t11603 = mod(t11601,t11602); +float t11604 = (t11603-3.1415927); +float t11605 = (t11378+3.1415927); +float t11606 = (3.1415927*2); +float t11607 = mod(t11605,t11606); +float t11608 = (t11607-3.1415927); +float t11609 = (t11604-t11608); +float t11610 = abs(t11609); +float t11611 = (t11610/2); +float t11612 = sin(t11611); +float t11613 = (t11612*t11612); +float t11614 = (t11600*t11613); +float t11615 = (t11597+t11614); +float t11616 = sqrt(t11615); +float t11617 = asin(t11616); +float t11618 = (2*t11617); +float t11619 = (t11618/t9998); +float t11620 = (1-t11619); +float t11621 = (t10000/245); +float t11622 = (t11621*float(842.378)); +float t11623 = fract(t11622); +float t11624 = (t11623+float(45.32)); +float t11625 = (t11624+u6.u0); +float t11626 = (t11623*t11625); +float t11627 = (t10016/t10013); +float t11628 = (t11627*float(1734.048)); +float t11629 = fract(t11628); +float t11630 = (t11629+float(45.32)); +float t11631 = (t11630+u6.u0); +float t11632 = (t11629*t11631); +float t11633 = (t11626+t11632); +float t11634 = (t11623+t11633); +float t11635 = (t11629+t11633); +float t11636 = (t11634*t11635); +float t11637 = fract(t11636); +float t11638 = (t11637*float(8.0e-3)); +float t11639 = (float(1.0e-3)+t11638); +float t11640 = (t11637*173); +float t11641 = fract(t11640); +float t11642 = step(float(0.66),t11641); +float t11643 = (t11642*float(3.0e-3)); +float t11644 = (t11639-t11643); +float t11645 = (t11644*float(0.4)); +float t11646 = (t10663/245); +float t11647 = (t11646*float(842.378)); +float t11648 = fract(t11647); +float t11649 = (t11648+float(45.32)); +float t11650 = (t11649+u6.u0); +float t11651 = (t11648*t11650); +float t11652 = (t10679/t10676); +float t11653 = (t11652*float(1734.048)); +float t11654 = fract(t11653); +float t11655 = (t11654+float(45.32)); +float t11656 = (t11655+u6.u0); +float t11657 = (t11654*t11656); +float t11658 = (t11651+t11657); +float t11659 = (t11648+t11658); +float t11660 = (t11654+t11658); +float t11661 = (t11659*t11660); +float t11662 = fract(t11661); +float t11663 = (t11662*float(8.0e-3)); +float t11664 = (float(1.0e-3)+t11663); +float t11665 = (t11662*173); +float t11666 = fract(t11665); +float t11667 = step(float(0.66),t11666); +float t11668 = (t11667*float(3.0e-3)); +float t11669 = (t11664-t11668); +float t11670 = (t11669*float(0.4)); +float t11671 = (t11645-t11670); +float t11672 = abs(t11671); +float t11673 = (t11672-float(1.0e-3)); +float t11674 = (t11673/float(8.0e-3)); +float t11675 = (1-t11674); +float t11676 = (t11675*t11675); +float t11677 = (t11620*t11676); +float t11678 = (t11588*t11677); +float t11679 = (u4.u0*t11586); +float t11680 = (t11679*3); +float t11681 = sin(t11680); +float t11682 = (t11681+1); +float t11683 = (t11682/2); +float t11684 = (t11683*float(0.66)); +float t11685 = (t11684+float(0.33)); +float t11686 = (t11678*t11685); +float t11687 = (float(0.2)*t11686); +bool t11688 = (0>=t11687); +float t11689; +if(t11688){ +t11689 = 0; +} else { +t11689 = t11687; +} +float t11690 = (t11689*0); +float t11691 = (t11290+t11690); +float t11692 = (t10663*t9998); +float t11693 = (t10663/245); +float t11694 = (t11693*float(842.378)); +float t11695 = fract(t11694); +float t11696 = (t11695+float(45.32)); +float t11697 = (t11696+u6.u0); +float t11698 = (t11695*t11697); +float t11699 = (t10679+1); +float t11700 = (t11699/t10676); +float t11701 = (t11700*float(1734.048)); +float t11702 = fract(t11701); +float t11703 = (t11702+float(45.32)); +float t11704 = (t11703+u6.u0); +float t11705 = (t11702*t11704); +float t11706 = (t11698+t11705); +float t11707 = (t11695+t11706); +float t11708 = (t11702+t11706); +float t11709 = (t11707*t11708); +float t11710 = fract(t11709); +float t11711 = (t11710*float(2852.02)); +float t11712 = fract(t11711); +float t11713 = (t11712-float(0.5)); +float t11714 = (t11713*t9998); +float t11715 = (t11714*float(0.75)); +float t11716 = (t11692+t11715); +float t11717 = (3.1415927/2); +float t11718 = (t11716-t11717); +float t11719 = (t10663*t9998); +float t11720 = (t10663/245); +float t11721 = (t11720*float(842.378)); +float t11722 = fract(t11721); +float t11723 = (t11722+float(45.32)); +float t11724 = (t11723+u6.u0); +float t11725 = (t11722*t11724); +float t11726 = (t10679/t10676); +float t11727 = (t11726*float(1734.048)); +float t11728 = fract(t11727); +float t11729 = (t11728+float(45.32)); +float t11730 = (t11729+u6.u0); +float t11731 = (t11728*t11730); +float t11732 = (t11725+t11731); +float t11733 = (t11722+t11732); +float t11734 = (t11728+t11732); +float t11735 = (t11733*t11734); +float t11736 = fract(t11735); +float t11737 = (t11736*float(2852.02)); +float t11738 = fract(t11737); +float t11739 = (t11738-float(0.5)); +float t11740 = (t11739*t9998); +float t11741 = (t11740*float(0.75)); +float t11742 = (t11719+t11741); +float t11743 = (3.1415927/2); +float t11744 = (t11742-t11743); +float t11745 = (t11718-t11744); +float t11746 = abs(t11745); +float t11747 = (t11746/2); +float t11748 = sin(t11747); +float t11749 = (t11748*t11748); +float t11750 = cos(t11744); +float t11751 = cos(t11718); +float t11752 = (t11750*t11751); +float t11753 = (3.1415927/t10676); +float t11754 = (t11699*t11753); +float t11755 = (t11710*float(97372.83)); +float t11756 = fract(t11755); +float t11757 = (t11756-float(0.5)); +float t11758 = (3.1415927/t10676); +float t11759 = (t11757*t11758); +float t11760 = (t11759*float(0.75)); +float t11761 = (t11754+t11760); +float t11762 = (t11761+3.1415927); +float t11763 = mod(t11762,t1433); +float t11764 = (t11763-3.1415927); +float t11765 = (t11764+3.1415927); +float t11766 = (3.1415927*2); +float t11767 = mod(t11765,t11766); +float t11768 = (t11767-3.1415927); +float t11769 = (3.1415927/t10676); +float t11770 = (t10679*t11769); +float t11771 = (t11736*float(97372.83)); +float t11772 = fract(t11771); +float t11773 = (t11772-float(0.5)); +float t11774 = (3.1415927/t10676); +float t11775 = (t11773*t11774); +float t11776 = (t11775*float(0.75)); +float t11777 = (t11770+t11776); +float t11778 = (t11777+3.1415927); +float t11779 = mod(t11778,t1433); +float t11780 = (t11779-3.1415927); +float t11781 = (t11780+3.1415927); +float t11782 = (3.1415927*2); +float t11783 = mod(t11781,t11782); +float t11784 = (t11783-3.1415927); +float t11785 = (t11768-t11784); +float t11786 = abs(t11785); +float t11787 = (t11786/2); +float t11788 = sin(t11787); +float t11789 = (t11788*t11788); +float t11790 = (t11752*t11789); +float t11791 = (t11749+t11790); +float t11792 = sqrt(t11791); +float t11793 = asin(t11792); +float t11794 = (2*t11793); +float t11795 = (3.1415927/2); +float t11796 = (t8-t11795); +float t11797 = (3.1415927/2); +float t11798 = (t11742-t11797); +float t11799 = (t11796-t11798); +float t11800 = abs(t11799); +float t11801 = (t11800/2); +float t11802 = sin(t11801); +float t11803 = (t11802*t11802); +float t11804 = cos(t11798); +float t11805 = cos(t11796); +float t11806 = (t11804*t11805); +float t11807 = (t118+3.1415927); +float t11808 = (3.1415927*2); +float t11809 = mod(t11807,t11808); +float t11810 = (t11809-3.1415927); +float t11811 = (t11780+3.1415927); +float t11812 = (3.1415927*2); +float t11813 = mod(t11811,t11812); +float t11814 = (t11813-3.1415927); +float t11815 = (t11810-t11814); +float t11816 = abs(t11815); +float t11817 = (t11816/2); +float t11818 = sin(t11817); +float t11819 = (t11818*t11818); +float t11820 = (t11806*t11819); +float t11821 = (t11803+t11820); +float t11822 = sqrt(t11821); +float t11823 = asin(t11822); +float t11824 = (2*t11823); +float t11825 = (t11794-t11824); +float t11826 = (3.1415927/2); +float t11827 = (t8-t11826); +float t11828 = (3.1415927/2); +float t11829 = (t11716-t11828); +float t11830 = (t11827-t11829); +float t11831 = abs(t11830); +float t11832 = (t11831/2); +float t11833 = sin(t11832); +float t11834 = (t11833*t11833); +float t11835 = cos(t11829); +float t11836 = cos(t11827); +float t11837 = (t11835*t11836); +float t11838 = (t118+3.1415927); +float t11839 = (3.1415927*2); +float t11840 = mod(t11838,t11839); +float t11841 = (t11840-3.1415927); +float t11842 = (t11764+3.1415927); +float t11843 = (3.1415927*2); +float t11844 = mod(t11842,t11843); +float t11845 = (t11844-3.1415927); +float t11846 = (t11841-t11845); +float t11847 = abs(t11846); +float t11848 = (t11847/2); +float t11849 = sin(t11848); +float t11850 = (t11849*t11849); +float t11851 = (t11837*t11850); +float t11852 = (t11834+t11851); +float t11853 = sqrt(t11852); +float t11854 = asin(t11853); +float t11855 = (2*t11854); +float t11856 = (t11825-t11855); +float t11857 = abs(t11856); +bool t11858 = (float(1.0e-4)>t11857); +float t11859; +if(t11858){ +float t11860 = cos(t11742); +float t11861 = (1*t11860); +float t11862 = sin(t11716); +float t11863 = (1*t11862); +float t11864 = cos(t11764); +float t11865 = (t11863*t11864); +float t11866 = (t11861*t11865); +float t11867 = sin(t11742); +float t11868 = (1*t11867); +float t11869 = cos(t11780); +float t11870 = (t11868*t11869); +float t11871 = cos(t11716); +float t11872 = (1*t11871); +float t11873 = (t11870*t11872); +float t11874 = (t11866-t11873); +float t11875 = sin(t8); +float t11876 = (1*t11875); +float t11877 = sin(t118); +float t11878 = (t11876*t11877); +float t11879 = (t11874*t11878); +float t11880 = sin(t11716); +float t11881 = (1*t11880); +float t11882 = sin(t11764); +float t11883 = (t11881*t11882); +float t11884 = (t11870*t11883); +float t11885 = sin(t11742); +float t11886 = (1*t11885); +float t11887 = sin(t11780); +float t11888 = (t11886*t11887); +float t11889 = (t11888*t11865); +float t11890 = (t11884-t11889); +float t11891 = cos(t8); +float t11892 = (1*t11891); +float t11893 = (t11890*t11892); +float t11894 = (t11879+t11893); +float t11895 = (t11888*t11872); +float t11896 = (t11861*t11883); +float t11897 = (t11895-t11896); +float t11898 = sin(t8); +float t11899 = (1*t11898); +float t11900 = cos(t118); +float t11901 = (t11899*t11900); +float t11902 = (t11897*t11901); +float t11903 = (t11894+t11902); +float t11904 = abs(t11903); +t11859 = t11904; +} else { +float t11905 = (3.1415927/2); +float t11906 = (t8-t11905); +float t11907 = (3.1415927/2); +float t11908 = (t11716-t11907); +float t11909 = (t11906-t11908); +float t11910 = abs(t11909); +float t11911 = (t11910/2); +float t11912 = sin(t11911); +float t11913 = (t11912*t11912); +float t11914 = cos(t11908); +float t11915 = cos(t11906); +float t11916 = (t11914*t11915); +float t11917 = (t118+3.1415927); +float t11918 = (3.1415927*2); +float t11919 = mod(t11917,t11918); +float t11920 = (t11919-3.1415927); +float t11921 = (t11764+3.1415927); +float t11922 = (3.1415927*2); +float t11923 = mod(t11921,t11922); +float t11924 = (t11923-3.1415927); +float t11925 = (t11920-t11924); +float t11926 = abs(t11925); +float t11927 = (t11926/2); +float t11928 = sin(t11927); +float t11929 = (t11928*t11928); +float t11930 = (t11916*t11929); +float t11931 = (t11913+t11930); +float t11932 = sqrt(t11931); +float t11933 = asin(t11932); +float t11934 = (2*t11933); +float t11935 = abs(t11934); +float t11936 = (3.1415927/2); +float t11937 = (t8-t11936); +float t11938 = (3.1415927/2); +float t11939 = (t11742-t11938); +float t11940 = (t11937-t11939); +float t11941 = abs(t11940); +float t11942 = (t11941/2); +float t11943 = sin(t11942); +float t11944 = (t11943*t11943); +float t11945 = cos(t11939); +float t11946 = cos(t11937); +float t11947 = (t11945*t11946); +float t11948 = (t118+3.1415927); +float t11949 = (3.1415927*2); +float t11950 = mod(t11948,t11949); +float t11951 = (t11950-3.1415927); +float t11952 = (t11780+3.1415927); +float t11953 = (3.1415927*2); +float t11954 = mod(t11952,t11953); +float t11955 = (t11954-3.1415927); +float t11956 = (t11951-t11955); +float t11957 = abs(t11956); +float t11958 = (t11957/2); +float t11959 = sin(t11958); +float t11960 = (t11959*t11959); +float t11961 = (t11947*t11960); +float t11962 = (t11944+t11961); +float t11963 = sqrt(t11962); +float t11964 = asin(t11963); +float t11965 = (2*t11964); +float t11966 = abs(t11965); +bool t11967 = (t11935>=t11966); +float t11968; +if(t11967){ +t11968 = t11935; +} else { +t11968 = t11966; +} +t11859 = t11968; +} +float t11969 = abs(t11859); +float t11970 = step(float(2.0e-4),t11969); +float t11971 = (1-t11970); +float t11972 = (t10663*t11699); +float t11973 = (t11972*float(842.378)); +float t11974 = fract(t11973); +float t11975 = (t11974+float(45.32)); +float t11976 = (t11975+u6.u0); +float t11977 = (t11974*t11976); +float t11978 = (t10679*t10663); +float t11979 = (t11978*float(1734.048)); +float t11980 = fract(t11979); +float t11981 = (t11980+float(45.32)); +float t11982 = (t11981+u6.u0); +float t11983 = (t11980*t11982); +float t11984 = (t11977+t11983); +float t11985 = (t11974+t11984); +float t11986 = (t11980+t11984); +float t11987 = (t11985*t11986); +float t11988 = fract(t11987); +float t11989 = step(float(0.2),t11988); +float t11990 = (t11971*t11989); +float t11991 = (3.1415927/2); +float t11992 = (t11716-t11991); +float t11993 = (3.1415927/2); +float t11994 = (t11742-t11993); +float t11995 = (t11992-t11994); +float t11996 = abs(t11995); +float t11997 = (t11996/2); +float t11998 = sin(t11997); +float t11999 = (t11998*t11998); +float t12000 = cos(t11994); +float t12001 = cos(t11992); +float t12002 = (t12000*t12001); +float t12003 = (t11764+3.1415927); +float t12004 = (3.1415927*2); +float t12005 = mod(t12003,t12004); +float t12006 = (t12005-3.1415927); +float t12007 = (t11780+3.1415927); +float t12008 = (3.1415927*2); +float t12009 = mod(t12007,t12008); +float t12010 = (t12009-3.1415927); +float t12011 = (t12006-t12010); +float t12012 = abs(t12011); +float t12013 = (t12012/2); +float t12014 = sin(t12013); +float t12015 = (t12014*t12014); +float t12016 = (t12002*t12015); +float t12017 = (t11999+t12016); +float t12018 = sqrt(t12017); +float t12019 = asin(t12018); +float t12020 = (2*t12019); +float t12021 = (t12020/t9998); +float t12022 = (1-t12021); +float t12023 = (t10663/245); +float t12024 = (t12023*float(842.378)); +float t12025 = fract(t12024); +float t12026 = (t12025+float(45.32)); +float t12027 = (t12026+u6.u0); +float t12028 = (t12025*t12027); +float t12029 = (t10679/t10676); +float t12030 = (t12029*float(1734.048)); +float t12031 = fract(t12030); +float t12032 = (t12031+float(45.32)); +float t12033 = (t12032+u6.u0); +float t12034 = (t12031*t12033); +float t12035 = (t12028+t12034); +float t12036 = (t12025+t12035); +float t12037 = (t12031+t12035); +float t12038 = (t12036*t12037); +float t12039 = fract(t12038); +float t12040 = (t12039*float(8.0e-3)); +float t12041 = (float(1.0e-3)+t12040); +float t12042 = (t12039*173); +float t12043 = fract(t12042); +float t12044 = step(float(0.66),t12043); +float t12045 = (t12044*float(3.0e-3)); +float t12046 = (t12041-t12045); +float t12047 = (t12046*float(0.4)); +float t12048 = (t10663/245); +float t12049 = (t12048*float(842.378)); +float t12050 = fract(t12049); +float t12051 = (t12050+float(45.32)); +float t12052 = (t12051+u6.u0); +float t12053 = (t12050*t12052); +float t12054 = (t11699/t10676); +float t12055 = (t12054*float(1734.048)); +float t12056 = fract(t12055); +float t12057 = (t12056+float(45.32)); +float t12058 = (t12057+u6.u0); +float t12059 = (t12056*t12058); +float t12060 = (t12053+t12059); +float t12061 = (t12050+t12060); +float t12062 = (t12056+t12060); +float t12063 = (t12061*t12062); +float t12064 = fract(t12063); +float t12065 = (t12064*float(8.0e-3)); +float t12066 = (float(1.0e-3)+t12065); +float t12067 = (t12064*173); +float t12068 = fract(t12067); +float t12069 = step(float(0.66),t12068); +float t12070 = (t12069*float(3.0e-3)); +float t12071 = (t12066-t12070); +float t12072 = (t12071*float(0.4)); +float t12073 = (t12047-t12072); +float t12074 = abs(t12073); +float t12075 = (t12074-float(1.0e-3)); +float t12076 = (t12075/float(8.0e-3)); +float t12077 = (1-t12076); +float t12078 = (t12077*t12077); +float t12079 = (t12022*t12078); +float t12080 = (t11990*t12079); +float t12081 = (u4.u0*t11988); +float t12082 = (t12081*3); +float t12083 = sin(t12082); +float t12084 = (t12083+1); +float t12085 = (t12084/2); +float t12086 = (t12085*float(0.66)); +float t12087 = (t12086+float(0.33)); +float t12088 = (t12080*t12087); +float t12089 = (float(0.2)*t12088); +bool t12090 = (0>=t12089); +float t12091; +if(t12090){ +t12091 = 0; +} else { +t12091 = t12089; +} +float t12092 = (t12091*0); +float t12093 = (t11691+t12092); +float t12094 = (t10663*t9998); +float t12095 = (t10663/245); +float t12096 = (t12095*float(842.378)); +float t12097 = fract(t12096); +float t12098 = (t12097+float(45.32)); +float t12099 = (t12098+u6.u0); +float t12100 = (t12097*t12099); +float t12101 = (t11699/t10676); +float t12102 = (t12101*float(1734.048)); +float t12103 = fract(t12102); +float t12104 = (t12103+float(45.32)); +float t12105 = (t12104+u6.u0); +float t12106 = (t12103*t12105); +float t12107 = (t12100+t12106); +float t12108 = (t12097+t12107); +float t12109 = (t12103+t12107); +float t12110 = (t12108*t12109); +float t12111 = fract(t12110); +float t12112 = (t12111*float(2852.02)); +float t12113 = fract(t12112); +float t12114 = (t12113-float(0.5)); +float t12115 = (t12114*t9998); +float t12116 = (t12115*float(0.75)); +float t12117 = (t12094+t12116); +float t12118 = (3.1415927/2); +float t12119 = (t12117-t12118); +float t12120 = (t10000*t9998); +float t12121 = (t10000/245); +float t12122 = (t12121*float(842.378)); +float t12123 = fract(t12122); +float t12124 = (t12123+float(45.32)); +float t12125 = (t12124+u6.u0); +float t12126 = (t12123*t12125); +float t12127 = (t10234/t10013); +float t12128 = (t12127*float(1734.048)); +float t12129 = fract(t12128); +float t12130 = (t12129+float(45.32)); +float t12131 = (t12130+u6.u0); +float t12132 = (t12129*t12131); +float t12133 = (t12126+t12132); +float t12134 = (t12123+t12133); +float t12135 = (t12129+t12133); +float t12136 = (t12134*t12135); +float t12137 = fract(t12136); +float t12138 = (t12137*float(2852.02)); +float t12139 = fract(t12138); +float t12140 = (t12139-float(0.5)); +float t12141 = (t12140*t9998); +float t12142 = (t12141*float(0.75)); +float t12143 = (t12120+t12142); +float t12144 = (3.1415927/2); +float t12145 = (t12143-t12144); +float t12146 = (t12119-t12145); +float t12147 = abs(t12146); +float t12148 = (t12147/2); +float t12149 = sin(t12148); +float t12150 = (t12149*t12149); +float t12151 = cos(t12145); +float t12152 = cos(t12119); +float t12153 = (t12151*t12152); +float t12154 = (3.1415927/t10676); +float t12155 = (t11699*t12154); +float t12156 = (t12111*float(97372.83)); +float t12157 = fract(t12156); +float t12158 = (t12157-float(0.5)); +float t12159 = (3.1415927/t10676); +float t12160 = (t12158*t12159); +float t12161 = (t12160*float(0.75)); +float t12162 = (t12155+t12161); +float t12163 = (t12162+3.1415927); +float t12164 = mod(t12163,t1433); +float t12165 = (t12164-3.1415927); +float t12166 = (t12165+3.1415927); +float t12167 = (3.1415927*2); +float t12168 = mod(t12166,t12167); +float t12169 = (t12168-3.1415927); +float t12170 = (3.1415927/t10013); +float t12171 = (t10234*t12170); +float t12172 = (t12137*float(97372.83)); +float t12173 = fract(t12172); +float t12174 = (t12173-float(0.5)); +float t12175 = (3.1415927/t10013); +float t12176 = (t12174*t12175); +float t12177 = (t12176*float(0.75)); +float t12178 = (t12171+t12177); +float t12179 = (t12178+3.1415927); +float t12180 = mod(t12179,t1433); +float t12181 = (t12180-3.1415927); +float t12182 = (t12181+3.1415927); +float t12183 = (3.1415927*2); +float t12184 = mod(t12182,t12183); +float t12185 = (t12184-3.1415927); +float t12186 = (t12169-t12185); +float t12187 = abs(t12186); +float t12188 = (t12187/2); +float t12189 = sin(t12188); +float t12190 = (t12189*t12189); +float t12191 = (t12153*t12190); +float t12192 = (t12150+t12191); +float t12193 = sqrt(t12192); +float t12194 = asin(t12193); +float t12195 = (2*t12194); +float t12196 = (3.1415927/2); +float t12197 = (t8-t12196); +float t12198 = (3.1415927/2); +float t12199 = (t12143-t12198); +float t12200 = (t12197-t12199); +float t12201 = abs(t12200); +float t12202 = (t12201/2); +float t12203 = sin(t12202); +float t12204 = (t12203*t12203); +float t12205 = cos(t12199); +float t12206 = cos(t12197); +float t12207 = (t12205*t12206); +float t12208 = (t118+3.1415927); +float t12209 = (3.1415927*2); +float t12210 = mod(t12208,t12209); +float t12211 = (t12210-3.1415927); +float t12212 = (t12181+3.1415927); +float t12213 = (3.1415927*2); +float t12214 = mod(t12212,t12213); +float t12215 = (t12214-3.1415927); +float t12216 = (t12211-t12215); +float t12217 = abs(t12216); +float t12218 = (t12217/2); +float t12219 = sin(t12218); +float t12220 = (t12219*t12219); +float t12221 = (t12207*t12220); +float t12222 = (t12204+t12221); +float t12223 = sqrt(t12222); +float t12224 = asin(t12223); +float t12225 = (2*t12224); +float t12226 = (t12195-t12225); +float t12227 = (3.1415927/2); +float t12228 = (t8-t12227); +float t12229 = (3.1415927/2); +float t12230 = (t12117-t12229); +float t12231 = (t12228-t12230); +float t12232 = abs(t12231); +float t12233 = (t12232/2); +float t12234 = sin(t12233); +float t12235 = (t12234*t12234); +float t12236 = cos(t12230); +float t12237 = cos(t12228); +float t12238 = (t12236*t12237); +float t12239 = (t118+3.1415927); +float t12240 = (3.1415927*2); +float t12241 = mod(t12239,t12240); +float t12242 = (t12241-3.1415927); +float t12243 = (t12165+3.1415927); +float t12244 = (3.1415927*2); +float t12245 = mod(t12243,t12244); +float t12246 = (t12245-3.1415927); +float t12247 = (t12242-t12246); +float t12248 = abs(t12247); +float t12249 = (t12248/2); +float t12250 = sin(t12249); +float t12251 = (t12250*t12250); +float t12252 = (t12238*t12251); +float t12253 = (t12235+t12252); +float t12254 = sqrt(t12253); +float t12255 = asin(t12254); +float t12256 = (2*t12255); +float t12257 = (t12226-t12256); +float t12258 = abs(t12257); +bool t12259 = (float(1.0e-4)>t12258); +float t12260; +if(t12259){ +float t12261 = cos(t12143); +float t12262 = (1*t12261); +float t12263 = sin(t12117); +float t12264 = (1*t12263); +float t12265 = cos(t12165); +float t12266 = (t12264*t12265); +float t12267 = (t12262*t12266); +float t12268 = sin(t12143); +float t12269 = (1*t12268); +float t12270 = cos(t12181); +float t12271 = (t12269*t12270); +float t12272 = cos(t12117); +float t12273 = (1*t12272); +float t12274 = (t12271*t12273); +float t12275 = (t12267-t12274); +float t12276 = sin(t8); +float t12277 = (1*t12276); +float t12278 = sin(t118); +float t12279 = (t12277*t12278); +float t12280 = (t12275*t12279); +float t12281 = sin(t12117); +float t12282 = (1*t12281); +float t12283 = sin(t12165); +float t12284 = (t12282*t12283); +float t12285 = (t12271*t12284); +float t12286 = sin(t12143); +float t12287 = (1*t12286); +float t12288 = sin(t12181); +float t12289 = (t12287*t12288); +float t12290 = (t12289*t12266); +float t12291 = (t12285-t12290); +float t12292 = cos(t8); +float t12293 = (1*t12292); +float t12294 = (t12291*t12293); +float t12295 = (t12280+t12294); +float t12296 = (t12289*t12273); +float t12297 = (t12262*t12284); +float t12298 = (t12296-t12297); +float t12299 = sin(t8); +float t12300 = (1*t12299); +float t12301 = cos(t118); +float t12302 = (t12300*t12301); +float t12303 = (t12298*t12302); +float t12304 = (t12295+t12303); +float t12305 = abs(t12304); +t12260 = t12305; +} else { +float t12306 = (3.1415927/2); +float t12307 = (t8-t12306); +float t12308 = (3.1415927/2); +float t12309 = (t12117-t12308); +float t12310 = (t12307-t12309); +float t12311 = abs(t12310); +float t12312 = (t12311/2); +float t12313 = sin(t12312); +float t12314 = (t12313*t12313); +float t12315 = cos(t12309); +float t12316 = cos(t12307); +float t12317 = (t12315*t12316); +float t12318 = (t118+3.1415927); +float t12319 = (3.1415927*2); +float t12320 = mod(t12318,t12319); +float t12321 = (t12320-3.1415927); +float t12322 = (t12165+3.1415927); +float t12323 = (3.1415927*2); +float t12324 = mod(t12322,t12323); +float t12325 = (t12324-3.1415927); +float t12326 = (t12321-t12325); +float t12327 = abs(t12326); +float t12328 = (t12327/2); +float t12329 = sin(t12328); +float t12330 = (t12329*t12329); +float t12331 = (t12317*t12330); +float t12332 = (t12314+t12331); +float t12333 = sqrt(t12332); +float t12334 = asin(t12333); +float t12335 = (2*t12334); +float t12336 = abs(t12335); +float t12337 = (3.1415927/2); +float t12338 = (t8-t12337); +float t12339 = (3.1415927/2); +float t12340 = (t12143-t12339); +float t12341 = (t12338-t12340); +float t12342 = abs(t12341); +float t12343 = (t12342/2); +float t12344 = sin(t12343); +float t12345 = (t12344*t12344); +float t12346 = cos(t12340); +float t12347 = cos(t12338); +float t12348 = (t12346*t12347); +float t12349 = (t118+3.1415927); +float t12350 = (3.1415927*2); +float t12351 = mod(t12349,t12350); +float t12352 = (t12351-3.1415927); +float t12353 = (t12181+3.1415927); +float t12354 = (3.1415927*2); +float t12355 = mod(t12353,t12354); +float t12356 = (t12355-3.1415927); +float t12357 = (t12352-t12356); +float t12358 = abs(t12357); +float t12359 = (t12358/2); +float t12360 = sin(t12359); +float t12361 = (t12360*t12360); +float t12362 = (t12348*t12361); +float t12363 = (t12345+t12362); +float t12364 = sqrt(t12363); +float t12365 = asin(t12364); +float t12366 = (2*t12365); +float t12367 = abs(t12366); +bool t12368 = (t12336>=t12367); +float t12369; +if(t12368){ +t12369 = t12336; +} else { +t12369 = t12367; +} +t12260 = t12369; +} +float t12370 = abs(t12260); +float t12371 = step(float(2.0e-4),t12370); +float t12372 = (1-t12371); +float t12373 = (t10000*t11699); +float t12374 = (t12373*float(842.378)); +float t12375 = fract(t12374); +float t12376 = (t12375+float(45.32)); +float t12377 = (t12376+u6.u0); +float t12378 = (t12375*t12377); +float t12379 = (t10234*t10663); +float t12380 = (t12379*float(1734.048)); +float t12381 = fract(t12380); +float t12382 = (t12381+float(45.32)); +float t12383 = (t12382+u6.u0); +float t12384 = (t12381*t12383); +float t12385 = (t12378+t12384); +float t12386 = (t12375+t12385); +float t12387 = (t12381+t12385); +float t12388 = (t12386*t12387); +float t12389 = fract(t12388); +float t12390 = step(float(0.2),t12389); +float t12391 = (t12372*t12390); +float t12392 = (3.1415927/2); +float t12393 = (t12117-t12392); +float t12394 = (3.1415927/2); +float t12395 = (t12143-t12394); +float t12396 = (t12393-t12395); +float t12397 = abs(t12396); +float t12398 = (t12397/2); +float t12399 = sin(t12398); +float t12400 = (t12399*t12399); +float t12401 = cos(t12395); +float t12402 = cos(t12393); +float t12403 = (t12401*t12402); +float t12404 = (t12165+3.1415927); +float t12405 = (3.1415927*2); +float t12406 = mod(t12404,t12405); +float t12407 = (t12406-3.1415927); +float t12408 = (t12181+3.1415927); +float t12409 = (3.1415927*2); +float t12410 = mod(t12408,t12409); +float t12411 = (t12410-3.1415927); +float t12412 = (t12407-t12411); +float t12413 = abs(t12412); +float t12414 = (t12413/2); +float t12415 = sin(t12414); +float t12416 = (t12415*t12415); +float t12417 = (t12403*t12416); +float t12418 = (t12400+t12417); +float t12419 = sqrt(t12418); +float t12420 = asin(t12419); +float t12421 = (2*t12420); +float t12422 = (t12421/t9998); +float t12423 = (1-t12422); +float t12424 = (t10000/245); +float t12425 = (t12424*float(842.378)); +float t12426 = fract(t12425); +float t12427 = (t12426+float(45.32)); +float t12428 = (t12427+u6.u0); +float t12429 = (t12426*t12428); +float t12430 = (t10234/t10013); +float t12431 = (t12430*float(1734.048)); +float t12432 = fract(t12431); +float t12433 = (t12432+float(45.32)); +float t12434 = (t12433+u6.u0); +float t12435 = (t12432*t12434); +float t12436 = (t12429+t12435); +float t12437 = (t12426+t12436); +float t12438 = (t12432+t12436); +float t12439 = (t12437*t12438); +float t12440 = fract(t12439); +float t12441 = (t12440*float(8.0e-3)); +float t12442 = (float(1.0e-3)+t12441); +float t12443 = (t12440*173); +float t12444 = fract(t12443); +float t12445 = step(float(0.66),t12444); +float t12446 = (t12445*float(3.0e-3)); +float t12447 = (t12442-t12446); +float t12448 = (t12447*float(0.4)); +float t12449 = (t10663/245); +float t12450 = (t12449*float(842.378)); +float t12451 = fract(t12450); +float t12452 = (t12451+float(45.32)); +float t12453 = (t12452+u6.u0); +float t12454 = (t12451*t12453); +float t12455 = (t11699/t10676); +float t12456 = (t12455*float(1734.048)); +float t12457 = fract(t12456); +float t12458 = (t12457+float(45.32)); +float t12459 = (t12458+u6.u0); +float t12460 = (t12457*t12459); +float t12461 = (t12454+t12460); +float t12462 = (t12451+t12461); +float t12463 = (t12457+t12461); +float t12464 = (t12462*t12463); +float t12465 = fract(t12464); +float t12466 = (t12465*float(8.0e-3)); +float t12467 = (float(1.0e-3)+t12466); +float t12468 = (t12465*173); +float t12469 = fract(t12468); +float t12470 = step(float(0.66),t12469); +float t12471 = (t12470*float(3.0e-3)); +float t12472 = (t12467-t12471); +float t12473 = (t12472*float(0.4)); +float t12474 = (t12448-t12473); +float t12475 = abs(t12474); +float t12476 = (t12475-float(1.0e-3)); +float t12477 = (t12476/float(8.0e-3)); +float t12478 = (1-t12477); +float t12479 = (t12478*t12478); +float t12480 = (t12423*t12479); +float t12481 = (t12391*t12480); +float t12482 = (u4.u0*t12389); +float t12483 = (t12482*3); +float t12484 = sin(t12483); +float t12485 = (t12484+1); +float t12486 = (t12485/2); +float t12487 = (t12486*float(0.66)); +float t12488 = (t12487+float(0.33)); +float t12489 = (t12481*t12488); +float t12490 = (float(0.2)*t12489); +bool t12491 = (0>=t12490); +float t12492; +if(t12491){ +t12492 = 0; +} else { +t12492 = t12490; +} +float t12493 = (t12492*0); +float t12494 = (t12093+t12493); +float t12495 = (t10663*t9998); +float t12496 = (t10663/245); +float t12497 = (t12496*float(842.378)); +float t12498 = fract(t12497); +float t12499 = (t12498+float(45.32)); +float t12500 = (t12499+u6.u0); +float t12501 = (t12498*t12500); +float t12502 = (t11699/t10676); +float t12503 = (t12502*float(1734.048)); +float t12504 = fract(t12503); +float t12505 = (t12504+float(45.32)); +float t12506 = (t12505+u6.u0); +float t12507 = (t12504*t12506); +float t12508 = (t12501+t12507); +float t12509 = (t12498+t12508); +float t12510 = (t12504+t12508); +float t12511 = (t12509*t12510); +float t12512 = fract(t12511); +float t12513 = (t12512*float(2852.02)); +float t12514 = fract(t12513); +float t12515 = (t12514-float(0.5)); +float t12516 = (t12515*t9998); +float t12517 = (t12516*float(0.75)); +float t12518 = (t12495+t12517); +float t12519 = (3.1415927/2); +float t12520 = (t12518-t12519); +float t12521 = (t10000*t9998); +float t12522 = (t10000/245); +float t12523 = (t12522*float(842.378)); +float t12524 = fract(t12523); +float t12525 = (t12524+float(45.32)); +float t12526 = (t12525+u6.u0); +float t12527 = (t12524*t12526); +float t12528 = (t10016/t10013); +float t12529 = (t12528*float(1734.048)); +float t12530 = fract(t12529); +float t12531 = (t12530+float(45.32)); +float t12532 = (t12531+u6.u0); +float t12533 = (t12530*t12532); +float t12534 = (t12527+t12533); +float t12535 = (t12524+t12534); +float t12536 = (t12530+t12534); +float t12537 = (t12535*t12536); +float t12538 = fract(t12537); +float t12539 = (t12538*float(2852.02)); +float t12540 = fract(t12539); +float t12541 = (t12540-float(0.5)); +float t12542 = (t12541*t9998); +float t12543 = (t12542*float(0.75)); +float t12544 = (t12521+t12543); +float t12545 = (3.1415927/2); +float t12546 = (t12544-t12545); +float t12547 = (t12520-t12546); +float t12548 = abs(t12547); +float t12549 = (t12548/2); +float t12550 = sin(t12549); +float t12551 = (t12550*t12550); +float t12552 = cos(t12546); +float t12553 = cos(t12520); +float t12554 = (t12552*t12553); +float t12555 = (3.1415927/t10676); +float t12556 = (t11699*t12555); +float t12557 = (t12512*float(97372.83)); +float t12558 = fract(t12557); +float t12559 = (t12558-float(0.5)); +float t12560 = (3.1415927/t10676); +float t12561 = (t12559*t12560); +float t12562 = (t12561*float(0.75)); +float t12563 = (t12556+t12562); +float t12564 = (t12563+3.1415927); +float t12565 = mod(t12564,t1433); +float t12566 = (t12565-3.1415927); +float t12567 = (t12566+3.1415927); +float t12568 = (3.1415927*2); +float t12569 = mod(t12567,t12568); +float t12570 = (t12569-3.1415927); +float t12571 = (3.1415927/t10013); +float t12572 = (t10016*t12571); +float t12573 = (t12538*float(97372.83)); +float t12574 = fract(t12573); +float t12575 = (t12574-float(0.5)); +float t12576 = (3.1415927/t10013); +float t12577 = (t12575*t12576); +float t12578 = (t12577*float(0.75)); +float t12579 = (t12572+t12578); +float t12580 = (t12579+3.1415927); +float t12581 = mod(t12580,t1433); +float t12582 = (t12581-3.1415927); +float t12583 = (t12582+3.1415927); +float t12584 = (3.1415927*2); +float t12585 = mod(t12583,t12584); +float t12586 = (t12585-3.1415927); +float t12587 = (t12570-t12586); +float t12588 = abs(t12587); +float t12589 = (t12588/2); +float t12590 = sin(t12589); +float t12591 = (t12590*t12590); +float t12592 = (t12554*t12591); +float t12593 = (t12551+t12592); +float t12594 = sqrt(t12593); +float t12595 = asin(t12594); +float t12596 = (2*t12595); +float t12597 = (3.1415927/2); +float t12598 = (t8-t12597); +float t12599 = (3.1415927/2); +float t12600 = (t12544-t12599); +float t12601 = (t12598-t12600); +float t12602 = abs(t12601); +float t12603 = (t12602/2); +float t12604 = sin(t12603); +float t12605 = (t12604*t12604); +float t12606 = cos(t12600); +float t12607 = cos(t12598); +float t12608 = (t12606*t12607); +float t12609 = (t118+3.1415927); +float t12610 = (3.1415927*2); +float t12611 = mod(t12609,t12610); +float t12612 = (t12611-3.1415927); +float t12613 = (t12582+3.1415927); +float t12614 = (3.1415927*2); +float t12615 = mod(t12613,t12614); +float t12616 = (t12615-3.1415927); +float t12617 = (t12612-t12616); +float t12618 = abs(t12617); +float t12619 = (t12618/2); +float t12620 = sin(t12619); +float t12621 = (t12620*t12620); +float t12622 = (t12608*t12621); +float t12623 = (t12605+t12622); +float t12624 = sqrt(t12623); +float t12625 = asin(t12624); +float t12626 = (2*t12625); +float t12627 = (t12596-t12626); +float t12628 = (3.1415927/2); +float t12629 = (t8-t12628); +float t12630 = (3.1415927/2); +float t12631 = (t12518-t12630); +float t12632 = (t12629-t12631); +float t12633 = abs(t12632); +float t12634 = (t12633/2); +float t12635 = sin(t12634); +float t12636 = (t12635*t12635); +float t12637 = cos(t12631); +float t12638 = cos(t12629); +float t12639 = (t12637*t12638); +float t12640 = (t118+3.1415927); +float t12641 = (3.1415927*2); +float t12642 = mod(t12640,t12641); +float t12643 = (t12642-3.1415927); +float t12644 = (t12566+3.1415927); +float t12645 = (3.1415927*2); +float t12646 = mod(t12644,t12645); +float t12647 = (t12646-3.1415927); +float t12648 = (t12643-t12647); +float t12649 = abs(t12648); +float t12650 = (t12649/2); +float t12651 = sin(t12650); +float t12652 = (t12651*t12651); +float t12653 = (t12639*t12652); +float t12654 = (t12636+t12653); +float t12655 = sqrt(t12654); +float t12656 = asin(t12655); +float t12657 = (2*t12656); +float t12658 = (t12627-t12657); +float t12659 = abs(t12658); +bool t12660 = (float(1.0e-4)>t12659); +float t12661; +if(t12660){ +float t12662 = cos(t12544); +float t12663 = (1*t12662); +float t12664 = sin(t12518); +float t12665 = (1*t12664); +float t12666 = cos(t12566); +float t12667 = (t12665*t12666); +float t12668 = (t12663*t12667); +float t12669 = sin(t12544); +float t12670 = (1*t12669); +float t12671 = cos(t12582); +float t12672 = (t12670*t12671); +float t12673 = cos(t12518); +float t12674 = (1*t12673); +float t12675 = (t12672*t12674); +float t12676 = (t12668-t12675); +float t12677 = sin(t8); +float t12678 = (1*t12677); +float t12679 = sin(t118); +float t12680 = (t12678*t12679); +float t12681 = (t12676*t12680); +float t12682 = sin(t12518); +float t12683 = (1*t12682); +float t12684 = sin(t12566); +float t12685 = (t12683*t12684); +float t12686 = (t12672*t12685); +float t12687 = sin(t12544); +float t12688 = (1*t12687); +float t12689 = sin(t12582); +float t12690 = (t12688*t12689); +float t12691 = (t12690*t12667); +float t12692 = (t12686-t12691); +float t12693 = cos(t8); +float t12694 = (1*t12693); +float t12695 = (t12692*t12694); +float t12696 = (t12681+t12695); +float t12697 = (t12690*t12674); +float t12698 = (t12663*t12685); +float t12699 = (t12697-t12698); +float t12700 = sin(t8); +float t12701 = (1*t12700); +float t12702 = cos(t118); +float t12703 = (t12701*t12702); +float t12704 = (t12699*t12703); +float t12705 = (t12696+t12704); +float t12706 = abs(t12705); +t12661 = t12706; +} else { +float t12707 = (3.1415927/2); +float t12708 = (t8-t12707); +float t12709 = (3.1415927/2); +float t12710 = (t12518-t12709); +float t12711 = (t12708-t12710); +float t12712 = abs(t12711); +float t12713 = (t12712/2); +float t12714 = sin(t12713); +float t12715 = (t12714*t12714); +float t12716 = cos(t12710); +float t12717 = cos(t12708); +float t12718 = (t12716*t12717); +float t12719 = (t118+3.1415927); +float t12720 = (3.1415927*2); +float t12721 = mod(t12719,t12720); +float t12722 = (t12721-3.1415927); +float t12723 = (t12566+3.1415927); +float t12724 = (3.1415927*2); +float t12725 = mod(t12723,t12724); +float t12726 = (t12725-3.1415927); +float t12727 = (t12722-t12726); +float t12728 = abs(t12727); +float t12729 = (t12728/2); +float t12730 = sin(t12729); +float t12731 = (t12730*t12730); +float t12732 = (t12718*t12731); +float t12733 = (t12715+t12732); +float t12734 = sqrt(t12733); +float t12735 = asin(t12734); +float t12736 = (2*t12735); +float t12737 = abs(t12736); +float t12738 = (3.1415927/2); +float t12739 = (t8-t12738); +float t12740 = (3.1415927/2); +float t12741 = (t12544-t12740); +float t12742 = (t12739-t12741); +float t12743 = abs(t12742); +float t12744 = (t12743/2); +float t12745 = sin(t12744); +float t12746 = (t12745*t12745); +float t12747 = cos(t12741); +float t12748 = cos(t12739); +float t12749 = (t12747*t12748); +float t12750 = (t118+3.1415927); +float t12751 = (3.1415927*2); +float t12752 = mod(t12750,t12751); +float t12753 = (t12752-3.1415927); +float t12754 = (t12582+3.1415927); +float t12755 = (3.1415927*2); +float t12756 = mod(t12754,t12755); +float t12757 = (t12756-3.1415927); +float t12758 = (t12753-t12757); +float t12759 = abs(t12758); +float t12760 = (t12759/2); +float t12761 = sin(t12760); +float t12762 = (t12761*t12761); +float t12763 = (t12749*t12762); +float t12764 = (t12746+t12763); +float t12765 = sqrt(t12764); +float t12766 = asin(t12765); +float t12767 = (2*t12766); +float t12768 = abs(t12767); +bool t12769 = (t12737>=t12768); +float t12770; +if(t12769){ +t12770 = t12737; +} else { +t12770 = t12768; +} +t12661 = t12770; +} +float t12771 = abs(t12661); +float t12772 = step(float(2.0e-4),t12771); +float t12773 = (1-t12772); +float t12774 = (t10000*t11699); +float t12775 = (t12774*float(842.378)); +float t12776 = fract(t12775); +float t12777 = (t12776+float(45.32)); +float t12778 = (t12777+u6.u0); +float t12779 = (t12776*t12778); +float t12780 = (t10016*t10663); +float t12781 = (t12780*float(1734.048)); +float t12782 = fract(t12781); +float t12783 = (t12782+float(45.32)); +float t12784 = (t12783+u6.u0); +float t12785 = (t12782*t12784); +float t12786 = (t12779+t12785); +float t12787 = (t12776+t12786); +float t12788 = (t12782+t12786); +float t12789 = (t12787*t12788); +float t12790 = fract(t12789); +float t12791 = step(float(0.2),t12790); +float t12792 = (t12773*t12791); +float t12793 = (3.1415927/2); +float t12794 = (t12518-t12793); +float t12795 = (3.1415927/2); +float t12796 = (t12544-t12795); +float t12797 = (t12794-t12796); +float t12798 = abs(t12797); +float t12799 = (t12798/2); +float t12800 = sin(t12799); +float t12801 = (t12800*t12800); +float t12802 = cos(t12796); +float t12803 = cos(t12794); +float t12804 = (t12802*t12803); +float t12805 = (t12566+3.1415927); +float t12806 = (3.1415927*2); +float t12807 = mod(t12805,t12806); +float t12808 = (t12807-3.1415927); +float t12809 = (t12582+3.1415927); +float t12810 = (3.1415927*2); +float t12811 = mod(t12809,t12810); +float t12812 = (t12811-3.1415927); +float t12813 = (t12808-t12812); +float t12814 = abs(t12813); +float t12815 = (t12814/2); +float t12816 = sin(t12815); +float t12817 = (t12816*t12816); +float t12818 = (t12804*t12817); +float t12819 = (t12801+t12818); +float t12820 = sqrt(t12819); +float t12821 = asin(t12820); +float t12822 = (2*t12821); +float t12823 = (t12822/t9998); +float t12824 = (1-t12823); +float t12825 = (t10000/245); +float t12826 = (t12825*float(842.378)); +float t12827 = fract(t12826); +float t12828 = (t12827+float(45.32)); +float t12829 = (t12828+u6.u0); +float t12830 = (t12827*t12829); +float t12831 = (t10016/t10013); +float t12832 = (t12831*float(1734.048)); +float t12833 = fract(t12832); +float t12834 = (t12833+float(45.32)); +float t12835 = (t12834+u6.u0); +float t12836 = (t12833*t12835); +float t12837 = (t12830+t12836); +float t12838 = (t12827+t12837); +float t12839 = (t12833+t12837); +float t12840 = (t12838*t12839); +float t12841 = fract(t12840); +float t12842 = (t12841*float(8.0e-3)); +float t12843 = (float(1.0e-3)+t12842); +float t12844 = (t12841*173); +float t12845 = fract(t12844); +float t12846 = step(float(0.66),t12845); +float t12847 = (t12846*float(3.0e-3)); +float t12848 = (t12843-t12847); +float t12849 = (t12848*float(0.4)); +float t12850 = (t10663/245); +float t12851 = (t12850*float(842.378)); +float t12852 = fract(t12851); +float t12853 = (t12852+float(45.32)); +float t12854 = (t12853+u6.u0); +float t12855 = (t12852*t12854); +float t12856 = (t11699/t10676); +float t12857 = (t12856*float(1734.048)); +float t12858 = fract(t12857); +float t12859 = (t12858+float(45.32)); +float t12860 = (t12859+u6.u0); +float t12861 = (t12858*t12860); +float t12862 = (t12855+t12861); +float t12863 = (t12852+t12862); +float t12864 = (t12858+t12862); +float t12865 = (t12863*t12864); +float t12866 = fract(t12865); +float t12867 = (t12866*float(8.0e-3)); +float t12868 = (float(1.0e-3)+t12867); +float t12869 = (t12866*173); +float t12870 = fract(t12869); +float t12871 = step(float(0.66),t12870); +float t12872 = (t12871*float(3.0e-3)); +float t12873 = (t12868-t12872); +float t12874 = (t12873*float(0.4)); +float t12875 = (t12849-t12874); +float t12876 = abs(t12875); +float t12877 = (t12876-float(1.0e-3)); +float t12878 = (t12877/float(8.0e-3)); +float t12879 = (1-t12878); +float t12880 = (t12879*t12879); +float t12881 = (t12824*t12880); +float t12882 = (t12792*t12881); +float t12883 = (u4.u0*t12790); +float t12884 = (t12883*3); +float t12885 = sin(t12884); +float t12886 = (t12885+1); +float t12887 = (t12886/2); +float t12888 = (t12887*float(0.66)); +float t12889 = (t12888+float(0.33)); +float t12890 = (t12882*t12889); +float t12891 = (float(0.2)*t12890); +bool t12892 = (0>=t12891); +float t12893; +if(t12892){ +t12893 = 0; +} else { +t12893 = t12891; +} +float t12894 = (t12893*0); +float t12895 = (t12494+t12894); +float t12896 = (t10000*t9998); +float t12897 = (t10000/245); +float t12898 = (t12897*float(842.378)); +float t12899 = fract(t12898); +float t12900 = (t12899+float(45.32)); +float t12901 = (t12900+u6.u0); +float t12902 = (t12899*t12901); +float t12903 = (t10452/t10013); +float t12904 = (t12903*float(1734.048)); +float t12905 = fract(t12904); +float t12906 = (t12905+float(45.32)); +float t12907 = (t12906+u6.u0); +float t12908 = (t12905*t12907); +float t12909 = (t12902+t12908); +float t12910 = (t12899+t12909); +float t12911 = (t12905+t12909); +float t12912 = (t12910*t12911); +float t12913 = fract(t12912); +float t12914 = (t12913*float(2852.02)); +float t12915 = fract(t12914); +float t12916 = (t12915-float(0.5)); +float t12917 = (t12916*t9998); +float t12918 = (t12917*float(0.75)); +float t12919 = (t12896+t12918); +float t12920 = (3.1415927/2); +float t12921 = (t12919-t12920); +float t12922 = (t10000*t9998); +float t12923 = (t10000/245); +float t12924 = (t12923*float(842.378)); +float t12925 = fract(t12924); +float t12926 = (t12925+float(45.32)); +float t12927 = (t12926+u6.u0); +float t12928 = (t12925*t12927); +float t12929 = (t10234/t10013); +float t12930 = (t12929*float(1734.048)); +float t12931 = fract(t12930); +float t12932 = (t12931+float(45.32)); +float t12933 = (t12932+u6.u0); +float t12934 = (t12931*t12933); +float t12935 = (t12928+t12934); +float t12936 = (t12925+t12935); +float t12937 = (t12931+t12935); +float t12938 = (t12936*t12937); +float t12939 = fract(t12938); +float t12940 = (t12939*float(2852.02)); +float t12941 = fract(t12940); +float t12942 = (t12941-float(0.5)); +float t12943 = (t12942*t9998); +float t12944 = (t12943*float(0.75)); +float t12945 = (t12922+t12944); +float t12946 = (3.1415927/2); +float t12947 = (t12945-t12946); +float t12948 = (t12921-t12947); +float t12949 = abs(t12948); +float t12950 = (t12949/2); +float t12951 = sin(t12950); +float t12952 = (t12951*t12951); +float t12953 = cos(t12947); +float t12954 = cos(t12921); +float t12955 = (t12953*t12954); +float t12956 = (3.1415927/t10013); +float t12957 = (t10452*t12956); +float t12958 = (t12913*float(97372.83)); +float t12959 = fract(t12958); +float t12960 = (t12959-float(0.5)); +float t12961 = (3.1415927/t10013); +float t12962 = (t12960*t12961); +float t12963 = (t12962*float(0.75)); +float t12964 = (t12957+t12963); +float t12965 = (t12964+3.1415927); +float t12966 = mod(t12965,t1433); +float t12967 = (t12966-3.1415927); +float t12968 = (t12967+3.1415927); +float t12969 = (3.1415927*2); +float t12970 = mod(t12968,t12969); +float t12971 = (t12970-3.1415927); +float t12972 = (3.1415927/t10013); +float t12973 = (t10234*t12972); +float t12974 = (t12939*float(97372.83)); +float t12975 = fract(t12974); +float t12976 = (t12975-float(0.5)); +float t12977 = (3.1415927/t10013); +float t12978 = (t12976*t12977); +float t12979 = (t12978*float(0.75)); +float t12980 = (t12973+t12979); +float t12981 = (t12980+3.1415927); +float t12982 = mod(t12981,t1433); +float t12983 = (t12982-3.1415927); +float t12984 = (t12983+3.1415927); +float t12985 = (3.1415927*2); +float t12986 = mod(t12984,t12985); +float t12987 = (t12986-3.1415927); +float t12988 = (t12971-t12987); +float t12989 = abs(t12988); +float t12990 = (t12989/2); +float t12991 = sin(t12990); +float t12992 = (t12991*t12991); +float t12993 = (t12955*t12992); +float t12994 = (t12952+t12993); +float t12995 = sqrt(t12994); +float t12996 = asin(t12995); +float t12997 = (2*t12996); +float t12998 = (3.1415927/2); +float t12999 = (t8-t12998); +float t13000 = (3.1415927/2); +float t13001 = (t12945-t13000); +float t13002 = (t12999-t13001); +float t13003 = abs(t13002); +float t13004 = (t13003/2); +float t13005 = sin(t13004); +float t13006 = (t13005*t13005); +float t13007 = cos(t13001); +float t13008 = cos(t12999); +float t13009 = (t13007*t13008); +float t13010 = (t118+3.1415927); +float t13011 = (3.1415927*2); +float t13012 = mod(t13010,t13011); +float t13013 = (t13012-3.1415927); +float t13014 = (t12983+3.1415927); +float t13015 = (3.1415927*2); +float t13016 = mod(t13014,t13015); +float t13017 = (t13016-3.1415927); +float t13018 = (t13013-t13017); +float t13019 = abs(t13018); +float t13020 = (t13019/2); +float t13021 = sin(t13020); +float t13022 = (t13021*t13021); +float t13023 = (t13009*t13022); +float t13024 = (t13006+t13023); +float t13025 = sqrt(t13024); +float t13026 = asin(t13025); +float t13027 = (2*t13026); +float t13028 = (t12997-t13027); +float t13029 = (3.1415927/2); +float t13030 = (t8-t13029); +float t13031 = (3.1415927/2); +float t13032 = (t12919-t13031); +float t13033 = (t13030-t13032); +float t13034 = abs(t13033); +float t13035 = (t13034/2); +float t13036 = sin(t13035); +float t13037 = (t13036*t13036); +float t13038 = cos(t13032); +float t13039 = cos(t13030); +float t13040 = (t13038*t13039); +float t13041 = (t118+3.1415927); +float t13042 = (3.1415927*2); +float t13043 = mod(t13041,t13042); +float t13044 = (t13043-3.1415927); +float t13045 = (t12967+3.1415927); +float t13046 = (3.1415927*2); +float t13047 = mod(t13045,t13046); +float t13048 = (t13047-3.1415927); +float t13049 = (t13044-t13048); +float t13050 = abs(t13049); +float t13051 = (t13050/2); +float t13052 = sin(t13051); +float t13053 = (t13052*t13052); +float t13054 = (t13040*t13053); +float t13055 = (t13037+t13054); +float t13056 = sqrt(t13055); +float t13057 = asin(t13056); +float t13058 = (2*t13057); +float t13059 = (t13028-t13058); +float t13060 = abs(t13059); +bool t13061 = (float(1.0e-4)>t13060); +float t13062; +if(t13061){ +float t13063 = cos(t12945); +float t13064 = (1*t13063); +float t13065 = sin(t12919); +float t13066 = (1*t13065); +float t13067 = cos(t12967); +float t13068 = (t13066*t13067); +float t13069 = (t13064*t13068); +float t13070 = sin(t12945); +float t13071 = (1*t13070); +float t13072 = cos(t12983); +float t13073 = (t13071*t13072); +float t13074 = cos(t12919); +float t13075 = (1*t13074); +float t13076 = (t13073*t13075); +float t13077 = (t13069-t13076); +float t13078 = sin(t8); +float t13079 = (1*t13078); +float t13080 = sin(t118); +float t13081 = (t13079*t13080); +float t13082 = (t13077*t13081); +float t13083 = sin(t12919); +float t13084 = (1*t13083); +float t13085 = sin(t12967); +float t13086 = (t13084*t13085); +float t13087 = (t13073*t13086); +float t13088 = sin(t12945); +float t13089 = (1*t13088); +float t13090 = sin(t12983); +float t13091 = (t13089*t13090); +float t13092 = (t13091*t13068); +float t13093 = (t13087-t13092); +float t13094 = cos(t8); +float t13095 = (1*t13094); +float t13096 = (t13093*t13095); +float t13097 = (t13082+t13096); +float t13098 = (t13091*t13075); +float t13099 = (t13064*t13086); +float t13100 = (t13098-t13099); +float t13101 = sin(t8); +float t13102 = (1*t13101); +float t13103 = cos(t118); +float t13104 = (t13102*t13103); +float t13105 = (t13100*t13104); +float t13106 = (t13097+t13105); +float t13107 = abs(t13106); +t13062 = t13107; +} else { +float t13108 = (3.1415927/2); +float t13109 = (t8-t13108); +float t13110 = (3.1415927/2); +float t13111 = (t12919-t13110); +float t13112 = (t13109-t13111); +float t13113 = abs(t13112); +float t13114 = (t13113/2); +float t13115 = sin(t13114); +float t13116 = (t13115*t13115); +float t13117 = cos(t13111); +float t13118 = cos(t13109); +float t13119 = (t13117*t13118); +float t13120 = (t118+3.1415927); +float t13121 = (3.1415927*2); +float t13122 = mod(t13120,t13121); +float t13123 = (t13122-3.1415927); +float t13124 = (t12967+3.1415927); +float t13125 = (3.1415927*2); +float t13126 = mod(t13124,t13125); +float t13127 = (t13126-3.1415927); +float t13128 = (t13123-t13127); +float t13129 = abs(t13128); +float t13130 = (t13129/2); +float t13131 = sin(t13130); +float t13132 = (t13131*t13131); +float t13133 = (t13119*t13132); +float t13134 = (t13116+t13133); +float t13135 = sqrt(t13134); +float t13136 = asin(t13135); +float t13137 = (2*t13136); +float t13138 = abs(t13137); +float t13139 = (3.1415927/2); +float t13140 = (t8-t13139); +float t13141 = (3.1415927/2); +float t13142 = (t12945-t13141); +float t13143 = (t13140-t13142); +float t13144 = abs(t13143); +float t13145 = (t13144/2); +float t13146 = sin(t13145); +float t13147 = (t13146*t13146); +float t13148 = cos(t13142); +float t13149 = cos(t13140); +float t13150 = (t13148*t13149); +float t13151 = (t118+3.1415927); +float t13152 = (3.1415927*2); +float t13153 = mod(t13151,t13152); +float t13154 = (t13153-3.1415927); +float t13155 = (t12983+3.1415927); +float t13156 = (3.1415927*2); +float t13157 = mod(t13155,t13156); +float t13158 = (t13157-3.1415927); +float t13159 = (t13154-t13158); +float t13160 = abs(t13159); +float t13161 = (t13160/2); +float t13162 = sin(t13161); +float t13163 = (t13162*t13162); +float t13164 = (t13150*t13163); +float t13165 = (t13147+t13164); +float t13166 = sqrt(t13165); +float t13167 = asin(t13166); +float t13168 = (2*t13167); +float t13169 = abs(t13168); +bool t13170 = (t13138>=t13169); +float t13171; +if(t13170){ +t13171 = t13138; +} else { +t13171 = t13169; +} +t13062 = t13171; +} +float t13172 = abs(t13062); +float t13173 = step(float(2.0e-4),t13172); +float t13174 = (1-t13173); +float t13175 = (t10000*t10452); +float t13176 = (t13175*float(842.378)); +float t13177 = fract(t13176); +float t13178 = (t13177+float(45.32)); +float t13179 = (t13178+u6.u0); +float t13180 = (t13177*t13179); +float t13181 = (t10234*t10000); +float t13182 = (t13181*float(1734.048)); +float t13183 = fract(t13182); +float t13184 = (t13183+float(45.32)); +float t13185 = (t13184+u6.u0); +float t13186 = (t13183*t13185); +float t13187 = (t13180+t13186); +float t13188 = (t13177+t13187); +float t13189 = (t13183+t13187); +float t13190 = (t13188*t13189); +float t13191 = fract(t13190); +float t13192 = step(float(0.2),t13191); +float t13193 = (t13174*t13192); +float t13194 = (3.1415927/2); +float t13195 = (t12919-t13194); +float t13196 = (3.1415927/2); +float t13197 = (t12945-t13196); +float t13198 = (t13195-t13197); +float t13199 = abs(t13198); +float t13200 = (t13199/2); +float t13201 = sin(t13200); +float t13202 = (t13201*t13201); +float t13203 = cos(t13197); +float t13204 = cos(t13195); +float t13205 = (t13203*t13204); +float t13206 = (t12967+3.1415927); +float t13207 = (3.1415927*2); +float t13208 = mod(t13206,t13207); +float t13209 = (t13208-3.1415927); +float t13210 = (t12983+3.1415927); +float t13211 = (3.1415927*2); +float t13212 = mod(t13210,t13211); +float t13213 = (t13212-3.1415927); +float t13214 = (t13209-t13213); +float t13215 = abs(t13214); +float t13216 = (t13215/2); +float t13217 = sin(t13216); +float t13218 = (t13217*t13217); +float t13219 = (t13205*t13218); +float t13220 = (t13202+t13219); +float t13221 = sqrt(t13220); +float t13222 = asin(t13221); +float t13223 = (2*t13222); +float t13224 = (t13223/t9998); +float t13225 = (1-t13224); +float t13226 = (t10000/245); +float t13227 = (t13226*float(842.378)); +float t13228 = fract(t13227); +float t13229 = (t13228+float(45.32)); +float t13230 = (t13229+u6.u0); +float t13231 = (t13228*t13230); +float t13232 = (t10234/t10013); +float t13233 = (t13232*float(1734.048)); +float t13234 = fract(t13233); +float t13235 = (t13234+float(45.32)); +float t13236 = (t13235+u6.u0); +float t13237 = (t13234*t13236); +float t13238 = (t13231+t13237); +float t13239 = (t13228+t13238); +float t13240 = (t13234+t13238); +float t13241 = (t13239*t13240); +float t13242 = fract(t13241); +float t13243 = (t13242*float(8.0e-3)); +float t13244 = (float(1.0e-3)+t13243); +float t13245 = (t13242*173); +float t13246 = fract(t13245); +float t13247 = step(float(0.66),t13246); +float t13248 = (t13247*float(3.0e-3)); +float t13249 = (t13244-t13248); +float t13250 = (t13249*float(0.4)); +float t13251 = (t10000/245); +float t13252 = (t13251*float(842.378)); +float t13253 = fract(t13252); +float t13254 = (t13253+float(45.32)); +float t13255 = (t13254+u6.u0); +float t13256 = (t13253*t13255); +float t13257 = (t10452/t10013); +float t13258 = (t13257*float(1734.048)); +float t13259 = fract(t13258); +float t13260 = (t13259+float(45.32)); +float t13261 = (t13260+u6.u0); +float t13262 = (t13259*t13261); +float t13263 = (t13256+t13262); +float t13264 = (t13253+t13263); +float t13265 = (t13259+t13263); +float t13266 = (t13264*t13265); +float t13267 = fract(t13266); +float t13268 = (t13267*float(8.0e-3)); +float t13269 = (float(1.0e-3)+t13268); +float t13270 = (t13267*173); +float t13271 = fract(t13270); +float t13272 = step(float(0.66),t13271); +float t13273 = (t13272*float(3.0e-3)); +float t13274 = (t13269-t13273); +float t13275 = (t13274*float(0.4)); +float t13276 = (t13250-t13275); +float t13277 = abs(t13276); +float t13278 = (t13277-float(1.0e-3)); +float t13279 = (t13278/float(8.0e-3)); +float t13280 = (1-t13279); +float t13281 = (t13280*t13280); +float t13282 = (t13225*t13281); +float t13283 = (t13193*t13282); +float t13284 = (u4.u0*t13191); +float t13285 = (t13284*3); +float t13286 = sin(t13285); +float t13287 = (t13286+1); +float t13288 = (t13287/2); +float t13289 = (t13288*float(0.66)); +float t13290 = (t13289+float(0.33)); +float t13291 = (t13283*t13290); +float t13292 = (float(0.2)*t13291); +bool t13293 = (0>=t13292); +float t13294; +if(t13293){ +t13294 = 0; +} else { +t13294 = t13292; +} +float t13295 = (t13294*0); +float t13296 = (t12895+t13295); +float t13297 = (t10000*t9998); +float t13298 = (t10000/245); +float t13299 = (t13298*float(842.378)); +float t13300 = fract(t13299); +float t13301 = (t13300+float(45.32)); +float t13302 = (t13301+u6.u0); +float t13303 = (t13300*t13302); +float t13304 = (t10016+2); +float t13305 = (t13304/t10676); +float t13306 = (t13305*float(1734.048)); +float t13307 = fract(t13306); +float t13308 = (t13307+float(45.32)); +float t13309 = (t13308+u6.u0); +float t13310 = (t13307*t13309); +float t13311 = (t13303+t13310); +float t13312 = (t13300+t13311); +float t13313 = (t13307+t13311); +float t13314 = (t13312*t13313); +float t13315 = fract(t13314); +float t13316 = (t13315*float(2852.02)); +float t13317 = fract(t13316); +float t13318 = (t13317-float(0.5)); +float t13319 = (t13318*t9998); +float t13320 = (t13319*float(0.75)); +float t13321 = (t13297+t13320); +float t13322 = (3.1415927/2); +float t13323 = (t13321-t13322); +float t13324 = (t10663*t9998); +float t13325 = (t10663/245); +float t13326 = (t13325*float(842.378)); +float t13327 = fract(t13326); +float t13328 = (t13327+float(45.32)); +float t13329 = (t13328+u6.u0); +float t13330 = (t13327*t13329); +float t13331 = (t11699/t10676); +float t13332 = (t13331*float(1734.048)); +float t13333 = fract(t13332); +float t13334 = (t13333+float(45.32)); +float t13335 = (t13334+u6.u0); +float t13336 = (t13333*t13335); +float t13337 = (t13330+t13336); +float t13338 = (t13327+t13337); +float t13339 = (t13333+t13337); +float t13340 = (t13338*t13339); +float t13341 = fract(t13340); +float t13342 = (t13341*float(2852.02)); +float t13343 = fract(t13342); +float t13344 = (t13343-float(0.5)); +float t13345 = (t13344*t9998); +float t13346 = (t13345*float(0.75)); +float t13347 = (t13324+t13346); +float t13348 = (3.1415927/2); +float t13349 = (t13347-t13348); +float t13350 = (t13323-t13349); +float t13351 = abs(t13350); +float t13352 = (t13351/2); +float t13353 = sin(t13352); +float t13354 = (t13353*t13353); +float t13355 = cos(t13349); +float t13356 = cos(t13323); +float t13357 = (t13355*t13356); +float t13358 = (3.1415927/t10676); +float t13359 = (t13304*t13358); +float t13360 = (t13315*float(97372.83)); +float t13361 = fract(t13360); +float t13362 = (t13361-float(0.5)); +float t13363 = (3.1415927/t10676); +float t13364 = (t13362*t13363); +float t13365 = (t13364*float(0.75)); +float t13366 = (t13359+t13365); +float t13367 = (t13366+3.1415927); +float t13368 = mod(t13367,t1433); +float t13369 = (t13368-3.1415927); +float t13370 = (t13369+3.1415927); +float t13371 = (3.1415927*2); +float t13372 = mod(t13370,t13371); +float t13373 = (t13372-3.1415927); +float t13374 = (3.1415927/t10676); +float t13375 = (t11699*t13374); +float t13376 = (t13341*float(97372.83)); +float t13377 = fract(t13376); +float t13378 = (t13377-float(0.5)); +float t13379 = (3.1415927/t10676); +float t13380 = (t13378*t13379); +float t13381 = (t13380*float(0.75)); +float t13382 = (t13375+t13381); +float t13383 = (t13382+3.1415927); +float t13384 = mod(t13383,t1433); +float t13385 = (t13384-3.1415927); +float t13386 = (t13385+3.1415927); +float t13387 = (3.1415927*2); +float t13388 = mod(t13386,t13387); +float t13389 = (t13388-3.1415927); +float t13390 = (t13373-t13389); +float t13391 = abs(t13390); +float t13392 = (t13391/2); +float t13393 = sin(t13392); +float t13394 = (t13393*t13393); +float t13395 = (t13357*t13394); +float t13396 = (t13354+t13395); +float t13397 = sqrt(t13396); +float t13398 = asin(t13397); +float t13399 = (2*t13398); +float t13400 = (3.1415927/2); +float t13401 = (t8-t13400); +float t13402 = (3.1415927/2); +float t13403 = (t13347-t13402); +float t13404 = (t13401-t13403); +float t13405 = abs(t13404); +float t13406 = (t13405/2); +float t13407 = sin(t13406); +float t13408 = (t13407*t13407); +float t13409 = cos(t13403); +float t13410 = cos(t13401); +float t13411 = (t13409*t13410); +float t13412 = (t118+3.1415927); +float t13413 = (3.1415927*2); +float t13414 = mod(t13412,t13413); +float t13415 = (t13414-3.1415927); +float t13416 = (t13385+3.1415927); +float t13417 = (3.1415927*2); +float t13418 = mod(t13416,t13417); +float t13419 = (t13418-3.1415927); +float t13420 = (t13415-t13419); +float t13421 = abs(t13420); +float t13422 = (t13421/2); +float t13423 = sin(t13422); +float t13424 = (t13423*t13423); +float t13425 = (t13411*t13424); +float t13426 = (t13408+t13425); +float t13427 = sqrt(t13426); +float t13428 = asin(t13427); +float t13429 = (2*t13428); +float t13430 = (t13399-t13429); +float t13431 = (3.1415927/2); +float t13432 = (t8-t13431); +float t13433 = (3.1415927/2); +float t13434 = (t13321-t13433); +float t13435 = (t13432-t13434); +float t13436 = abs(t13435); +float t13437 = (t13436/2); +float t13438 = sin(t13437); +float t13439 = (t13438*t13438); +float t13440 = cos(t13434); +float t13441 = cos(t13432); +float t13442 = (t13440*t13441); +float t13443 = (t118+3.1415927); +float t13444 = (3.1415927*2); +float t13445 = mod(t13443,t13444); +float t13446 = (t13445-3.1415927); +float t13447 = (t13369+3.1415927); +float t13448 = (3.1415927*2); +float t13449 = mod(t13447,t13448); +float t13450 = (t13449-3.1415927); +float t13451 = (t13446-t13450); +float t13452 = abs(t13451); +float t13453 = (t13452/2); +float t13454 = sin(t13453); +float t13455 = (t13454*t13454); +float t13456 = (t13442*t13455); +float t13457 = (t13439+t13456); +float t13458 = sqrt(t13457); +float t13459 = asin(t13458); +float t13460 = (2*t13459); +float t13461 = (t13430-t13460); +float t13462 = abs(t13461); +bool t13463 = (float(1.0e-4)>t13462); +float t13464; +if(t13463){ +float t13465 = cos(t13347); +float t13466 = (1*t13465); +float t13467 = sin(t13321); +float t13468 = (1*t13467); +float t13469 = cos(t13369); +float t13470 = (t13468*t13469); +float t13471 = (t13466*t13470); +float t13472 = sin(t13347); +float t13473 = (1*t13472); +float t13474 = cos(t13385); +float t13475 = (t13473*t13474); +float t13476 = cos(t13321); +float t13477 = (1*t13476); +float t13478 = (t13475*t13477); +float t13479 = (t13471-t13478); +float t13480 = sin(t8); +float t13481 = (1*t13480); +float t13482 = sin(t118); +float t13483 = (t13481*t13482); +float t13484 = (t13479*t13483); +float t13485 = sin(t13321); +float t13486 = (1*t13485); +float t13487 = sin(t13369); +float t13488 = (t13486*t13487); +float t13489 = (t13475*t13488); +float t13490 = sin(t13347); +float t13491 = (1*t13490); +float t13492 = sin(t13385); +float t13493 = (t13491*t13492); +float t13494 = (t13493*t13470); +float t13495 = (t13489-t13494); +float t13496 = cos(t8); +float t13497 = (1*t13496); +float t13498 = (t13495*t13497); +float t13499 = (t13484+t13498); +float t13500 = (t13493*t13477); +float t13501 = (t13466*t13488); +float t13502 = (t13500-t13501); +float t13503 = sin(t8); +float t13504 = (1*t13503); +float t13505 = cos(t118); +float t13506 = (t13504*t13505); +float t13507 = (t13502*t13506); +float t13508 = (t13499+t13507); +float t13509 = abs(t13508); +t13464 = t13509; +} else { +float t13510 = (3.1415927/2); +float t13511 = (t8-t13510); +float t13512 = (3.1415927/2); +float t13513 = (t13321-t13512); +float t13514 = (t13511-t13513); +float t13515 = abs(t13514); +float t13516 = (t13515/2); +float t13517 = sin(t13516); +float t13518 = (t13517*t13517); +float t13519 = cos(t13513); +float t13520 = cos(t13511); +float t13521 = (t13519*t13520); +float t13522 = (t118+3.1415927); +float t13523 = (3.1415927*2); +float t13524 = mod(t13522,t13523); +float t13525 = (t13524-3.1415927); +float t13526 = (t13369+3.1415927); +float t13527 = (3.1415927*2); +float t13528 = mod(t13526,t13527); +float t13529 = (t13528-3.1415927); +float t13530 = (t13525-t13529); +float t13531 = abs(t13530); +float t13532 = (t13531/2); +float t13533 = sin(t13532); +float t13534 = (t13533*t13533); +float t13535 = (t13521*t13534); +float t13536 = (t13518+t13535); +float t13537 = sqrt(t13536); +float t13538 = asin(t13537); +float t13539 = (2*t13538); +float t13540 = abs(t13539); +float t13541 = (3.1415927/2); +float t13542 = (t8-t13541); +float t13543 = (3.1415927/2); +float t13544 = (t13347-t13543); +float t13545 = (t13542-t13544); +float t13546 = abs(t13545); +float t13547 = (t13546/2); +float t13548 = sin(t13547); +float t13549 = (t13548*t13548); +float t13550 = cos(t13544); +float t13551 = cos(t13542); +float t13552 = (t13550*t13551); +float t13553 = (t118+3.1415927); +float t13554 = (3.1415927*2); +float t13555 = mod(t13553,t13554); +float t13556 = (t13555-3.1415927); +float t13557 = (t13385+3.1415927); +float t13558 = (3.1415927*2); +float t13559 = mod(t13557,t13558); +float t13560 = (t13559-3.1415927); +float t13561 = (t13556-t13560); +float t13562 = abs(t13561); +float t13563 = (t13562/2); +float t13564 = sin(t13563); +float t13565 = (t13564*t13564); +float t13566 = (t13552*t13565); +float t13567 = (t13549+t13566); +float t13568 = sqrt(t13567); +float t13569 = asin(t13568); +float t13570 = (2*t13569); +float t13571 = abs(t13570); +bool t13572 = (t13540>=t13571); +float t13573; +if(t13572){ +t13573 = t13540; +} else { +t13573 = t13571; +} +t13464 = t13573; +} +float t13574 = abs(t13464); +float t13575 = step(float(2.0e-4),t13574); +float t13576 = (1-t13575); +float t13577 = (t10663*t13304); +float t13578 = (t13577*float(842.378)); +float t13579 = fract(t13578); +float t13580 = (t13579+float(45.32)); +float t13581 = (t13580+u6.u0); +float t13582 = (t13579*t13581); +float t13583 = (t11699*t10000); +float t13584 = (t13583*float(1734.048)); +float t13585 = fract(t13584); +float t13586 = (t13585+float(45.32)); +float t13587 = (t13586+u6.u0); +float t13588 = (t13585*t13587); +float t13589 = (t13582+t13588); +float t13590 = (t13579+t13589); +float t13591 = (t13585+t13589); +float t13592 = (t13590*t13591); +float t13593 = fract(t13592); +float t13594 = step(float(0.2),t13593); +float t13595 = (t13576*t13594); +float t13596 = (3.1415927/2); +float t13597 = (t13321-t13596); +float t13598 = (3.1415927/2); +float t13599 = (t13347-t13598); +float t13600 = (t13597-t13599); +float t13601 = abs(t13600); +float t13602 = (t13601/2); +float t13603 = sin(t13602); +float t13604 = (t13603*t13603); +float t13605 = cos(t13599); +float t13606 = cos(t13597); +float t13607 = (t13605*t13606); +float t13608 = (t13369+3.1415927); +float t13609 = (3.1415927*2); +float t13610 = mod(t13608,t13609); +float t13611 = (t13610-3.1415927); +float t13612 = (t13385+3.1415927); +float t13613 = (3.1415927*2); +float t13614 = mod(t13612,t13613); +float t13615 = (t13614-3.1415927); +float t13616 = (t13611-t13615); +float t13617 = abs(t13616); +float t13618 = (t13617/2); +float t13619 = sin(t13618); +float t13620 = (t13619*t13619); +float t13621 = (t13607*t13620); +float t13622 = (t13604+t13621); +float t13623 = sqrt(t13622); +float t13624 = asin(t13623); +float t13625 = (2*t13624); +float t13626 = (t13625/t9998); +float t13627 = (1-t13626); +float t13628 = (t10663/245); +float t13629 = (t13628*float(842.378)); +float t13630 = fract(t13629); +float t13631 = (t13630+float(45.32)); +float t13632 = (t13631+u6.u0); +float t13633 = (t13630*t13632); +float t13634 = (t11699/t10676); +float t13635 = (t13634*float(1734.048)); +float t13636 = fract(t13635); +float t13637 = (t13636+float(45.32)); +float t13638 = (t13637+u6.u0); +float t13639 = (t13636*t13638); +float t13640 = (t13633+t13639); +float t13641 = (t13630+t13640); +float t13642 = (t13636+t13640); +float t13643 = (t13641*t13642); +float t13644 = fract(t13643); +float t13645 = (t13644*float(8.0e-3)); +float t13646 = (float(1.0e-3)+t13645); +float t13647 = (t13644*173); +float t13648 = fract(t13647); +float t13649 = step(float(0.66),t13648); +float t13650 = (t13649*float(3.0e-3)); +float t13651 = (t13646-t13650); +float t13652 = (t13651*float(0.4)); +float t13653 = (t10000/245); +float t13654 = (t13653*float(842.378)); +float t13655 = fract(t13654); +float t13656 = (t13655+float(45.32)); +float t13657 = (t13656+u6.u0); +float t13658 = (t13655*t13657); +float t13659 = (t13304/t10676); +float t13660 = (t13659*float(1734.048)); +float t13661 = fract(t13660); +float t13662 = (t13661+float(45.32)); +float t13663 = (t13662+u6.u0); +float t13664 = (t13661*t13663); +float t13665 = (t13658+t13664); +float t13666 = (t13655+t13665); +float t13667 = (t13661+t13665); +float t13668 = (t13666*t13667); +float t13669 = fract(t13668); +float t13670 = (t13669*float(8.0e-3)); +float t13671 = (float(1.0e-3)+t13670); +float t13672 = (t13669*173); +float t13673 = fract(t13672); +float t13674 = step(float(0.66),t13673); +float t13675 = (t13674*float(3.0e-3)); +float t13676 = (t13671-t13675); +float t13677 = (t13676*float(0.4)); +float t13678 = (t13652-t13677); +float t13679 = abs(t13678); +float t13680 = (t13679-float(1.0e-3)); +float t13681 = (t13680/float(8.0e-3)); +float t13682 = (1-t13681); +float t13683 = (t13682*t13682); +float t13684 = (t13627*t13683); +float t13685 = (t13595*t13684); +float t13686 = (u4.u0*t13593); +float t13687 = (t13686*3); +float t13688 = sin(t13687); +float t13689 = (t13688+1); +float t13690 = (t13689/2); +float t13691 = (t13690*float(0.66)); +float t13692 = (t13691+float(0.33)); +float t13693 = (t13685*t13692); +float t13694 = (float(0.2)*t13693); +bool t13695 = (0>=t13694); +float t13696; +if(t13695){ +t13696 = 0; +} else { +t13696 = t13694; +} +float t13697 = (t13696*0); +float t13698 = (t13296+t13697); +float t13699 = (t10000*t9998); +float t13700 = (t10000/245); +float t13701 = (t13700*float(842.378)); +float t13702 = fract(t13701); +float t13703 = (t13702+float(45.32)); +float t13704 = (t13703+u6.u0); +float t13705 = (t13702*t13704); +float t13706 = (t13304/t10676); +float t13707 = (t13706*float(1734.048)); +float t13708 = fract(t13707); +float t13709 = (t13708+float(45.32)); +float t13710 = (t13709+u6.u0); +float t13711 = (t13708*t13710); +float t13712 = (t13705+t13711); +float t13713 = (t13702+t13712); +float t13714 = (t13708+t13712); +float t13715 = (t13713*t13714); +float t13716 = fract(t13715); +float t13717 = (t13716*float(2852.02)); +float t13718 = fract(t13717); +float t13719 = (t13718-float(0.5)); +float t13720 = (t13719*t9998); +float t13721 = (t13720*float(0.75)); +float t13722 = (t13699+t13721); +float t13723 = (3.1415927/2); +float t13724 = (t13722-t13723); +float t13725 = (t10000*t9998); +float t13726 = (t10000/245); +float t13727 = (t13726*float(842.378)); +float t13728 = fract(t13727); +float t13729 = (t13728+float(45.32)); +float t13730 = (t13729+u6.u0); +float t13731 = (t13728*t13730); +float t13732 = (t10452/t10013); +float t13733 = (t13732*float(1734.048)); +float t13734 = fract(t13733); +float t13735 = (t13734+float(45.32)); +float t13736 = (t13735+u6.u0); +float t13737 = (t13734*t13736); +float t13738 = (t13731+t13737); +float t13739 = (t13728+t13738); +float t13740 = (t13734+t13738); +float t13741 = (t13739*t13740); +float t13742 = fract(t13741); +float t13743 = (t13742*float(2852.02)); +float t13744 = fract(t13743); +float t13745 = (t13744-float(0.5)); +float t13746 = (t13745*t9998); +float t13747 = (t13746*float(0.75)); +float t13748 = (t13725+t13747); +float t13749 = (3.1415927/2); +float t13750 = (t13748-t13749); +float t13751 = (t13724-t13750); +float t13752 = abs(t13751); +float t13753 = (t13752/2); +float t13754 = sin(t13753); +float t13755 = (t13754*t13754); +float t13756 = cos(t13750); +float t13757 = cos(t13724); +float t13758 = (t13756*t13757); +float t13759 = (3.1415927/t10676); +float t13760 = (t13304*t13759); +float t13761 = (t13716*float(97372.83)); +float t13762 = fract(t13761); +float t13763 = (t13762-float(0.5)); +float t13764 = (3.1415927/t10676); +float t13765 = (t13763*t13764); +float t13766 = (t13765*float(0.75)); +float t13767 = (t13760+t13766); +float t13768 = (t13767+3.1415927); +float t13769 = mod(t13768,t1433); +float t13770 = (t13769-3.1415927); +float t13771 = (t13770+3.1415927); +float t13772 = (3.1415927*2); +float t13773 = mod(t13771,t13772); +float t13774 = (t13773-3.1415927); +float t13775 = (3.1415927/t10013); +float t13776 = (t10452*t13775); +float t13777 = (t13742*float(97372.83)); +float t13778 = fract(t13777); +float t13779 = (t13778-float(0.5)); +float t13780 = (3.1415927/t10013); +float t13781 = (t13779*t13780); +float t13782 = (t13781*float(0.75)); +float t13783 = (t13776+t13782); +float t13784 = (t13783+3.1415927); +float t13785 = mod(t13784,t1433); +float t13786 = (t13785-3.1415927); +float t13787 = (t13786+3.1415927); +float t13788 = (3.1415927*2); +float t13789 = mod(t13787,t13788); +float t13790 = (t13789-3.1415927); +float t13791 = (t13774-t13790); +float t13792 = abs(t13791); +float t13793 = (t13792/2); +float t13794 = sin(t13793); +float t13795 = (t13794*t13794); +float t13796 = (t13758*t13795); +float t13797 = (t13755+t13796); +float t13798 = sqrt(t13797); +float t13799 = asin(t13798); +float t13800 = (2*t13799); +float t13801 = (3.1415927/2); +float t13802 = (t8-t13801); +float t13803 = (3.1415927/2); +float t13804 = (t13748-t13803); +float t13805 = (t13802-t13804); +float t13806 = abs(t13805); +float t13807 = (t13806/2); +float t13808 = sin(t13807); +float t13809 = (t13808*t13808); +float t13810 = cos(t13804); +float t13811 = cos(t13802); +float t13812 = (t13810*t13811); +float t13813 = (t118+3.1415927); +float t13814 = (3.1415927*2); +float t13815 = mod(t13813,t13814); +float t13816 = (t13815-3.1415927); +float t13817 = (t13786+3.1415927); +float t13818 = (3.1415927*2); +float t13819 = mod(t13817,t13818); +float t13820 = (t13819-3.1415927); +float t13821 = (t13816-t13820); +float t13822 = abs(t13821); +float t13823 = (t13822/2); +float t13824 = sin(t13823); +float t13825 = (t13824*t13824); +float t13826 = (t13812*t13825); +float t13827 = (t13809+t13826); +float t13828 = sqrt(t13827); +float t13829 = asin(t13828); +float t13830 = (2*t13829); +float t13831 = (t13800-t13830); +float t13832 = (3.1415927/2); +float t13833 = (t8-t13832); +float t13834 = (3.1415927/2); +float t13835 = (t13722-t13834); +float t13836 = (t13833-t13835); +float t13837 = abs(t13836); +float t13838 = (t13837/2); +float t13839 = sin(t13838); +float t13840 = (t13839*t13839); +float t13841 = cos(t13835); +float t13842 = cos(t13833); +float t13843 = (t13841*t13842); +float t13844 = (t118+3.1415927); +float t13845 = (3.1415927*2); +float t13846 = mod(t13844,t13845); +float t13847 = (t13846-3.1415927); +float t13848 = (t13770+3.1415927); +float t13849 = (3.1415927*2); +float t13850 = mod(t13848,t13849); +float t13851 = (t13850-3.1415927); +float t13852 = (t13847-t13851); +float t13853 = abs(t13852); +float t13854 = (t13853/2); +float t13855 = sin(t13854); +float t13856 = (t13855*t13855); +float t13857 = (t13843*t13856); +float t13858 = (t13840+t13857); +float t13859 = sqrt(t13858); +float t13860 = asin(t13859); +float t13861 = (2*t13860); +float t13862 = (t13831-t13861); +float t13863 = abs(t13862); +bool t13864 = (float(1.0e-4)>t13863); +float t13865; +if(t13864){ +float t13866 = cos(t13748); +float t13867 = (1*t13866); +float t13868 = sin(t13722); +float t13869 = (1*t13868); +float t13870 = cos(t13770); +float t13871 = (t13869*t13870); +float t13872 = (t13867*t13871); +float t13873 = sin(t13748); +float t13874 = (1*t13873); +float t13875 = cos(t13786); +float t13876 = (t13874*t13875); +float t13877 = cos(t13722); +float t13878 = (1*t13877); +float t13879 = (t13876*t13878); +float t13880 = (t13872-t13879); +float t13881 = sin(t8); +float t13882 = (1*t13881); +float t13883 = sin(t118); +float t13884 = (t13882*t13883); +float t13885 = (t13880*t13884); +float t13886 = sin(t13722); +float t13887 = (1*t13886); +float t13888 = sin(t13770); +float t13889 = (t13887*t13888); +float t13890 = (t13876*t13889); +float t13891 = sin(t13748); +float t13892 = (1*t13891); +float t13893 = sin(t13786); +float t13894 = (t13892*t13893); +float t13895 = (t13894*t13871); +float t13896 = (t13890-t13895); +float t13897 = cos(t8); +float t13898 = (1*t13897); +float t13899 = (t13896*t13898); +float t13900 = (t13885+t13899); +float t13901 = (t13894*t13878); +float t13902 = (t13867*t13889); +float t13903 = (t13901-t13902); +float t13904 = sin(t8); +float t13905 = (1*t13904); +float t13906 = cos(t118); +float t13907 = (t13905*t13906); +float t13908 = (t13903*t13907); +float t13909 = (t13900+t13908); +float t13910 = abs(t13909); +t13865 = t13910; +} else { +float t13911 = (3.1415927/2); +float t13912 = (t8-t13911); +float t13913 = (3.1415927/2); +float t13914 = (t13722-t13913); +float t13915 = (t13912-t13914); +float t13916 = abs(t13915); +float t13917 = (t13916/2); +float t13918 = sin(t13917); +float t13919 = (t13918*t13918); +float t13920 = cos(t13914); +float t13921 = cos(t13912); +float t13922 = (t13920*t13921); +float t13923 = (t118+3.1415927); +float t13924 = (3.1415927*2); +float t13925 = mod(t13923,t13924); +float t13926 = (t13925-3.1415927); +float t13927 = (t13770+3.1415927); +float t13928 = (3.1415927*2); +float t13929 = mod(t13927,t13928); +float t13930 = (t13929-3.1415927); +float t13931 = (t13926-t13930); +float t13932 = abs(t13931); +float t13933 = (t13932/2); +float t13934 = sin(t13933); +float t13935 = (t13934*t13934); +float t13936 = (t13922*t13935); +float t13937 = (t13919+t13936); +float t13938 = sqrt(t13937); +float t13939 = asin(t13938); +float t13940 = (2*t13939); +float t13941 = abs(t13940); +float t13942 = (3.1415927/2); +float t13943 = (t8-t13942); +float t13944 = (3.1415927/2); +float t13945 = (t13748-t13944); +float t13946 = (t13943-t13945); +float t13947 = abs(t13946); +float t13948 = (t13947/2); +float t13949 = sin(t13948); +float t13950 = (t13949*t13949); +float t13951 = cos(t13945); +float t13952 = cos(t13943); +float t13953 = (t13951*t13952); +float t13954 = (t118+3.1415927); +float t13955 = (3.1415927*2); +float t13956 = mod(t13954,t13955); +float t13957 = (t13956-3.1415927); +float t13958 = (t13786+3.1415927); +float t13959 = (3.1415927*2); +float t13960 = mod(t13958,t13959); +float t13961 = (t13960-3.1415927); +float t13962 = (t13957-t13961); +float t13963 = abs(t13962); +float t13964 = (t13963/2); +float t13965 = sin(t13964); +float t13966 = (t13965*t13965); +float t13967 = (t13953*t13966); +float t13968 = (t13950+t13967); +float t13969 = sqrt(t13968); +float t13970 = asin(t13969); +float t13971 = (2*t13970); +float t13972 = abs(t13971); +bool t13973 = (t13941>=t13972); +float t13974; +if(t13973){ +t13974 = t13941; +} else { +t13974 = t13972; +} +t13865 = t13974; +} +float t13975 = abs(t13865); +float t13976 = step(float(2.0e-4),t13975); +float t13977 = (1-t13976); +float t13978 = (t10000*t13304); +float t13979 = (t13978*float(842.378)); +float t13980 = fract(t13979); +float t13981 = (t13980+float(45.32)); +float t13982 = (t13981+u6.u0); +float t13983 = (t13980*t13982); +float t13984 = (t10452*t10000); +float t13985 = (t13984*float(1734.048)); +float t13986 = fract(t13985); +float t13987 = (t13986+float(45.32)); +float t13988 = (t13987+u6.u0); +float t13989 = (t13986*t13988); +float t13990 = (t13983+t13989); +float t13991 = (t13980+t13990); +float t13992 = (t13986+t13990); +float t13993 = (t13991*t13992); +float t13994 = fract(t13993); +float t13995 = step(float(0.2),t13994); +float t13996 = (t13977*t13995); +float t13997 = (3.1415927/2); +float t13998 = (t13722-t13997); +float t13999 = (3.1415927/2); +float t14000 = (t13748-t13999); +float t14001 = (t13998-t14000); +float t14002 = abs(t14001); +float t14003 = (t14002/2); +float t14004 = sin(t14003); +float t14005 = (t14004*t14004); +float t14006 = cos(t14000); +float t14007 = cos(t13998); +float t14008 = (t14006*t14007); +float t14009 = (t13770+3.1415927); +float t14010 = (3.1415927*2); +float t14011 = mod(t14009,t14010); +float t14012 = (t14011-3.1415927); +float t14013 = (t13786+3.1415927); +float t14014 = (3.1415927*2); +float t14015 = mod(t14013,t14014); +float t14016 = (t14015-3.1415927); +float t14017 = (t14012-t14016); +float t14018 = abs(t14017); +float t14019 = (t14018/2); +float t14020 = sin(t14019); +float t14021 = (t14020*t14020); +float t14022 = (t14008*t14021); +float t14023 = (t14005+t14022); +float t14024 = sqrt(t14023); +float t14025 = asin(t14024); +float t14026 = (2*t14025); +float t14027 = (t14026/t9998); +float t14028 = (1-t14027); +float t14029 = (t10000/245); +float t14030 = (t14029*float(842.378)); +float t14031 = fract(t14030); +float t14032 = (t14031+float(45.32)); +float t14033 = (t14032+u6.u0); +float t14034 = (t14031*t14033); +float t14035 = (t10452/t10013); +float t14036 = (t14035*float(1734.048)); +float t14037 = fract(t14036); +float t14038 = (t14037+float(45.32)); +float t14039 = (t14038+u6.u0); +float t14040 = (t14037*t14039); +float t14041 = (t14034+t14040); +float t14042 = (t14031+t14041); +float t14043 = (t14037+t14041); +float t14044 = (t14042*t14043); +float t14045 = fract(t14044); +float t14046 = (t14045*float(8.0e-3)); +float t14047 = (float(1.0e-3)+t14046); +float t14048 = (t14045*173); +float t14049 = fract(t14048); +float t14050 = step(float(0.66),t14049); +float t14051 = (t14050*float(3.0e-3)); +float t14052 = (t14047-t14051); +float t14053 = (t14052*float(0.4)); +float t14054 = (t10000/245); +float t14055 = (t14054*float(842.378)); +float t14056 = fract(t14055); +float t14057 = (t14056+float(45.32)); +float t14058 = (t14057+u6.u0); +float t14059 = (t14056*t14058); +float t14060 = (t13304/t10676); +float t14061 = (t14060*float(1734.048)); +float t14062 = fract(t14061); +float t14063 = (t14062+float(45.32)); +float t14064 = (t14063+u6.u0); +float t14065 = (t14062*t14064); +float t14066 = (t14059+t14065); +float t14067 = (t14056+t14066); +float t14068 = (t14062+t14066); +float t14069 = (t14067*t14068); +float t14070 = fract(t14069); +float t14071 = (t14070*float(8.0e-3)); +float t14072 = (float(1.0e-3)+t14071); +float t14073 = (t14070*173); +float t14074 = fract(t14073); +float t14075 = step(float(0.66),t14074); +float t14076 = (t14075*float(3.0e-3)); +float t14077 = (t14072-t14076); +float t14078 = (t14077*float(0.4)); +float t14079 = (t14053-t14078); +float t14080 = abs(t14079); +float t14081 = (t14080-float(1.0e-3)); +float t14082 = (t14081/float(8.0e-3)); +float t14083 = (1-t14082); +float t14084 = (t14083*t14083); +float t14085 = (t14028*t14084); +float t14086 = (t13996*t14085); +float t14087 = (u4.u0*t13994); +float t14088 = (t14087*3); +float t14089 = sin(t14088); +float t14090 = (t14089+1); +float t14091 = (t14090/2); +float t14092 = (t14091*float(0.66)); +float t14093 = (t14092+float(0.33)); +float t14094 = (t14086*t14093); +float t14095 = (float(0.2)*t14094); +bool t14096 = (0>=t14095); +float t14097; +if(t14096){ +t14097 = 0; +} else { +t14097 = t14095; +} +float t14098 = (t14097*0); +float t14099 = (t13698+t14098); +float t14100 = (t9993*t9993); +float t14101 = (t14099*t14100); +bool t14102 = (t9997>=t14101); +float t14103; +if(t14102){ +t14103 = t9997; +} else { +t14103 = t14101; +} +float t14104 = (t9551+t14103); +float t14105 = smoothstep(float(0.35),float(0.55),t468); +float t14106 = (u8.u0*t14105); +float t14107 = (1-t14106); +float t14108 = smoothstep(float(0.45),float(0.65),t468); +float t14109 = (t1334*t14108); +float t14110 = (u8.u0*t14109); +float t14111 = (1-t14110); +float t14112 = (3.1415927/2); +float t14113 = (t8-t14112); +float t14114 = (3.1415927/2); +float t14115 = (t107-t14114); +float t14116 = (t14113-t14115); +float t14117 = abs(t14116); +float t14118 = (t14117/2); +float t14119 = sin(t14118); +float t14120 = (t14119*t14119); +float t14121 = cos(t14115); +float t14122 = cos(t14113); +float t14123 = (t14121*t14122); +float t14124 = (t118+3.1415927); +float t14125 = (3.1415927*2); +float t14126 = mod(t14124,t14125); +float t14127 = (t14126-3.1415927); +float t14128 = (t123+3.1415927); +float t14129 = (3.1415927*2); +float t14130 = mod(t14128,t14129); +float t14131 = (t14130-3.1415927); +float t14132 = (t14127-t14131); +float t14133 = abs(t14132); +float t14134 = (t14133/2); +float t14135 = sin(t14134); +float t14136 = (t14135*t14135); +float t14137 = (t14123*t14136); +float t14138 = (t14120+t14137); +float t14139 = sqrt(t14138); +float t14140 = asin(t14139); +float t14141 = (2*t14140); +float t14142 = (3.1415927-t14141); +float t14143 = (t14142/3.1415927); +float t14144 = smoothstep(float(0.8),float(1.0),t14143); +float t14145 = (u8.u0*t14144); +float t14146 = (1-t14145); +bool t14147 = (t14111<=t14146); +float t14148; +if(t14147){ +t14148 = t14111; +} else { +t14148 = t14146; +} +bool t14149 = (t14107<=t14148); +float t14150; +if(t14149){ +t14150 = t14107; +} else { +t14150 = t14148; +} +float t14151 = (t14104*t14150); +float t14152 = (1-t1342); +float t14153 = (t14151*t14152); +float t14154 = (t1343+t14153); +float t14155 = (1-t1254); +float t14156 = (t14154*t14155); +float t14157 = (t1255+t14156); +float t14158 = (t3*t155); +float t14159 = (float(1.0)*t469); +float t14160 = (float(0.0)+t14159); +float t14161 = (t14160*t472); +float t14162 = (t14158+t14161); +float t14163 = (t14162*t524); +float t14164 = (float(0.2)*t678); +float t14165 = (t14164*t680); +float t14166 = (t14163+t14165); +float t14167 = (t14166*t685); +float t14168 = (float(0.7)*t839); +float t14169 = (t14168*t841); +float t14170 = (t14167+t14169); +float t14171 = (t14170*t846); +float t14172 = (float(0.1)*t1061); +float t14173 = (t14172*t1063); +float t14174 = (float(1.0e-2)*t1065); +float t14175 = (t14173+t14174); +float t14176 = (t14175*t1072); +float t14177 = (t14176*t1077); +float t14178 = (0*t1079); +float t14179 = (t14177+t14178); +float t14180 = (t1000*t14179); +float t14181 = (t14180*t1083); +float t14182 = (t14171+t14181); +float t14183 = (t14182*t1092); +float t14184 = (float(1.0)*t1246); +float t14185 = (t14184*t1248); +float t14186 = (t14183+t14185); +float t14187 = (t14186*t1254); +float t14188 = (float(0.7)*t1256); +float t14189 = (float(0.1)*t1258); +float t14190 = (t14188+t14189); +float t14191 = (float(0.2)*t1296); +float t14192 = (t14191*t1300); +float t14193 = (t14192*t1334); +float t14194 = (t14190+t14193); +float t14195 = (u8.u0*t14194); +float t14196 = (t14195*t1342); +float t14197 = (t1377/4000); +bool t14198 = (1<=t14197); +float t14199; +if(t14198){ +t14199 = 1; +} else { +t14199 = t14197; +} +float t14200 = (t1377-7000); +float t14201 = (t14200/9333); +bool t14202 = (0>=t14201); +float t14203; +if(t14202){ +t14203 = 0; +} else { +t14203 = t14201; +} +float t14204 = (t14199-t14203); +float t14205 = (t14204*t1532); +float t14206 = (t1571*t14204); +float t14207 = (t14205+t14206); +float t14208 = (0+t14207); +float t14209 = (t1597/4000); +bool t14210 = (1<=t14209); +float t14211; +if(t14210){ +t14211 = 1; +} else { +t14211 = t14209; +} +float t14212 = (t1597-7000); +float t14213 = (t14212/9333); +bool t14214 = (0>=t14213); +float t14215; +if(t14214){ +t14215 = 0; +} else { +t14215 = t14213; +} +float t14216 = (t14211-t14215); +float t14217 = (t14216*t1750); +float t14218 = (t1789*t14216); +float t14219 = (t14217+t14218); +float t14220 = (t14208+t14219); +float t14221 = (t1815/4000); +bool t14222 = (1<=t14221); +float t14223; +if(t14222){ +t14223 = 1; +} else { +t14223 = t14221; +} +float t14224 = (t1815-7000); +float t14225 = (t14224/9333); +bool t14226 = (0>=t14225); +float t14227; +if(t14226){ +t14227 = 0; +} else { +t14227 = t14225; +} +float t14228 = (t14223-t14227); +float t14229 = (t14228*t1968); +float t14230 = (t2007*t14228); +float t14231 = (t14229+t14230); +float t14232 = (t14220+t14231); +float t14233 = (t2042/4000); +bool t14234 = (1<=t14233); +float t14235; +if(t14234){ +t14235 = 1; +} else { +t14235 = t14233; +} +float t14236 = (t2042-7000); +float t14237 = (t14236/9333); +bool t14238 = (0>=t14237); +float t14239; +if(t14238){ +t14239 = 0; +} else { +t14239 = t14237; +} +float t14240 = (t14235-t14239); +float t14241 = (t14240*t2195); +float t14242 = (t2234*t14240); +float t14243 = (t14241+t14242); +float t14244 = (t14232+t14243); +float t14245 = (float(0.3)*t2633); +bool t14246 = (0>=t14245); +float t14247; +if(t14246){ +t14247 = 0; +} else { +t14247 = t14245; +} +float t14248 = (t14247*1); +float t14249 = (t14244+t14248); +float t14250 = (float(0.3)*t3034); +bool t14251 = (0>=t14250); +float t14252; +if(t14251){ +t14252 = 0; +} else { +t14252 = t14250; +} +float t14253 = (t14252*1); +float t14254 = (t14249+t14253); +float t14255 = (float(0.3)*t3436); +bool t14256 = (0>=t14255); +float t14257; +if(t14256){ +t14257 = 0; +} else { +t14257 = t14255; +} +float t14258 = (t14257*1); +float t14259 = (t14254+t14258); +float t14260 = (float(0.3)*t3837); +bool t14261 = (0>=t14260); +float t14262; +if(t14261){ +t14262 = 0; +} else { +t14262 = t14260; +} +float t14263 = (t14262*1); +float t14264 = (t14259+t14263); +float t14265 = (float(0.3)*t4238); +bool t14266 = (0>=t14265); +float t14267; +if(t14266){ +t14267 = 0; +} else { +t14267 = t14265; +} +float t14268 = (t14267*1); +float t14269 = (t14264+t14268); +float t14270 = (float(0.3)*t4639); +bool t14271 = (0>=t14270); +float t14272; +if(t14271){ +t14272 = 0; +} else { +t14272 = t14270; +} +float t14273 = (t14272*1); +float t14274 = (t14269+t14273); +float t14275 = (float(0.3)*t5041); +bool t14276 = (0>=t14275); +float t14277; +if(t14276){ +t14277 = 0; +} else { +t14277 = t14275; +} +float t14278 = (t14277*1); +float t14279 = (t14274+t14278); +float t14280 = (float(0.3)*t5442); +bool t14281 = (0>=t14280); +float t14282; +if(t14281){ +t14282 = 0; +} else { +t14282 = t14280; +} +float t14283 = (t14282*1); +float t14284 = (t14279+t14283); +float t14285 = (t5481/4000); +bool t14286 = (1<=t14285); +float t14287; +if(t14286){ +t14287 = 1; +} else { +t14287 = t14285; +} +float t14288 = (t5481-7000); +float t14289 = (t14288/9333); +bool t14290 = (0>=t14289); +float t14291; +if(t14290){ +t14291 = 0; +} else { +t14291 = t14289; +} +float t14292 = (t14287-t14291); +float t14293 = (t14292*t5634); +float t14294 = (t5673*t14292); +float t14295 = (t14293+t14294); +float t14296 = (0+t14295); +float t14297 = (t5699/4000); +bool t14298 = (1<=t14297); +float t14299; +if(t14298){ +t14299 = 1; +} else { +t14299 = t14297; +} +float t14300 = (t5699-7000); +float t14301 = (t14300/9333); +bool t14302 = (0>=t14301); +float t14303; +if(t14302){ +t14303 = 0; +} else { +t14303 = t14301; +} +float t14304 = (t14299-t14303); +float t14305 = (t14304*t5852); +float t14306 = (t5891*t14304); +float t14307 = (t14305+t14306); +float t14308 = (t14296+t14307); +float t14309 = (t5917/4000); +bool t14310 = (1<=t14309); +float t14311; +if(t14310){ +t14311 = 1; +} else { +t14311 = t14309; +} +float t14312 = (t5917-7000); +float t14313 = (t14312/9333); +bool t14314 = (0>=t14313); +float t14315; +if(t14314){ +t14315 = 0; +} else { +t14315 = t14313; +} +float t14316 = (t14311-t14315); +float t14317 = (t14316*t6070); +float t14318 = (t6109*t14316); +float t14319 = (t14317+t14318); +float t14320 = (t14308+t14319); +float t14321 = (t6144/4000); +bool t14322 = (1<=t14321); +float t14323; +if(t14322){ +t14323 = 1; +} else { +t14323 = t14321; +} +float t14324 = (t6144-7000); +float t14325 = (t14324/9333); +bool t14326 = (0>=t14325); +float t14327; +if(t14326){ +t14327 = 0; +} else { +t14327 = t14325; +} +float t14328 = (t14323-t14327); +float t14329 = (t14328*t6297); +float t14330 = (t6336*t14328); +float t14331 = (t14329+t14330); +float t14332 = (t14320+t14331); +float t14333 = (float(0.3)*t6735); +bool t14334 = (0>=t14333); +float t14335; +if(t14334){ +t14335 = 0; +} else { +t14335 = t14333; +} +float t14336 = (t14335*0); +float t14337 = (t14332+t14336); +float t14338 = (float(0.3)*t7136); +bool t14339 = (0>=t14338); +float t14340; +if(t14339){ +t14340 = 0; +} else { +t14340 = t14338; +} +float t14341 = (t14340*0); +float t14342 = (t14337+t14341); +float t14343 = (float(0.3)*t7538); +bool t14344 = (0>=t14343); +float t14345; +if(t14344){ +t14345 = 0; +} else { +t14345 = t14343; +} +float t14346 = (t14345*0); +float t14347 = (t14342+t14346); +float t14348 = (float(0.3)*t7939); +bool t14349 = (0>=t14348); +float t14350; +if(t14349){ +t14350 = 0; +} else { +t14350 = t14348; +} +float t14351 = (t14350*0); +float t14352 = (t14347+t14351); +float t14353 = (float(0.3)*t8340); +bool t14354 = (0>=t14353); +float t14355; +if(t14354){ +t14355 = 0; +} else { +t14355 = t14353; +} +float t14356 = (t14355*0); +float t14357 = (t14352+t14356); +float t14358 = (float(0.3)*t8741); +bool t14359 = (0>=t14358); +float t14360; +if(t14359){ +t14360 = 0; +} else { +t14360 = t14358; +} +float t14361 = (t14360*0); +float t14362 = (t14357+t14361); +float t14363 = (float(0.3)*t9143); +bool t14364 = (0>=t14363); +float t14365; +if(t14364){ +t14365 = 0; +} else { +t14365 = t14363; +} +float t14366 = (t14365*0); +float t14367 = (t14362+t14366); +float t14368 = (float(0.3)*t9544); +bool t14369 = (0>=t14368); +float t14370; +if(t14369){ +t14370 = 0; +} else { +t14370 = t14368; +} +float t14371 = (t14370*0); +float t14372 = (t14367+t14371); +float t14373 = (t14372*float(0.33)); +float t14374 = (t14284+t14373); +float t14375 = (t10031/4000); +bool t14376 = (1<=t14375); +float t14377; +if(t14376){ +t14377 = 1; +} else { +t14377 = t14375; +} +float t14378 = (t10031-7000); +float t14379 = (t14378/9333); +bool t14380 = (0>=t14379); +float t14381; +if(t14380){ +t14381 = 0; +} else { +t14381 = t14379; +} +float t14382 = (t14377-t14381); +float t14383 = (t14382*t10184); +float t14384 = (t10223*t14382); +float t14385 = (t14383+t14384); +float t14386 = (0+t14385); +float t14387 = (t10249/4000); +bool t14388 = (1<=t14387); +float t14389; +if(t14388){ +t14389 = 1; +} else { +t14389 = t14387; +} +float t14390 = (t10249-7000); +float t14391 = (t14390/9333); +bool t14392 = (0>=t14391); +float t14393; +if(t14392){ +t14393 = 0; +} else { +t14393 = t14391; +} +float t14394 = (t14389-t14393); +float t14395 = (t14394*t10402); +float t14396 = (t10441*t14394); +float t14397 = (t14395+t14396); +float t14398 = (t14386+t14397); +float t14399 = (t10467/4000); +bool t14400 = (1<=t14399); +float t14401; +if(t14400){ +t14401 = 1; +} else { +t14401 = t14399; +} +float t14402 = (t10467-7000); +float t14403 = (t14402/9333); +bool t14404 = (0>=t14403); +float t14405; +if(t14404){ +t14405 = 0; +} else { +t14405 = t14403; +} +float t14406 = (t14401-t14405); +float t14407 = (t14406*t10620); +float t14408 = (t10659*t14406); +float t14409 = (t14407+t14408); +float t14410 = (t14398+t14409); +float t14411 = (t10694/4000); +bool t14412 = (1<=t14411); +float t14413; +if(t14412){ +t14413 = 1; +} else { +t14413 = t14411; +} +float t14414 = (t10694-7000); +float t14415 = (t14414/9333); +bool t14416 = (0>=t14415); +float t14417; +if(t14416){ +t14417 = 0; +} else { +t14417 = t14415; +} +float t14418 = (t14413-t14417); +float t14419 = (t14418*t10847); +float t14420 = (t10886*t14418); +float t14421 = (t14419+t14420); +float t14422 = (t14410+t14421); +float t14423 = (float(0.3)*t11285); +bool t14424 = (0>=t14423); +float t14425; +if(t14424){ +t14425 = 0; +} else { +t14425 = t14423; +} +float t14426 = (t14425*0); +float t14427 = (t14422+t14426); +float t14428 = (float(0.3)*t11686); +bool t14429 = (0>=t14428); +float t14430; +if(t14429){ +t14430 = 0; +} else { +t14430 = t14428; +} +float t14431 = (t14430*0); +float t14432 = (t14427+t14431); +float t14433 = (float(0.3)*t12088); +bool t14434 = (0>=t14433); +float t14435; +if(t14434){ +t14435 = 0; +} else { +t14435 = t14433; +} +float t14436 = (t14435*0); +float t14437 = (t14432+t14436); +float t14438 = (float(0.3)*t12489); +bool t14439 = (0>=t14438); +float t14440; +if(t14439){ +t14440 = 0; +} else { +t14440 = t14438; +} +float t14441 = (t14440*0); +float t14442 = (t14437+t14441); +float t14443 = (float(0.3)*t12890); +bool t14444 = (0>=t14443); +float t14445; +if(t14444){ +t14445 = 0; +} else { +t14445 = t14443; +} +float t14446 = (t14445*0); +float t14447 = (t14442+t14446); +float t14448 = (float(0.3)*t13291); +bool t14449 = (0>=t14448); +float t14450; +if(t14449){ +t14450 = 0; +} else { +t14450 = t14448; +} +float t14451 = (t14450*0); +float t14452 = (t14447+t14451); +float t14453 = (float(0.3)*t13693); +bool t14454 = (0>=t14453); +float t14455; +if(t14454){ +t14455 = 0; +} else { +t14455 = t14453; +} +float t14456 = (t14455*0); +float t14457 = (t14452+t14456); +float t14458 = (float(0.3)*t14094); +bool t14459 = (0>=t14458); +float t14460; +if(t14459){ +t14460 = 0; +} else { +t14460 = t14458; +} +float t14461 = (t14460*0); +float t14462 = (t14457+t14461); +float t14463 = (t14462*t14100); +bool t14464 = (t9997>=t14463); +float t14465; +if(t14464){ +t14465 = t9997; +} else { +t14465 = t14463; +} +float t14466 = (t14374+t14465); +float t14467 = (t14466*t14150); +float t14468 = (t14467*t14152); +float t14469 = (t14196+t14468); +float t14470 = (t14469*t14155); +float t14471 = (t14187+t14470); +float t14472 = (float(0.72)*t1); +float t14473 = (t0+t14472); +float t14474 = (t14473*t155); +float t14475 = (float(0.8)*t469); +float t14476 = (float(0.0)+t14475); +float t14477 = (t14476*t472); +float t14478 = (t14474+t14477); +float t14479 = (t14478*t524); +float t14480 = (float(0.0)*t678); +float t14481 = (t14480*t680); +float t14482 = (t14479+t14481); +float t14483 = (t14482*t685); +float t14484 = (float(0.2)*t839); +float t14485 = (t14484*t841); +float t14486 = (t14483+t14485); +float t14487 = (t14486*t846); +float t14488 = (t1062*t1063); +float t14489 = (float(6.0e-2)*t1065); +float t14490 = (t14488+t14489); +float t14491 = (t14490*t1072); +float t14492 = (t14491*t1077); +float t14493 = (0*t1079); +float t14494 = (t14492+t14493); +float t14495 = (t1000*t14494); +float t14496 = (t14495*t1083); +float t14497 = (t14487+t14496); +float t14498 = (t14497*t1092); +float t14499 = (float(0.7)*t1246); +float t14500 = (t14499*t1248); +float t14501 = (t14498+t14500); +float t14502 = (t14501*t1254); +float t14503 = (float(1.0)*t1256); +float t14504 = (float(0.6)*t1258); +float t14505 = (t14503+t14504); +float t14506 = (-float(0.4)); +float t14507 = (t14506*t1296); +float t14508 = (t14507*t1300); +float t14509 = (t14508*t1334); +float t14510 = (t14505+t14509); +float t14511 = (u8.u0*t14510); +float t14512 = (t14511*t1342); +float t14513 = (t1377/8000); +bool t14514 = (1<=t14513); +float t14515; +if(t14514){ +t14515 = 1; +} else { +t14515 = t14513; +} +float t14516 = (t14515*t1532); +float t14517 = (t1571*t14515); +float t14518 = (t14516+t14517); +float t14519 = (0+t14518); +float t14520 = (t1597/8000); +bool t14521 = (1<=t14520); +float t14522; +if(t14521){ +t14522 = 1; +} else { +t14522 = t14520; +} +float t14523 = (t14522*t1750); +float t14524 = (t1789*t14522); +float t14525 = (t14523+t14524); +float t14526 = (t14519+t14525); +float t14527 = (t1815/8000); +bool t14528 = (1<=t14527); +float t14529; +if(t14528){ +t14529 = 1; +} else { +t14529 = t14527; +} +float t14530 = (t14529*t1968); +float t14531 = (t2007*t14529); +float t14532 = (t14530+t14531); +float t14533 = (t14526+t14532); +float t14534 = (t2042/8000); +bool t14535 = (1<=t14534); +float t14536; +if(t14535){ +t14536 = 1; +} else { +t14536 = t14534; +} +float t14537 = (t14536*t2195); +float t14538 = (t2234*t14536); +float t14539 = (t14537+t14538); +float t14540 = (t14533+t14539); +float t14541 = (float(0.7)*t2633); +bool t14542 = (0>=t14541); +float t14543; +if(t14542){ +t14543 = 0; +} else { +t14543 = t14541; +} +float t14544 = (t14543*1); +float t14545 = (t14540+t14544); +float t14546 = (float(0.7)*t3034); +bool t14547 = (0>=t14546); +float t14548; +if(t14547){ +t14548 = 0; +} else { +t14548 = t14546; +} +float t14549 = (t14548*1); +float t14550 = (t14545+t14549); +float t14551 = (float(0.7)*t3436); +bool t14552 = (0>=t14551); +float t14553; +if(t14552){ +t14553 = 0; +} else { +t14553 = t14551; +} +float t14554 = (t14553*1); +float t14555 = (t14550+t14554); +float t14556 = (float(0.7)*t3837); +bool t14557 = (0>=t14556); +float t14558; +if(t14557){ +t14558 = 0; +} else { +t14558 = t14556; +} +float t14559 = (t14558*1); +float t14560 = (t14555+t14559); +float t14561 = (float(0.7)*t4238); +bool t14562 = (0>=t14561); +float t14563; +if(t14562){ +t14563 = 0; +} else { +t14563 = t14561; +} +float t14564 = (t14563*1); +float t14565 = (t14560+t14564); +float t14566 = (float(0.7)*t4639); +bool t14567 = (0>=t14566); +float t14568; +if(t14567){ +t14568 = 0; +} else { +t14568 = t14566; +} +float t14569 = (t14568*1); +float t14570 = (t14565+t14569); +float t14571 = (float(0.7)*t5041); +bool t14572 = (0>=t14571); +float t14573; +if(t14572){ +t14573 = 0; +} else { +t14573 = t14571; +} +float t14574 = (t14573*1); +float t14575 = (t14570+t14574); +float t14576 = (float(0.7)*t5442); +bool t14577 = (0>=t14576); +float t14578; +if(t14577){ +t14578 = 0; +} else { +t14578 = t14576; +} +float t14579 = (t14578*1); +float t14580 = (t14575+t14579); +float t14581 = (t5481/8000); +bool t14582 = (1<=t14581); +float t14583; +if(t14582){ +t14583 = 1; +} else { +t14583 = t14581; +} +float t14584 = (t14583*t5634); +float t14585 = (t5673*t14583); +float t14586 = (t14584+t14585); +float t14587 = (0+t14586); +float t14588 = (t5699/8000); +bool t14589 = (1<=t14588); +float t14590; +if(t14589){ +t14590 = 1; +} else { +t14590 = t14588; +} +float t14591 = (t14590*t5852); +float t14592 = (t5891*t14590); +float t14593 = (t14591+t14592); +float t14594 = (t14587+t14593); +float t14595 = (t5917/8000); +bool t14596 = (1<=t14595); +float t14597; +if(t14596){ +t14597 = 1; +} else { +t14597 = t14595; +} +float t14598 = (t14597*t6070); +float t14599 = (t6109*t14597); +float t14600 = (t14598+t14599); +float t14601 = (t14594+t14600); +float t14602 = (t6144/8000); +bool t14603 = (1<=t14602); +float t14604; +if(t14603){ +t14604 = 1; +} else { +t14604 = t14602; +} +float t14605 = (t14604*t6297); +float t14606 = (t6336*t14604); +float t14607 = (t14605+t14606); +float t14608 = (t14601+t14607); +float t14609 = (float(0.7)*t6735); +bool t14610 = (0>=t14609); +float t14611; +if(t14610){ +t14611 = 0; +} else { +t14611 = t14609; +} +float t14612 = (t14611*0); +float t14613 = (t14608+t14612); +float t14614 = (float(0.7)*t7136); +bool t14615 = (0>=t14614); +float t14616; +if(t14615){ +t14616 = 0; +} else { +t14616 = t14614; +} +float t14617 = (t14616*0); +float t14618 = (t14613+t14617); +float t14619 = (float(0.7)*t7538); +bool t14620 = (0>=t14619); +float t14621; +if(t14620){ +t14621 = 0; +} else { +t14621 = t14619; +} +float t14622 = (t14621*0); +float t14623 = (t14618+t14622); +float t14624 = (float(0.7)*t7939); +bool t14625 = (0>=t14624); +float t14626; +if(t14625){ +t14626 = 0; +} else { +t14626 = t14624; +} +float t14627 = (t14626*0); +float t14628 = (t14623+t14627); +float t14629 = (float(0.7)*t8340); +bool t14630 = (0>=t14629); +float t14631; +if(t14630){ +t14631 = 0; +} else { +t14631 = t14629; +} +float t14632 = (t14631*0); +float t14633 = (t14628+t14632); +float t14634 = (float(0.7)*t8741); +bool t14635 = (0>=t14634); +float t14636; +if(t14635){ +t14636 = 0; +} else { +t14636 = t14634; +} +float t14637 = (t14636*0); +float t14638 = (t14633+t14637); +float t14639 = (float(0.7)*t9143); +bool t14640 = (0>=t14639); +float t14641; +if(t14640){ +t14641 = 0; +} else { +t14641 = t14639; +} +float t14642 = (t14641*0); +float t14643 = (t14638+t14642); +float t14644 = (float(0.7)*t9544); +bool t14645 = (0>=t14644); +float t14646; +if(t14645){ +t14646 = 0; +} else { +t14646 = t14644; +} +float t14647 = (t14646*0); +float t14648 = (t14643+t14647); +float t14649 = (t14648*float(0.33)); +float t14650 = (t14580+t14649); +float t14651 = (t10031/8000); +bool t14652 = (1<=t14651); +float t14653; +if(t14652){ +t14653 = 1; +} else { +t14653 = t14651; +} +float t14654 = (t14653*t10184); +float t14655 = (t10223*t14653); +float t14656 = (t14654+t14655); +float t14657 = (0+t14656); +float t14658 = (t10249/8000); +bool t14659 = (1<=t14658); +float t14660; +if(t14659){ +t14660 = 1; +} else { +t14660 = t14658; +} +float t14661 = (t14660*t10402); +float t14662 = (t10441*t14660); +float t14663 = (t14661+t14662); +float t14664 = (t14657+t14663); +float t14665 = (t10467/8000); +bool t14666 = (1<=t14665); +float t14667; +if(t14666){ +t14667 = 1; +} else { +t14667 = t14665; +} +float t14668 = (t14667*t10620); +float t14669 = (t10659*t14667); +float t14670 = (t14668+t14669); +float t14671 = (t14664+t14670); +float t14672 = (t10694/8000); +bool t14673 = (1<=t14672); +float t14674; +if(t14673){ +t14674 = 1; +} else { +t14674 = t14672; +} +float t14675 = (t14674*t10847); +float t14676 = (t10886*t14674); +float t14677 = (t14675+t14676); +float t14678 = (t14671+t14677); +float t14679 = (float(0.7)*t11285); +bool t14680 = (0>=t14679); +float t14681; +if(t14680){ +t14681 = 0; +} else { +t14681 = t14679; +} +float t14682 = (t14681*0); +float t14683 = (t14678+t14682); +float t14684 = (float(0.7)*t11686); +bool t14685 = (0>=t14684); +float t14686; +if(t14685){ +t14686 = 0; +} else { +t14686 = t14684; +} +float t14687 = (t14686*0); +float t14688 = (t14683+t14687); +float t14689 = (float(0.7)*t12088); +bool t14690 = (0>=t14689); +float t14691; +if(t14690){ +t14691 = 0; +} else { +t14691 = t14689; +} +float t14692 = (t14691*0); +float t14693 = (t14688+t14692); +float t14694 = (float(0.7)*t12489); +bool t14695 = (0>=t14694); +float t14696; +if(t14695){ +t14696 = 0; +} else { +t14696 = t14694; +} +float t14697 = (t14696*0); +float t14698 = (t14693+t14697); +float t14699 = (float(0.7)*t12890); +bool t14700 = (0>=t14699); +float t14701; +if(t14700){ +t14701 = 0; +} else { +t14701 = t14699; +} +float t14702 = (t14701*0); +float t14703 = (t14698+t14702); +float t14704 = (float(0.7)*t13291); +bool t14705 = (0>=t14704); +float t14706; +if(t14705){ +t14706 = 0; +} else { +t14706 = t14704; +} +float t14707 = (t14706*0); +float t14708 = (t14703+t14707); +float t14709 = (float(0.7)*t13693); +bool t14710 = (0>=t14709); +float t14711; +if(t14710){ +t14711 = 0; +} else { +t14711 = t14709; +} +float t14712 = (t14711*0); +float t14713 = (t14708+t14712); +float t14714 = (float(0.7)*t14094); +bool t14715 = (0>=t14714); +float t14716; +if(t14715){ +t14716 = 0; +} else { +t14716 = t14714; +} +float t14717 = (t14716*0); +float t14718 = (t14713+t14717); +float t14719 = (t14718*t14100); +bool t14720 = (t9997>=t14719); +float t14721; +if(t14720){ +t14721 = t9997; +} else { +t14721 = t14719; +} +float t14722 = (t14650+t14721); +float t14723 = (t14722*t14150); +float t14724 = (t14723*t14152); +float t14725 = (t14512+t14724); +float t14726 = (t14725*t14155); +float t14727 = (t14502+t14726); +float t14728 = (1*t14150); +float t14729 = (1-t14728); +float t14730 = (t14729*t1342); +float t14731 = (t14728+t14730); +float t14732 = (1-t14731); +float t14733 = (t14732*t1254); +float t14734 = (t14731+t14733); +out0 = vec4(t14157,t14471,t14727,t14734); +gl_FragDepth = gl_FragCoord[2]; +} diff --git a/test/data/large-shaders/xax.vert b/test/data/large-shaders/xax.vert new file mode 100644 --- /dev/null +++ b/test/data/large-shaders/xax.vert @@ -0,0 +1,382 @@ +#version 450 +out float vf0; +out float vf1; +out float vf2; +layout(std140) uniform uBlock2 { +vec4 u0; +vec4 u16; +vec4 u32; +vec4 u48; +} u2; +layout(std140) uniform uBlock3 { +vec4 u0; +vec4 u16; +vec4 u32; +vec4 u48; +} u3; +layout(std140) uniform uBlock5 { +float u0; +} u5; +in vec3 in0; +void main() { +vec3 t0 = in0; +vec4 t1 = vec4(t0.x,t0.y,t0.z,1); +vec4 t2 = vec4(u3.u0[0],u3.u0[1],u3.u0[2],u3.u0[3]); +vec4 t3 = vec4(u3.u16[0],u3.u16[1],u3.u16[2],u3.u16[3]); +vec4 t4 = vec4(u3.u32[0],u3.u32[1],u3.u32[2],u3.u32[3]); +vec4 t5 = vec4(u3.u48[0],u3.u48[1],u3.u48[2],u3.u48[3]); +mat4x4 t6 = mat4x4(t2,t3,t4,t5); +vec4 t7 = vec4(u2.u0[0],u2.u0[1],u2.u0[2],0); +vec4 t8 = vec4(u2.u16[0],u2.u16[1],u2.u16[2],0); +vec4 t9 = vec4(u2.u32[0],u2.u32[1],u2.u32[2],0); +vec4 t10 = vec4(0,0,0,1); +mat4x4 t11 = mat4x4(t7,t8,t9,t10); +mat4x4 t12 = (t6*t11); +float t13 = (t12[0][0]*t12[1][1]); +float t14 = (t12[1][0]*t12[0][1]); +float t15 = (t13-t14); +float t16 = (t12[2][2]*t12[3][3]); +float t17 = (t12[3][2]*t12[2][3]); +float t18 = (t16-t17); +float t19 = (t15*t18); +float t20 = (t12[0][0]*t12[1][2]); +float t21 = (t12[1][0]*t12[0][2]); +float t22 = (t20-t21); +float t23 = (t12[2][1]*t12[3][3]); +float t24 = (t12[3][1]*t12[2][3]); +float t25 = (t23-t24); +float t26 = (t22*t25); +float t27 = (t19-t26); +float t28 = (t12[0][0]*t12[1][3]); +float t29 = (t12[1][0]*t12[0][3]); +float t30 = (t28-t29); +float t31 = (t12[2][1]*t12[3][2]); +float t32 = (t12[3][1]*t12[2][2]); +float t33 = (t31-t32); +float t34 = (t30*t33); +float t35 = (t27+t34); +float t36 = (t12[0][1]*t12[1][2]); +float t37 = (t12[1][1]*t12[0][2]); +float t38 = (t36-t37); +float t39 = (t12[2][0]*t12[3][3]); +float t40 = (t12[3][0]*t12[2][3]); +float t41 = (t39-t40); +float t42 = (t38*t41); +float t43 = (t35+t42); +float t44 = (t12[0][1]*t12[1][3]); +float t45 = (t12[1][1]*t12[0][3]); +float t46 = (t44-t45); +float t47 = (t12[2][0]*t12[3][2]); +float t48 = (t12[3][0]*t12[2][2]); +float t49 = (t47-t48); +float t50 = (t46*t49); +float t51 = (t43-t50); +float t52 = (t12[0][2]*t12[1][3]); +float t53 = (t12[1][2]*t12[0][3]); +float t54 = (t52-t53); +float t55 = (t12[2][0]*t12[3][1]); +float t56 = (t12[3][0]*t12[2][1]); +float t57 = (t55-t56); +float t58 = (t54*t57); +float t59 = (t51+t58); +float t60 = (1/t59); +float t61 = (t12[1][1]*t18); +float t62 = (t12[1][2]*t25); +float t63 = (t61-t62); +float t64 = (t12[1][3]*t33); +float t65 = (t63+t64); +float t66 = (t60*t65); +float t67 = (t12[0][1]*t18); +float t68 = (-t67); +float t69 = (t12[0][2]*t25); +float t70 = (t68+t69); +float t71 = (t12[0][3]*t33); +float t72 = (t70-t71); +float t73 = (t60*t72); +float t74 = (t12[3][1]*t54); +float t75 = (t12[3][2]*t46); +float t76 = (t74-t75); +float t77 = (t12[3][3]*t38); +float t78 = (t76+t77); +float t79 = (t60*t78); +float t80 = (t12[2][1]*t54); +float t81 = (-t80); +float t82 = (t12[2][2]*t46); +float t83 = (t81+t82); +float t84 = (t12[2][3]*t38); +float t85 = (t83-t84); +float t86 = (t60*t85); +vec4 t87 = vec4(t66,t73,t79,t86); +float t88 = (t12[1][0]*t18); +float t89 = (-t88); +float t90 = (t12[1][2]*t41); +float t91 = (t89+t90); +float t92 = (t12[1][3]*t49); +float t93 = (t91-t92); +float t94 = (t60*t93); +float t95 = (t12[0][0]*t18); +float t96 = (t12[0][2]*t41); +float t97 = (t95-t96); +float t98 = (t12[0][3]*t49); +float t99 = (t97+t98); +float t100 = (t60*t99); +float t101 = (t12[3][0]*t54); +float t102 = (-t101); +float t103 = (t12[3][2]*t30); +float t104 = (t102+t103); +float t105 = (t12[3][3]*t22); +float t106 = (t104-t105); +float t107 = (t60*t106); +float t108 = (t12[2][0]*t54); +float t109 = (t12[2][2]*t30); +float t110 = (t108-t109); +float t111 = (t12[2][3]*t22); +float t112 = (t110+t111); +float t113 = (t60*t112); +vec4 t114 = vec4(t94,t100,t107,t113); +float t115 = (t12[1][0]*t25); +float t116 = (t12[1][1]*t41); +float t117 = (t115-t116); +float t118 = (t12[1][3]*t57); +float t119 = (t117+t118); +float t120 = (t60*t119); +float t121 = (t12[0][0]*t25); +float t122 = (-t121); +float t123 = (t12[0][1]*t41); +float t124 = (t122+t123); +float t125 = (t12[0][3]*t57); +float t126 = (t124-t125); +float t127 = (t60*t126); +float t128 = (t12[3][0]*t46); +float t129 = (t12[3][1]*t30); +float t130 = (t128-t129); +float t131 = (t12[3][3]*t15); +float t132 = (t130+t131); +float t133 = (t60*t132); +float t134 = (t12[2][0]*t46); +float t135 = (-t134); +float t136 = (t12[2][1]*t30); +float t137 = (t135+t136); +float t138 = (t12[2][3]*t15); +float t139 = (t137-t138); +float t140 = (t60*t139); +vec4 t141 = vec4(t120,t127,t133,t140); +float t142 = (t12[1][0]*t33); +float t143 = (-t142); +float t144 = (t12[1][1]*t49); +float t145 = (t143+t144); +float t146 = (t12[1][2]*t57); +float t147 = (t145-t146); +float t148 = (t60*t147); +float t149 = (t12[0][0]*t33); +float t150 = (t12[0][1]*t49); +float t151 = (t149-t150); +float t152 = (t12[0][2]*t57); +float t153 = (t151+t152); +float t154 = (t60*t153); +float t155 = (t12[3][0]*t38); +float t156 = (-t155); +float t157 = (t12[3][1]*t22); +float t158 = (t156+t157); +float t159 = (t12[3][2]*t15); +float t160 = (t158-t159); +float t161 = (t60*t160); +float t162 = (t12[2][0]*t38); +float t163 = (t12[2][1]*t22); +float t164 = (t162-t163); +float t165 = (t12[2][2]*t15); +float t166 = (t164+t165); +float t167 = (t60*t166); +vec4 t168 = vec4(t148,t154,t161,t167); +mat4x4 t169 = mat4x4(t87,t114,t141,t168); +vec4 t170 = (t1*t169); +float t171 = (t170[0]/t170[3]); +float t172 = (t171*t171); +float t173 = (t170[1]/t170[3]); +float t174 = (t173*t173); +float t175 = (t172+t174); +float t176 = (t170[2]/t170[3]); +float t177 = (t176*t176); +float t178 = (t175+t177); +float t179 = sqrt(t178); +float t180 = (t171/t179); +float t181 = (t173/t179); +float t182 = (t176/t179); +vec4 t183 = vec4(t180,t181,t182,1); +float t184 = mod(u5.u0,840); +float t185 = (t184/840); +float t186 = (t185*3.1415927); +float t187 = (t186*2); +float t188 = (t187/2); +float t189 = sin(t188); +float t190 = (0*0); +float t191 = (1*1); +float t192 = (t190+t191); +float t193 = (0*0); +float t194 = (t192+t193); +float t195 = sqrt(t194); +float t196 = (1/t195); +float t197 = (t189*t196); +float t198 = (t197*t197); +float t199 = (0/t195); +float t200 = (t189*t199); +float t201 = (t200*t200); +float t202 = (t198+t201); +float t203 = (2*t202); +float t204 = (1-t203); +float t205 = (3.1415927/4); +float t206 = (t205/2); +float t207 = sin(t206); +float t208 = sin(t205); +float t209 = (1*t208); +float t210 = cos(0); +float t211 = (t209*t210); +float t212 = (t211*0); +float t213 = sin(0); +float t214 = (t209*t213); +float t215 = (t214*0); +float t216 = (t212-t215); +float t217 = cos(t205); +float t218 = (1*t217); +float t219 = (t218*0); +float t220 = (t211*1); +float t221 = (t219-t220); +float t222 = (t221*t221); +float t223 = (t216*t216); +float t224 = (t222+t223); +float t225 = (t214*1); +float t226 = (t218*0); +float t227 = (t225-t226); +float t228 = (t227*t227); +float t229 = (t224+t228); +float t230 = sqrt(t229); +float t231 = (t216/t230); +float t232 = (t207*t231); +float t233 = (t232*t232); +float t234 = (t227/t230); +float t235 = (t207*t234); +float t236 = (t235*t235); +float t237 = (t233+t236); +float t238 = (2*t237); +float t239 = (1-t238); +float t240 = (t204*t239); +float t241 = (0+t240); +float t242 = (0/t195); +float t243 = (t189*t242); +float t244 = (t243*t197); +float t245 = cos(t188); +float t246 = (t200*t245); +float t247 = (t244-t246); +float t248 = (2*t247); +float t249 = (t221/t230); +float t250 = (t207*t249); +float t251 = (t250*t232); +float t252 = cos(t206); +float t253 = (t235*t252); +float t254 = (t251+t253); +float t255 = (2*t254); +float t256 = (t248*t255); +float t257 = (t241+t256); +float t258 = (t243*t200); +float t259 = (t197*t245); +float t260 = (t258+t259); +float t261 = (2*t260); +float t262 = (t250*t235); +float t263 = (t232*t252); +float t264 = (t262-t263); +float t265 = (2*t264); +float t266 = (t261*t265); +float t267 = (t257+t266); +float t268 = (t251-t253); +float t269 = (2*t268); +float t270 = (t204*t269); +float t271 = (0+t270); +float t272 = (t250*t250); +float t273 = (t272+t236); +float t274 = (2*t273); +float t275 = (1-t274); +float t276 = (t248*t275); +float t277 = (t271+t276); +float t278 = (t232*t235); +float t279 = (t250*t252); +float t280 = (t278+t279); +float t281 = (2*t280); +float t282 = (t261*t281); +float t283 = (t277+t282); +float t284 = (t262+t263); +float t285 = (2*t284); +float t286 = (t204*t285); +float t287 = (0+t286); +float t288 = (t278-t279); +float t289 = (2*t288); +float t290 = (t248*t289); +float t291 = (t287+t290); +float t292 = (t272+t233); +float t293 = (2*t292); +float t294 = (1-t293); +float t295 = (t261*t294); +float t296 = (t291+t295); +vec4 t297 = vec4(t267,t283,t296,0); +float t298 = (t244+t246); +float t299 = (2*t298); +float t300 = (t299*t239); +float t301 = (0+t300); +float t302 = (t243*t243); +float t303 = (t302+t201); +float t304 = (2*t303); +float t305 = (1-t304); +float t306 = (t305*t255); +float t307 = (t301+t306); +float t308 = (t197*t200); +float t309 = (t243*t245); +float t310 = (t308-t309); +float t311 = (2*t310); +float t312 = (t311*t265); +float t313 = (t307+t312); +float t314 = (t299*t269); +float t315 = (0+t314); +float t316 = (t305*t275); +float t317 = (t315+t316); +float t318 = (t311*t281); +float t319 = (t317+t318); +float t320 = (t299*t285); +float t321 = (0+t320); +float t322 = (t305*t289); +float t323 = (t321+t322); +float t324 = (t311*t294); +float t325 = (t323+t324); +vec4 t326 = vec4(t313,t319,t325,0); +float t327 = (t258-t259); +float t328 = (2*t327); +float t329 = (t328*t239); +float t330 = (0+t329); +float t331 = (t308+t309); +float t332 = (2*t331); +float t333 = (t332*t255); +float t334 = (t330+t333); +float t335 = (t302+t198); +float t336 = (2*t335); +float t337 = (1-t336); +float t338 = (t337*t265); +float t339 = (t334+t338); +float t340 = (t328*t269); +float t341 = (0+t340); +float t342 = (t332*t275); +float t343 = (t341+t342); +float t344 = (t337*t281); +float t345 = (t343+t344); +float t346 = (t328*t285); +float t347 = (0+t346); +float t348 = (t332*t289); +float t349 = (t347+t348); +float t350 = (t337*t294); +float t351 = (t349+t350); +vec4 t352 = vec4(t339,t345,t351,0); +vec4 t353 = vec4(0,0,0,1); +mat4x4 t354 = mat4x4(t297,t326,t352,t353); +vec4 t355 = (t183*t354); +vf0 = t355[0]; +vf1 = t355[1]; +vf2 = t355[2]; +gl_Position = vec4(t0.x,t0.y,t0.z,1); +} diff --git a/tools/optshader.hs b/tools/optshader.hs --- a/tools/optshader.hs +++ b/tools/optshader.hs @@ -5,9 +5,11 @@ import Data.Time.Clock as Time (diffUTCTime, getCurrentTime, nominalDiffTimeToSeconds) +import qualified Language.GLSL.AST as GLSL import qualified Language.GLSL.Optimizer as Opt import qualified Language.GLSL.Optimizer.DFG as DFG -import qualified Language.GLSL.Types as GLSL +import qualified Language.GLSL.Parser as GLSL +import qualified Language.GLSL.PrettyPrint as GLSL import qualified System.Environment as Env main :: IO ()