text:
  Baillif est
      une ville localisée dans le département de Guadeloupe en Guadeloupe. Elle comptait 6 086 habitants en 2008.

La commune compte de nombreux  équipements sportifs, elle propose entre autres un terrain de tennis et quatre terrains de sport.

À coté de Baillif sont situées les villes de
 entre autres.

La localité dispose s'agissant de des études de un collège.
S'agissant ceux d'entre nous ayant moins de 6 ans, la ville peut se prévaloir de disposer de une maternelle et trois écoles primaires.
Baillif dispose des équipements facilitant une bonne prise en charge des jeunes.
Si vous avez un projet d'achat immobilier à Baillif, il est important évaluer la notoriété des écoles de la communes

À Baillif, le prix moyen à l'achat d'un appartement s'évalue à zero € du m² en vente. Le prix moyen d'une maison à l'achat se situe à 2 019 € du m². À la location la valorisation moyenne se situe à 5,63 € du m² mensuel.

À Baillif le salaire médian mensuel par personne se situe à environ 2 214 €  net. C'est supérieur à la moyenne nationale.

Le nombre de logements, à Baillif, était réparti en 2011 en 262 appartements et 2 357 maisons soit
 un marché plutôt équilibré.


text:
using LightNode.Server;
using Owin;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Runtime.Serialization;
using System.Web;

namespace LightNode.Performance
{
    public class Startup
    {
        public void Configuration(IAppBuilder app)
        {
            app.UseLightNode(new LightNode.Server.LightNodeOptions(Server.AcceptVerbs.Get | Server.AcceptVerbs.Post,
                new LightNode.Formatter.JsonNetContentFormatter()));
        }
    }

    public class Perf : LightNode.Server.LightNodeContract
    {
        public MyClass Echo(string name, int x, int y, MyEnum e)
        {
            return new MyClass { Name = name, Sum = (x + y) * (int)e };
        }

        public void Test(string a = null, int? x = null, MyEnum2? z = null)
        {
        }

        public System.Threading.Tasks.Task Te()
        {
            return System.Threading.Tasks.Task.FromResult(1);
        }

        public void TestArray(string[] array, int[] array2, MyEnum[] array3)
        {
        }

        public void TeVoid()
        {
        }

        [Post]
        public void ByteArrayCheck1(int x, string y, byte[] byteArray)
        {
        }

        [Post]
        public void ByteArrayCheck2(string[] array, int[] array2, MyEnum[] array3, byte[] byteArray)
        {
        }

        [Post]
        public void ByteArrayCheck3(int x, string y, byte[] byteArray, string a = null, int? xxx = null, MyEnum2? z = null)
        {
        }

        public string Te4(string xs)
        {
            return xs;
        }

        [LightNode.Server.IgnoreOperation]
        public void Ignore(string a)
        {
        }

        [LightNode.Server.IgnoreClientGenerate]
        public void IgnoreClient(string a)
        {
        }

        [Post]
        public string PostString(string hoge)
        {
            return hoge;
        }
    }

    [DebugOnlyClientGenerate]
    public class DebugOnlyTest : LightNodeContract
    {
        public void Hoge()
        {
        }
    }

    public class DebugOnlyMethodTest :LightNodeContract
    {
        [DebugOnlyClientGenerate]
        public void Hoge()
        {
        }
    }

    public class MyClass
    {
        public string Name { get; set; }
        public int Sum { get; set; }
    }

    public enum MyEnum
    {
        A = 2,
        B = 3,
        C = 4
    }

    public enum MyEnum2 : ulong
    {
        A = 100,
        B = 3000,
        C = 50000
    }
}

redpajama_set_name: RedPajamaGithub


text:
{-# LANGUAGE ScopedTypeVariables, BangPatterns #-}
-- |Utility functions for working with 'Topic's. These functions are
-- primarily combinators for fusing two 'Topic's in various ways.
module Ros.Topic.Util where
import Prelude hiding (dropWhile, filter, splitAt, mapM)
import Control.Applicative
import Control.Arrow ((***), second)
import Control.Concurrent hiding (yield)
import Control.Concurrent.STM
import Control.Monad ((<=<), when, replicateM)
import Control.Monad.IO.Class
import Data.AdditiveGroup (AdditiveGroup, (^+^), (^-^), Sum(..))
import Data.Monoid (Monoid)
import Data.Sequence ((|>), viewl, ViewL(..))
import qualified Data.Sequence as S
import qualified Data.Foldable as F
import Ros.Rate (rateLimiter)
import Ros.Topic hiding (mapM_)

-- |Produce an infinite list from a 'Topic'.
toList :: Topic IO a -> IO [a]
toList t0 = do c <- newChan
               let feed t = do (x, t') <- runTopic t
                               writeChan c x
                               feed t'
               _ <- forkIO $ feed t0
               getChanContents c

-- |Produce a 'Topic' from an infinite list.
fromList :: Monad m => [a] -> Topic m a
fromList (x:xs) = Topic $ return (x, fromList xs)
fromList [] = error "Ran out of list elements"

-- |Tee a 'Topic' into two duplicate 'Topic's. Each returned 'Topic'
-- will receive all the values of the original 'Topic' while any
-- side-effect produced by each step of the original 'Topic' will
-- occur only once.
--
-- This version of @tee@ lazily pulls data from the original 'Topic'
-- when it is first required by a consumer of either of the returned
-- 'Topic's. This behavior is crucial when lazily consuming the data
-- stream is preferred. For instance, using 'interruptible' with 'tee'
-- will allow for a chunk of data to be abandoned before being fully
-- consumed as long as neither consumer has forced its way too far
-- down the stream.
--
-- This function is useful when two consumers must see all the same
-- elements from a 'Topic'. If the 'Topic' was instead 'share'd, then
-- one consumer might get the first value from the 'Topic' before the
-- second consumer's buffer is created since buffer creation is lazy.
tee :: Topic IO a -> IO (Topic IO a, Topic IO a)
tee t0 = do c1 <- newTChanIO
            c2 <- newTChanIO
            signal <- newTVarIO True
            let feed c = do atomically $ do f <- isEmptyTChan c
                                            when f (writeTVar signal False)
                            atomically $ readTChan c
                produce t = do atomically $ readTVar signal >>= flip when retry
                               (x,t') <- runTopic t
                               atomically $ writeTChan c1 x >>
                                            writeTChan c2 x >>
                                            writeTVar signal True
                               produce t'
            _ <- forkIO $ produce t0
            return (repeatM (feed c1), repeatM (feed c2))

-- |This version of @tee@ eagerly pulls data from the
-- original 'Topic' as soon as it is available. This behavior is
-- undesirable when lazily consuming the data stream is preferred. For
-- instance, using 'interruptible' with 'teeEager' will likely not
-- work well. However, 'teeEager' may have slightly better performance
-- than 'tee'.
teeEager :: Topic IO a -> IO (Topic IO a, Topic IO a)
teeEager t = do c1 <- newChan
                c2 <- newChan
                let feed c = do x <- readChan c
                                return (x, Topic $ feed c)
                _ <- forkIO . forever . join $
                     (\x -> writeChan c1 x >> writeChan c2 x) <$> t
                return (Topic $ feed c1, Topic $ feed c2)

-- |Fan out one 'Topic' out to a number of duplicate 'Topic's, each of
-- which will produce the same values. Side effects caused by the
-- original 'Topic''s production will occur only once. This is useful
-- when a known number of consumers must see exactly all the same
-- elements.
fan :: Int -> Topic IO a -> IO [Topic IO a]
fan n t0 = do cs <- replicateM n newTChanIO
              signal <- newTVarIO True
              let feed c = do atomically $ do f <- isEmptyTChan c
                                              when f (writeTVar signal False)
                              atomically $ readTChan c
                  produce t = do atomically $ readTVar signal >>= flip when retry
                                 (x,t') <- runTopic t
                                 atomically $ mapM_ (flip writeTChan x) cs >>
                                              writeTVar signal True
                                 produce t'
              _ <- forkIO $ produce t0
              return $ map (repeatM . feed) cs

-- |Make a 'Topic' shareable among multiple consumers. Each consumer
-- of a Topic gets its own read buffer automatically as soon as it
-- starts pulling items from the Topic. Without calling one of
-- 'share', 'tee', or 'fan' on a Topic, the Topic's values will be
-- split among all consumers (e.g. consumer /A/ gets half the values
-- produced by the 'Topic', while consumer /B/ gets the other half
-- with some unpredictable interleaving). Note that Topics returned by
-- the @Ros.Node.subscribe@ are already shared.
share :: Topic IO a -> IO (Topic IO a)
share t0 = do cs <- newTVarIO [] -- A list for the individual client buffers
              signal <- newTVarIO True
              let addClient = atomically $ do cs0 <- readTVar cs
                                              c <- newTChan
                                              writeTVar cs (c:cs0)
                                              return c
                  feed c = do atomically $ do f <- isEmptyTChan c
                                              when f (writeTVar signal False)
                              atomically $ readTChan c
                  produce t = do atomically $ readTVar signal >>= flip when retry
                                 (x,t') <- runTopic t
                                 atomically $ do cs' <- readTVar cs
                                                 mapM_ (flip writeTChan x) cs'
                                                 writeTVar signal True
                                 produce t'
              _ <- forkIO $ produce t0
              return . Topic $ addClient >>= runTopic . repeatM . feed

-- |The application @topicRate rate t@ runs 'Topic' @t@ no faster than
-- @rate@ Hz.
topicRate :: (Functor m, MonadIO m) => Double -> Topic m a -> Topic m a
topicRate p t0 = Topic $
                 do delay <- liftIO $ rateLimiter p (return ())
                    (x,t') <- runTopic t0
                    let go t = Topic $ liftIO delay >> second go <$> runTopic t
                    return (x, go t')

-- |Splits a 'Topic' into two 'Topic's: the elements of the first
-- 'Topic' all satisfy the given predicate, while none of the elements
-- of the second 'Topic' do.
partition :: (a -> Bool) -> Topic IO a -> IO (Topic IO a, Topic IO a)
partition p = fmap (filter p *** filter (not . p)) . tee

-- |Returns a 'Topic' whose values are consecutive values from the
-- original 'Topic'.
consecutive :: Monad m => Topic m a -> Topic m (a,a)
consecutive = metamorph startup
  where startup x = skip (go x)
        go x y    = yield (x,y) (go y)
-- consecutive t = Topic $ do (x, t') <- runTopic t
--                            runTopic $ go x t'
--   where go x t' = Topic$ do (y, t'') <- runTopic t'
--                             return ((x,y), go y t'')

-- |Interleave two 'Topic's. Items from each component 'Topic' will be
-- tagged with an 'Either' constructor and added to the combined
-- 'Topic' as they become available.
(<+>) :: Topic IO a -> Topic IO b -> Topic IO (Either a b)
(<+>) t1 t2 = Topic $ do c <- newChan
                         let aux = do x <- readChan c
                                      return (x, Topic aux)
                             feed t = do (x,t') <- runTopic t
                                         writeChan c x
                                         feed t'
                         _ <- forkIO $ feed (fmap Left t1)
                         _ <- forkIO $ feed (fmap Right t2)
                         aux
infixl 7 <+>

-- |Returns a 'Topic' that produces a new pair every time either of
-- the component 'Topic's produces a new value. The value of the
-- other element of the pair will be the newest available value. The
-- resulting 'Topic' will produce a new value at the rate of the
-- faster component 'Topic', and may contain duplicate consecutive
-- elements.
-- what happens if there  is no newest available value for a topic,
-- because nothing was received so far on that topic?
-- experiments seem to suggest that no messages are sent until
-- both the topics receive at least one message.
everyNew :: Topic IO a -> Topic IO b -> Topic IO (a,b)
everyNew t1 t2 = Topic $ warmup =<< runTopic (t1 <+> t2)
  where warmup (Left x, t)     = warmupR x =<< runTopic t
        warmup (Right y, t)    = warmupL y =<< runTopic t
        warmupR _ (Left x, t)  = warmupR x =<< runTopic t
        warmupR x (Right y, t) = return ((x,y), Topic $ runTopic t >>= go x y)
        warmupL _ (Right y, t) = warmupL y =<< runTopic t
        warmupL y (Left x, t)  = return ((x,y), Topic $ runTopic t >>= go x y)
        go _ y (Left x, t)     = return ((x,y), Topic $ runTopic t >>= go x y)
        go x _ (Right y, t)    = return ((x,y), Topic $ runTopic t >>= go x y)

-- |Returns a 'Topic' that produces a new pair every time both of the
-- component 'Topic's have produced a new value. The composite
-- 'Topic' will produce pairs at the rate of the slower component
-- 'Topic' consisting of the most recent value from each 'Topic'.
bothNew :: Topic IO a -> Topic IO b -> Topic IO (a,b)
bothNew t1 t2 = Topic $ warmup =<< runTopic (t1 <+> t2)
  where warmup (v,t) = go v =<< runTopic t
        go (Left _) (l@(Left _), t) = go l =<< runTopic t
        go (Left x) (Right y, t) = return ((x,y), Topic $ warmup =<< runTopic t)
        go (Right _) (r@(Right _), t) = go r =<< runTopic t
        go (Right y) (Left x, t) = return ((x,y), Topic $ warmup =<< runTopic t)

-- |Returns a 'Topic' that produces a new pair every time a value of
-- first topic produces a new value, followed by a new value from the
-- second topic. This can be used for sampling the first topic with
-- the second topic.
firstThenSecond :: Topic IO a -> Topic IO b -> Topic IO (a,b)
firstThenSecond t1 t2 = leftThenRight (t1 <+> t2)

-- |Produces a value when a Left value is followed by a Right value.
leftThenRight :: (Monad m) => Topic m (Either a b) -> Topic m (a,b)
leftThenRight t1 = Topic $ warmup =<< runTopic t1
    where warmup (v,t) = go v =<< runTopic t
          go (Left x) (Right y, t) = return ((x,y), Topic $ warmup =<< runTopic t)
          go _ (x, t) = go x =<< runTopic t

-- |Merge two 'Topic's into one. The items from each component
-- 'Topic' will be added to the combined 'Topic' as they become
-- available.
merge :: Topic IO a -> Topic IO a -> Topic IO a
merge t1 t2 = either id id <$> t1 <+> t2

-- |Apply a function to each consecutive pair of elements from a 'Topic'.
finiteDifference :: (Functor m, Monad m) => (a -> a -> b) -> Topic m a -> Topic m b
finiteDifference f = fmap (uncurry f) . consecutive

-- |Compute a running \"average\" of a 'Topic' using a user-provided
-- normalization function applied to the sum of products. The
-- arguments are a constat @alpha@ that is used to scale the current
-- average, a constant @invAlpha@ used to scale the newest value, a
-- function for adding two scaled values, a function for scaling
-- input values, a function for normalizing the sum of scaled values,
-- and finally the stream to average. Parameterizing over all the
-- arithmetic to this extent allows for the use of denormalizing
-- scaling factors, as might be used to keep all arithmetic
-- integral. An example would be scaling the average by the integer
-- 7, the new value by the integer 1, then normalizing by dividing
-- the sum of scaled values by 8.
weightedMeanNormalized :: Monad m =>
                          n -> n -> (b -> b -> c) -> (n -> a -> b) ->
                          (c -> a) -> Topic m a -> Topic m a
weightedMeanNormalized alpha invAlpha plus scale normalize = Topic . warmup
    where warmup = uncurry go <=< runTopic
          go avg t = do (x,t') <- runTopic t
                        let !avg' = normalize $ plus (scale alpha avg)
                                                     (scale invAlpha x)
                        return (avg', Topic $ go avg' t')
{-# INLINE weightedMeanNormalized #-}

-- |Perform numerical integration of a 'Topic' using Simpson's rule
-- applied at three consecutive points. This requires a function for
-- adding values from the 'Topic', and a function for scaling values
-- by a fractional number.
simpsonsRule :: (Monad m, Fractional n) =>
                (a -> a -> a) -> (n -> a -> a) -> Topic m a -> Topic m a
simpsonsRule plus scale t0 = Topic $ do ([x,y], t') <- splitAt 2 t0
                                        go x y t'
  where go x y t = do (z,t') <- runTopic t
                      return (simpson x y z, Topic $ go y z t')
        simpson a mid b = scale c $ plus (plus a (scale 4 mid)) b
        c = 1 / 3
{-# INLINE simpsonsRule #-}

-- |Compute a running \"average\" of a 'Topic'. The application
-- @weightedMean alpha plus scale t@ sums the product of @alpha@ and
-- the current average with the product of @1 - alpha@ and the newest
-- value produced by 'Topic' @t@. The addition and scaling operations
-- are performed using the supplied @plus@ and @scale@ functions.
weightedMean :: (Monad m, Num n) =>
                n -> (a -> a -> a) -> (n -> a -> a) -> Topic m a -> Topic m a
weightedMean alpha plus scale = weightedMean2 alpha (1 - alpha) plus scale
{-# INLINE weightedMean #-}

-- |Compute a running \"average\" of a 'Topic'. The application
-- @weightedMean2 alpha invAlpha plus scale t@ sums the product of
-- @alpha@ and the current average with the product of @invAlpha@ and
-- the newest value produced by 'Topic' @t@. The addition and scaling
-- operations are performed using the supplied @plus@ and @scale@
-- functions.
weightedMean2 :: Monad m =>
                 n -> n -> (a -> a -> a) -> (n -> a -> a) -> Topic m a -> Topic m a
weightedMean2 alpha invAlpha plus scale = Topic . warmup
    where warmup = uncurry go <=< runTopic
          go avg t = do (x, t') <- runTopic t
                        let !savg = scale alpha avg
                            !sx = scale invAlpha x
                            !avg' = plus savg sx
                        return (avg', Topic $ go avg' t')
{-# INLINE weightedMean2 #-}

-- |Use a 'Topic' of functions to filter a 'Topic' of values. The
-- application @filterBy t1 t2@ causes each function from 'Topic' @t1@
-- to be applied to values produced by @t2@ until it returns
-- 'True'. At that point, the 'filterBy' application produces the
-- accepted value of the @t2@ and moves on to the next function from
-- @t1@ which is applied to the rest of @t2@ in the same manner.
filterBy :: Monad m => Topic m (a -> Bool) -> Topic m a -> Topic m a
filterBy tf tx = Topic $ do (f, tf') <- runTopic tf
                            (x, tx') <- uncons $ dropWhile (not . f) tx
                            return (x, filterBy tf' tx')

-- |Produce elements of the first 'Topic' no faster than elements of
-- the second 'Topic' are produced.
gate :: (Applicative m, Monad m) => Topic m a -> Topic m b -> Topic m a
gate t1 t2 = const <$> t1 <*> t2

-- |Flatten a 'Topic' of 'F.Foldable' values. For example, turn a
-- @Topic m [a]@ of finite lists into a @Topic a@ by taking each
-- element from each list in sequence.
concats :: (Monad m, F.Foldable f) => Topic m (f a) -> Topic m a
concats t = Topic $ do (x, t') <- runTopic t
                       F.foldr (\x' z -> return (x', Topic z))
                               (runTopic $ concats t')
                               x

-- |Flatten a 'Topic' of 'F.Foldable' values such that old values are
-- discarded as soon as the original 'Topic' produces a new
-- 'F.Foldable'.
interruptible :: F.Foldable t => Topic IO (t a) -> Topic IO a
interruptible s = Topic $
    do feeder <- newEmptyMVar         -- Active feeder thread
       latestItem <- newEmptyMVar     -- Next available item
       signal <- newEmptyMVar         -- Demand signal
       let feedItems ys = do ft <- tryTakeMVar feeder
                             maybe (return ()) killThread ft
                             t <- forkIO $
                                  F.traverse_ (\y -> takeMVar signal >>
                                                     putMVar latestItem y)
                                              ys
                             putMVar feeder t
           watchForItems t = do (x,t') <- runTopic t
                                feedItems x
                                watchForItems t'
           getAll = do putMVar signal ()
                       x <- takeMVar latestItem
                       return (x, Topic getAll)
       _ <- forkIO $ watchForItems s
       getAll

-- |Pull elements from a 'Topic' in a new thread. This allows 'IO'
-- 'Topic's to run at different rates even if they are consumed by a
-- single thread.
forkTopic :: Topic IO a -> IO (Topic IO a)
forkTopic t = do c <- newChan
                 _ <- forkIO . forever . join $ fmap (writeChan c) t
                 let feed = Topic $ (\x -> (x,feed)) <$> readChan c
                 return feed

-- |Sliding window over a 'Monoid'. @slidingWindow n t@ slides a
-- window of width @n@ along 'Topic' @t@. As soon as at least @n@
-- elements have been produced by @t@, the output 'Topic' starts
-- producing the 'mconcat' of the elements in the window.
slidingWindow :: (Monad m, Monoid a) => Int -> Topic m a -> Topic m a
slidingWindow n = metamorph (fill S.empty)
  where fill w x
          | S.length w < n - 1 = skip . fill $ w |> x
          | otherwise = let w' = w |> x
                        in yield (F.fold w') (go w')
        go w x = let w' = dropOldest w |> x
                 in yield (F.fold w') (go w')
        dropOldest w = case viewl w of
                         EmptyL -> S.empty
                         _ :< w' -> w'

-- |Sliding window over an 'AdditiveGroup'. @slidingWindowG n t@
-- slides a window of width @n@ along 'Topic' @t@. As soon as at least
-- @n@ elements have been produced by @t@, the output 'Topic' starts
-- producing the total sum of the elements of the window. This
-- function is more efficient than 'slidingWindow' because the group
-- inverse operation is used to remove elements falling behind the
-- window from the running sum.
slidingWindowG :: (Monad m, AdditiveGroup a) => Int -> Topic m a -> Topic m a
slidingWindowG n = metamorph (fill S.empty)
  where fill w x
          | S.length w < n - 1 = skip . fill $ w |> x
          | otherwise = let w' = w |> x
                            s = getSum . F.fold . fmap Sum $ w'
                        in yield s (go s w')
        go s w x = case viewl w of
                     EmptyL -> yield x $ go x (S.singleton x)
                     y :< w' -> let s' = s ^+^ x ^-^ y
                                in yield s' $ go s' (w' |> x)

-- |A way of pushing a monadic action into and along a 'Topic'. The
-- application @topicOn proj inj trans t@ extracts a function from
-- @trans@ that is then applied to the result of applying @proj@ to
-- each value of 'Topic' @t@. The result of that application is
-- supplied to the result of applying @inj@ to the same values from
-- @t@ to produce a value for the output 'Topic'. A typical use case
-- is projecting out a field from the original 'Topic' @t@ using
-- @proj@ so that it may be modified by @trans@ and then injected back
-- into the original structure using @inj@.
topicOn :: (Applicative m, Monad m) =>
           (a -> b) -> (a -> c -> d) -> m (b -> m c) -> Topic m a -> Topic m d
topicOn proj inj trans t =
  Topic $ do f <- trans
             runTopic $ mapM (\x -> inj x `fmap` f (proj x)) t

-- |@subsample n t@ subsamples topic 't' by dropping 'n' elements for
-- every element produced by the result topic.
subsample :: Monad m => Int -> Topic m b -> Topic m b
subsample n = metamorph $ go n
  where go 0 x = yield x (go n)
        go i _ = skip (go (i - 1))


text:
/**************************************\
|------------COLOR SCHEME--------------|
|--------------------------------------|
- black		#000
- white		#fff
\**************************************/

/**************************************/
/*              GLOBALS               */
/**************************************/
body {margin:0;padding:0;background:#eee}
.normal {background:#eee}
.darker {background:#777 url(g/actionMin.png)}
.dark {background:#aaa url(g/actionMax.png)}
.lighter {background:#f6f6f6}
.left  {float:left}
.right {float:right}

/**************************************/
/*              HEADER                */
/**************************************/
#header {position:relative; width:950px; background:#f7f7f7; border:1px solid #bbb; margin:1em auto; padding:15px 0 0; -moz-box-shadow: 0pt 0pt 1em #bbb;}
#logo {background:url(g/logo.png) no-repeat; position:absolute; left:20px; top:0; width:122px; height:50px}
#title {display:none; padding-left:160px; color:#fff; font-size:1.5em; height:50px; line-height:50px; font-weight:bold; font-style:italic}

#info_bar {clear:left; color:#aaa; background-color:#fff; border-top:1px solid #bbb; padding:4px 6px; margin-top:15px; overflow:hidden; height:1.2em}
#info_bar .hint {display:none;padding:0 5px;line-height:16px}
#info_bar:hover .hint {display:inline}
#info_bar b {cursor:pointer;display:block;width:16px;height:16px;float:left}
#menu_btn {cursor:pointer;float:left;background:url(g/icon.gif)}
#loading {visibility:hidden;background:url(../img/loading.gif);margin-right:4px}
#maxAll {background:url(g/expandAll.png)}
#minAll {background:url(g/collapseAll.png)}

/**************************************/
/*             NAVIGATION             */
/**************************************/
/* JPolite Native Navigation Tab */
#main_nav {list-style-type:none; margin:0 0 0 160px; position:relative; height:25px}
#main_nav li {overflow:visible;float:left; width:6em; text-align:center; font-size:1.2em; font-weight:bold; height:2em; line-height:2em; color:#333;
				padding:0 1em; border-right:1px dotted #ccc;
				margin:0; cursor:pointer; white-space:nowrap; position:relative; z-index:9}
#main_nav .hover {opacity:0; filter:alpha(opacity=0); display:block; background:url(g/tabon.gif) repeat-x; position:absolute; left:0; top:0; width:100%; height:100%; text-align:center; margin:0;color:#333}
#main_nav li.on {color:#c23;}
#main_nav li.on .hover {color:#e33}
#main_nav li:hover {color:#e33}
#main_nav li.backLava {background:#f2a04E; padding:0; position:absolute; z-index:1; border:0}
#main_nav li span:after {content:url(g/expandAll.png)}
#main_nav li dl {display:none; background:#777; width:200px; color:#eee; margin-left:-1em}
#main_nav li dd {text-align:left; padding:0 5px}
#main_nav li dd.on {border:1px solid #f73}
#main_nav li dd.on:before {content:"»  "}
#main_nav li dd:hover {background:#555; text-align:left; padding:0 5px}
#main_nav li:hover dl {display:block}
/**************************************/
/*            MAIN CONTENT            */
/**************************************/
#content {
	/*
	 * width:950px ==> this is the default value set by bluetrip .container class
	 * You can adjust the width manually with a value = 950 +/- n*40
	 */
}
.module_template {display:none}
.cc {padding-bottom:1px}
.dragging {padding-bottom:20px; margin-bottom:10px; background:url(g/stripe1.png)}
.ui-sortable-placeholder { margin:10px 0; border: 1px dotted #f00; background:#faa; visibility: visible !important; height: 20px !important}

/* Module Components */
.module {background:#fff; margin-bottom:10px; border:1px solid #ddd; display:none; -moz-box-shadow:0pt 0pt 1em #bbb}
.module:hover {border-color: #bbb}
.max {float:none !important; width:100% !important}
.min {display:none}
.moduleFrame {border:0; overflow:hidden;}
.moduleHeader {margin:10px; padding:2px; background:#888; color:#fff; cursor:move; overflow:hidden;
				border-width:1px; border-style:solid; border-color: #777 #eee #eee #777}
.moduleTitle {background:url(g/icon.gif) no-repeat; height:1.4em; line-height:1.4em; float:left; padding-left:18px; font-weight:bold}
.moduleActions {display:none; float:right}
.moduleActions b {cursor:pointer;width:16px;height:16px;display:block;float:left}
	.actionRefresh {background:url('g/actionRefresh.png')}
	.moduleActions .actionMax {display:none;background:url('g/actionMax.png')}
	.actionMin {background:url('g/actionMin.png')}
	.actionClose	{background:url('g/actionClose.png')}
.moduleHeader:hover .moduleActions {display:block}
.moduleContent {background:#fff; margin:10px}

/* Simple Theme for Modules */
.red .moduleHeader{background:#e24e61 url(g/module-orange.gif) repeat-x; border-color:#c94758 #F6A7B8 #F6A7B8 #c94758}
.orange .moduleHeader{background:#E2584E url(g/module-red.gif) repeat-x; border-color:#c94f47 #F6A7A8 #F6A7A8 #c94f47}
.yellow .moduleHeader{background:#E2904E url(g/module-yellow.gif) repeat-x; border-color:#c98147 #F6C4A7 #F6C4A7 #c98147}
.green .moduleHeader{background:#66B161 url(g/module-green.gif) repeat-x; border-color:#579653 #ABCFA5 #ABCFA5 #579653}
.blue .moduleHeader{background:#4E8EE2 url(g/module-header.gif) repeat-x; }
.white .moduleHeader{background:#9E9E9E url(g/module-white.gif) repeat-x; border-color:#888 #D9D9D9 #D9D9D9 #888}

/**************************************/
/*               CONTROLS             */
/**************************************/
/* Tabs Control */
.tabs {border:1px solid #ccc}
.tabsul {overflow:hidden;padding-top:1px;background:#ccc; list-style-type:none; margin:0}
.tabsul li {float:left; font-weight:bold; color:#777; background:#fff; border:1px solid #bbb; text-align:center; margin-left:2px; padding:4px 6px; cursor:pointer; white-space:nowrap}
.tabsul li:hover {background:#f0f0f0;color:#333}
.tabsul li.on {background:#fff url(g/tabon.gif) repeat-x; border-bottom-color:#fff; color:#333; padding-bottom:6px}
.tabsdiv {padding:4px; background:#fff}

/* Accordion Control */
.accordion {background:#ccc; padding:1px 3px 3px; margin:0}
.accordion dt {background:#fff;font-weight:bold; color:#777; border:1px solid #bbb; padding:4px 6px; cursor:pointer; margin:2px 0 0}
.accordion dt:hover {background:#f0f0f0;color:#333}
.accordion dt.on {background:url(g/tabon.gif) repeat-x; color:#333}
.accordion dd {background:#fff; overflow-x:auto; padding:3px; border-width:0px 1px 1px 1px; border-style:solid; border-color:#bbb; display:none}

.menu li {cursor:pointer}
.menu li:hover {background:#ddd}
.menu li.on {background:#aaa}
/**************************************/
/*               FOOTER               */
/**************************************/
#footer {margin:1em auto; border:1px solid #bbb; color:#777; bottom:0; width:950px; height:5em; background:#f7f7f7; text-align:center; -moz-box-shadow: 0pt 0pt 1em #bbb;}
#footer_bar {color:#999; border-bottom:1px solid #ccc; padding:4px 6px; height:1.2em; margin-bottom:10px; background:#fff}
#footer_bar a {color:#999}
#footer_bar a:hover {color:#333}


text:
<!DOCTYPE html>

        <title><%- contestTitle %> :: Team :: Restore password</title>

        <meta charset="utf-8">
        <meta name="viewport" content="width=device-width, initial-scale=1">
        <link rel="stylesheet" href="/assets/css/{{#cachebusting}}{{#volgactf_qualifier}}{{ css }}{{/volgactf_qualifier}}{{/cachebusting}}">
        {{#partials}}
        {{#head}}

        {{/head}}
        {{/partials}}

        <% if (google_tag_id) { %>
        <%= templates.analytics({ _: _, google_tag_id: google_tag_id }) %>
        <% } %>

        <%= templates.navbar({ _: _, active: null, identity: identity, templates: templates, contestTitle: contestTitle, contest: contest, moment: moment }) %>

            <% if (identity.role === 'guest') { %>
                <form class="volgactf-form-restore" method="POST" action="/api/team/restore" novalidate>

Restore password

                         If you have recently made a request to reset your account password, you may have to wait some time for an email to be delivered.

                        Email
                        <input type="email" id="restore-email" name="email" class="form-control" placeholder="Email" required autofocus>

                    <button class="btn btn-lg btn-primary btn-block" type="submit">Restore</button>
                </form>

Restore password

                        You will receive an email with further instructions.

            <% } else { %>

Already authenticated

You have already authenticated. Please navigate to another page.

            <% } %>

            {{#partials}}
            {{#footer}}

            {{/footer}}
            {{^footer}}

            {{/footer}}
            {{/partials}}


text:
<?php

namespace Droath\ProjectX\Project\Command;

use Droath\ProjectX\CommandBuilder;

/**
 * Define the symlink command.
 */
class SymlinkCommand extends CommandBuilder
{
    const DEFAULT_EXECUTABLE = 'ln';

    /**
     * Symlink command constructor.
     *
     * @param null $executable
     * @param bool $localhost
     */
    public function __construct($executable = null, bool $localhost = false)
    {
        parent::__construct($executable, $localhost);
        $this->setOption('-s');
    }

    /**
     * Link the source to the target.
     *
     * @param $source
     *   The source path.
     * @param $target
     *   The target path.
     *
     * @return $this
     */
    public function link($source, $target)
    {
        $this->command("$source $target");

        return $this;
    }
}


text:
//#define LOG_TRACE_INFO
//#define LOG_EXTRA_INFO

using UnityEngine;
using UnityEngine.UI;
using System.Collections;

//------------------------------------------------------------------------------
// class definition
//------------------------------------------------------------------------------
public class StartMenuController : MonoBehaviour
{
	public Canvas quitMenu;
	public Button startButton;
	public Button exitButton;

	private static StartMenuController menuController;

	//--------------------------------------------------------------------------
	// public static methods
	//--------------------------------------------------------------------------
	public void ShowQuitMenu(){
		quitMenu.enabled=true;
		startButton.enabled=false;
		exitButton.enabled=false;
	}

	public void LeaveQuitMenu(){
		quitMenu.enabled=false;
		startButton.enabled=true;
		exitButton.enabled=true;
	}

	public void StartPlaying(){
		MainController.SwitchScene("Game Scene");
	}

	public void QuitGame(){
		Application.Quit();
	}
	//--------------------------------------------------------------------------
	// protected mono methods
	//--------------------------------------------------------------------------
	protected void Awake()
	{
		menuController = this;
	}

	protected void OnDestroy()
	{
		if(menuController != null)
		{
			menuController = null;
		}
	}

	protected void OnDisable()
	{
	}

	protected void OnEnable()
	{
	}

	protected void Start()
	{
		quitMenu.enabled=false;
	}

	protected void Update()
	{

	}

	//--------------------------------------------------------------------------
	// private methods
	//--------------------------------------------------------------------------
}


text:
package io.sgr.telegram.bot.api.models;

import static com.google.common.base.Preconditions.checkArgument;
import static com.google.common.base.Strings.isNullOrEmpty;

import io.sgr.telegram.bot.api.utils.JsonUtil;

import com.fasterxml.jackson.annotation.JsonCreator;
import com.fasterxml.jackson.annotation.JsonIgnoreProperties;
import com.fasterxml.jackson.annotation.JsonInclude;
import com.fasterxml.jackson.annotation.JsonProperty;

/**
 * @author SgrAlpha
 */
@JsonIgnoreProperties(ignoreUnknown = true)
@JsonInclude(JsonInclude.Include.NON_NULL)
public class Document {

    private final String fileId;
    private final String fileUniqueId;
    private final PhotoSize thumb;
    private final String fileName;
    private final String mimeType;
    private final long fileSize;

    /**
     * @param fileId Unique identifier for this file.
     * @param fileUniqueId Unique identifier for this file, which is supposed to be the same over time and for different bots. Can't be used to download or
     * reuse the file.
     * @param thumb Optional. Document thumbnail as defined by sender.
     * @param fileName Optional. Original filename as defined by sender.
     * @param mimeType Optional. MIME type of the file as defined by sender.
     * @param fileSize Optional. File size
     */
    @JsonCreator
    public Document(
            @JsonProperty("file_id") final String fileId,
            @JsonProperty("file_unique_id") final String fileUniqueId,
            @JsonProperty("thumb") final PhotoSize thumb,
            @JsonProperty("file_name") final String fileName,
            @JsonProperty("mime_type") final String mimeType,
            @JsonProperty("file_size") final long fileSize) {
        checkArgument(!isNullOrEmpty(fileId), "File ID should be provided");
        this.fileId = fileId;
        checkArgument(!isNullOrEmpty(fileUniqueId), "File unique ID should be provided");
        this.fileUniqueId = fileUniqueId;
        this.thumb = thumb;
        this.fileName = fileName;
        this.mimeType = mimeType;
        this.fileSize = fileSize;
    }

    @JsonProperty("file_id")
    public String getFileId() {
        return fileId;
    }

    @JsonProperty("file_unique_id")
    public String getFileUniqueId() {
        return fileUniqueId;
    }

    @JsonProperty("thumb")
    public PhotoSize getThumb() {
        return thumb;
    }

    @JsonProperty("file_name")
    public String getFileName() {
        return fileName;
    }

    @JsonProperty("mime_type")
    public String getMimeType() {
        return mimeType;
    }

    @JsonProperty("file_size")
    public long getFileSize() {
        return fileSize;
    }

    public String toJson() {
        return JsonUtil.toJson(this);
    }

    @Override
    public String toString() {
        return this.toJson();
    }

}


text:
module Aaron

  module Errors

    class ConfigFileNotFound < Exception
    end

  end

end


text:
import typing as t
import warnings

from .response import Response

class _FakeSubclassCheck(type):
    def __subclasscheck__(cls, subclass: t.Type) -> bool:
        warnings.warn(
            "'BaseResponse' is deprecated and will be removed in"
            " Werkzeug 2.1. Use 'issubclass(cls, Response)' instead.",
            DeprecationWarning,
            stacklevel=2,
        )
        return issubclass(subclass, Response)

    def __instancecheck__(cls, instance: t.Any) -> bool:
        warnings.warn(
            "'BaseResponse' is deprecated and will be removed in"
            " Werkzeug 2.1. Use 'isinstance(obj, Response)' instead.",
            DeprecationWarning,
            stacklevel=2,
        )
        return isinstance(instance, Response)

class BaseResponse(Response, metaclass=_FakeSubclassCheck):
    def __init__(self, *args: t.Any, **kwargs: t.Any) -> None:
        warnings.warn(
            "'BaseResponse' is deprecated and will be removed in"
            " Werkzeug 2.1. 'Response' now includes the functionality"
            " directly.",
            DeprecationWarning,
            stacklevel=2,
        )
        super().__init__(*args, **kwargs)


text:
package org.jboss.resteasy.reactive.client.impl;

import java.lang.reflect.Type;
import java.net.URI;
import java.util.HashMap;
import java.util.Map;
import java.util.concurrent.CompletableFuture;
import java.util.concurrent.Future;
import java.util.function.BiConsumer;
import java.util.function.Function;

import javax.ws.rs.client.AsyncInvoker;
import javax.ws.rs.client.CompletionStageRxInvoker;
import javax.ws.rs.client.Entity;
import javax.ws.rs.client.InvocationCallback;
import javax.ws.rs.core.GenericType;
import javax.ws.rs.core.Response;

import org.jboss.resteasy.reactive.RestResponse;
import org.jboss.resteasy.reactive.common.jaxrs.ConfigurationImpl;
import org.jboss.resteasy.reactive.common.util.types.Types;
import org.jboss.resteasy.reactive.spi.ThreadSetupAction;

import io.vertx.core.buffer.Buffer;
import io.vertx.core.http.HttpClient;

public class AsyncInvokerImpl implements AsyncInvoker, CompletionStageRxInvoker {

    public static final Buffer EMPTY_BUFFER = Buffer.buffer(new byte[0]);

    final HttpClient httpClient;
    final URI uri;
    final RequestSpec requestSpec;
    final ConfigurationImpl configuration;
    final Map<String, Object> properties;
    final ClientImpl restClient;
    final HandlerChain handlerChain;
    final ThreadSetupAction requestContext;

    public AsyncInvokerImpl(ClientImpl restClient, HttpClient httpClient, URI uri, RequestSpec requestSpec,
            ConfigurationImpl configuration,
            Map<String, Object> properties, HandlerChain handlerChain,
            ThreadSetupAction requestContext) {
        this.restClient = restClient;
        this.httpClient = httpClient;
        this.uri = uri;
        this.requestSpec = new RequestSpec(requestSpec);
        this.configuration = configuration;
        this.properties = new HashMap<>(properties);
        this.handlerChain = handlerChain;
        this.requestContext = requestContext;
    }

    public Map<String, Object> getProperties() {
        return properties;
    }

    @Override
    public CompletableFuture<Response> get() {
        return method("GET");
    }

    @Override
    public <T> CompletableFuture<T> get(Class<T> responseType) {
        return method("GET", responseType);
    }

    @Override
    public <T> CompletableFuture<T> get(GenericType<T> responseType) {
        return method("GET", responseType);
    }

    @Override
    public <T> CompletableFuture<T> get(InvocationCallback<T> callback) {
        return method("GET", callback);
    }

    @Override
    public CompletableFuture<Response> put(Entity<?> entity) {
        return method("PUT", entity);
    }

    @Override
    public <T> CompletableFuture<T> put(Entity<?> entity, Class<T> responseType) {
        return method("PUT", entity, responseType);
    }

    @Override
    public <T> CompletableFuture<T> put(Entity<?> entity, GenericType<T> responseType) {
        return method("PUT", entity, responseType);
    }

    @Override
    public <T> CompletableFuture<T> put(Entity<?> entity, InvocationCallback<T> callback) {
        return method("PUT", entity, callback);
    }

    @Override
    public CompletableFuture<Response> post(Entity<?> entity) {
        return method("POST", entity);
    }

    @Override
    public <T> CompletableFuture<T> post(Entity<?> entity, Class<T> responseType) {
        return method("POST", entity, responseType);
    }

    @Override
    public <T> CompletableFuture<T> post(Entity<?> entity, GenericType<T> responseType) {
        return method("POST", entity, responseType);
    }

    @Override
    public <T> CompletableFuture<T> post(Entity<?> entity, InvocationCallback<T> callback) {
        return method("POST", entity, callback);
    }

    @Override
    public CompletableFuture<Response> delete() {
        return method("DELETE");
    }

    @Override
    public <T> CompletableFuture<T> delete(Class<T> responseType) {
        return method("DELETE", responseType);
    }

    @Override
    public <T> CompletableFuture<T> delete(GenericType<T> responseType) {
        return method("DELETE", responseType);
    }

    @Override
    public <T> CompletableFuture<T> delete(InvocationCallback<T> callback) {
        return method("DELETE", callback);
    }

    @Override
    public CompletableFuture<Response> head() {
        return method("HEAD");
    }

    @Override
    public Future<Response> head(InvocationCallback<Response> callback) {
        return method("HEAD", callback);
    }

    @Override
    public CompletableFuture<Response> options() {
        return method("OPTIONS");
    }

    @Override
    public <T> CompletableFuture<T> options(Class<T> responseType) {
        return method("OPTIONS", responseType);
    }

    @Override
    public <T> CompletableFuture<T> options(GenericType<T> responseType) {
        return method("OPTIONS", responseType);
    }

    @Override
    public <T> CompletableFuture<T> options(InvocationCallback<T> callback) {
        return method("OPTIONS", callback);
    }

    @Override
    public CompletableFuture<Response> trace() {
        return method("TRACE");
    }

    @Override
    public <T> CompletableFuture<T> trace(Class<T> responseType) {
        return method("TRACE", responseType);
    }

    @Override
    public <T> CompletableFuture<T> trace(GenericType<T> responseType) {
        return method("TRACE", responseType);
    }

    @Override
    public <T> CompletableFuture<T> trace(InvocationCallback<T> callback) {
        return method("TRACE", callback);
    }

    @Override
    public CompletableFuture<Response> method(String name) {
        return performRequestInternal(name, null, null);
    }

    @Override
    public <T> CompletableFuture<T> method(String name, Class<T> responseType) {
        return mapResponse(performRequestInternal(name, null, new GenericType<>(responseType)), responseType);
    }

    @Override
    public <T> CompletableFuture<T> method(String name, GenericType<T> responseType) {
        return mapResponse(performRequestInternal(name, null, responseType), responseType.getRawType());
    }

    @Override
    public <T> CompletableFuture<T> method(String name, InvocationCallback<T> callback) {
        return method(name, null, callback);
    }

    @Override
    public CompletableFuture<Response> method(String name, Entity<?> entity) {
        return performRequestInternal(name, entity, null);
    }

    @Override
    public <T> CompletableFuture<T> method(String name, Entity<?> entity, Class<T> responseType) {
        CompletableFuture<Response> response = performRequestInternal(name, entity, new GenericType<>(responseType));
        return mapResponse(response, responseType);
    }

    @Override
    public <T> CompletableFuture<T> method(String name, Entity<?> entity, GenericType<T> responseType) {
        //we default to String if no return type specified
        CompletableFuture<Response> response = performRequestInternal(name, entity,
                responseType == null ? new GenericType<>(String.class) : responseType);
        return mapResponse(response, responseType == null ? String.class : responseType.getRawType());
    }

    @SuppressWarnings("unchecked")
    @Override
    public <T> CompletableFuture<T> method(String name, Entity<?> entity, InvocationCallback<T> callback) {
        GenericType<Object> genericType = new GenericType<>(getInvocationCallbackType(callback));
        CompletableFuture<T> cf;
        if (genericType.getRawType().equals(Response.class)) {
            cf = (CompletableFuture<T>) performRequestInternal(name, entity, null);
        } else {
            cf = mapResponse(performRequestInternal(name, entity, genericType), genericType.getRawType());
        }

        cf.whenComplete(new BiConsumer<T, Throwable>() {
            @Override
            public void accept(T t, Throwable throwable) {
                if (throwable != null) {
                    callback.failed(throwable);
                } else {
                    callback.completed(t);
                }
            }
        });

        return cf;
    }

    @SuppressWarnings({ "rawtypes", "unchecked" })
    private <T> CompletableFuture<Response> performRequestInternal(String httpMethodName, Entity<?> entity,
            GenericType<?> responseType) {
        return (CompletableFuture) performRequestInternal(httpMethodName, entity, responseType, true).getResult();
    }

    RestClientRequestContext performRequestInternal(String httpMethodName, Entity<?> entity, GenericType<?> responseType,
            boolean registerBodyHandler) {
        RestClientRequestContext restClientRequestContext = new RestClientRequestContext(restClient, httpClient, httpMethodName,
                uri, requestSpec.configuration, requestSpec.headers,
                entity, responseType, registerBodyHandler, properties, handlerChain.createHandlerChain(configuration),
                handlerChain.createAbortHandlerChain(configuration),
                handlerChain.createAbortHandlerChainWithoutResponseFilters(), requestContext);
        restClientRequestContext.run();
        return restClientRequestContext;
    }

    private <T> Type getInvocationCallbackType(InvocationCallback<T> callback) {
        Class<?> knownFromBuildTime = restClient.getClientContext().getGenericTypeMapping()
                .forInvocationCallback(callback.getClass());
        if (knownFromBuildTime != null) {
            return knownFromBuildTime;
        }

        Type[] typeInfo = Types.getActualTypeArgumentsOfAnInterface(callback.getClass(), InvocationCallback.class);
        if (typeInfo.length == 1) {
            return typeInfo[0];
        }
        return null;
    }

    @SuppressWarnings("unchecked")
    public <T> CompletableFuture<T> mapResponse(CompletableFuture<Response> res, Class<?> responseType) {
        if (responseType.equals(Response.class)) {
            return (CompletableFuture<T>) res;
        } else if (responseType.equals(RestResponse.class)) {
            return res.thenApply(new Function<>() {
                @Override
                public T apply(Response response) {
                    return (T) RestResponse.ResponseBuilder.create(response.getStatusInfo(), response.getEntity())
                            .replaceAll(response.getHeaders()).build();
                }
            });
        } else {
            return res.thenApply(new Function<>() {
                @Override
                public T apply(Response response) {
                    return (T) response.getEntity();
                }
            });
        }

    }
}


text: export { default } from 'ember-g-map/components/g-map-route-waypoint';