text:
#ifndef GO_PLANEPRIMITIVE_HPP
#define GO_PLANEPRIMITIVE_HPP

#include "rapter/primitives/planePrimitive.h"

// ________________________________________________________HPP_________________________________________________________

namespace rapter
{

    /*! \brief Creates plane primitive from an ordered local frame
     */
    inline PlanePrimitive::PlanePrimitive( Eigen::Matrix<Scalar,3,1> const& centroid, Eigen::Matrix<Scalar,3,1> const& eigen_values, Eigen::Matrix<Scalar, 3, 3> const& eigen_vectors )
    {
        // get eigen vector for biggest eigen value
        const int min_eig_val_id = std::distance( eigen_values.data(), std::min_element( eigen_values.data(), eigen_values.data()+3 ) );
        // set position
        _coeffs.template head<3>() = centroid;
        // set direction
        _coeffs.template segment<3>(3) = eigen_vectors.col(min_eig_val_id).normalized();
    }

    inline PlanePrimitive::PlanePrimitive( Eigen::Matrix<PlanePrimitive::Scalar, 3, 1> const& pnt,
                                           Eigen::Matrix<PlanePrimitive::Scalar, 3, 1> const& normal )
    {
        _coeffs.template head   <3>( ) = pnt;
        _coeffs.template segment<3>(3) = normal.normalized();
    }

    /*! \brief Called from \ref rapter::CandidateGenerator::generate to create a new candidate from this and \p other.
     *         Create back-rotated version of the other at this position.
     *  \param[out] out              Created output primitive.
     *  \param[in]  other            Primitive, who's direction we want to use to generate something at our location.
     *  \param[in]  closest_angle_id The id of closest perfect angle between us and \p other. This we want to rotate back by.
     *  \param[in]  angles           List of desired angles, one of its entries is referenced by closest_angle_id.
     *  \return \p out is only valid, if return true. We might decide, that there's nothing to create, in which case we return false.
     */
    template <class _AngleContainerT> inline bool
    PlanePrimitive::generateFrom( PlanePrimitive         & out
                                , PlanePrimitive    const& other
                                , int               const  closest_angle_id
                                , _AngleContainerT  const& angles
                                , Scalar            const  angle_multiplier /* = Scalar(1.) */
                                ) const
    {
        // if not 0 or M_PI, meaning not parallel
        if ( (closest_angle_id != 0) && (closest_angle_id != static_cast<int>(angles.size())-1) )
        {
            //std::cerr << "[" << __func__ << "]: " << "rotating plane by angle " << angles[closest_angle_id] << std::endl;
            //return false;
            //Scalar const angle = angles[ closest_angle_id ];
            Scalar angle = angles[ closest_angle_id ];
//#warning This has to be tested for angle sign
            out = PlanePrimitive( /*  position: */ this->pos()
                                , /* direction: */ Eigen::AngleAxisf( angle, other.dir().cross(dir()) ) * other.dir()
                                );
        }
        else
        {
            //Scalar const angle = angles[ closest_angle_id ];
            out = PlanePrimitive( /*  position: */ this->pos()
                                , /* direction: */ other.dir()
                                );
        }
        out.copyTagsFrom( *this );
        // copy position id from self
        //out.setTag( GID, this->getTag(GID) );
        // copy direction id from the other
        out.setTag( TAGS::DIR_GID, other.getTag(TAGS::DIR_GID) );
        // erase chosen tag - this is a new candidate
        out.setTag( TAGS::STATUS, STATUS_VALUES::UNSET );

        return true;
    } //...generateFrom

    template <typename DerivedT> inline int
    PlanePrimitive::generateFrom( PlanePrimitive                 & out
                                , DerivedT                  const& normal
                                , PlanePrimitive::Scalar    const  distanceFromOrigin )
    {
        out.coeffs().segment<3>(3) = normal.normalized();
        out.coeffs().segment<3>(0) = Eigen::Matrix<Scalar,3,1>::Zero() - normal * distanceFromOrigin;
        return EXIT_SUCCESS;
    } //...generatreFrom()

    /*! \brief                          Calculates the length of the plane based on the points in \p cloud, masked by \p indices and the distance from point to plane \p threshold.
     *
     *                                  The method calculates the inliers and selects the most far away point from #pos() in both directions.
     *  \tparam     _PointT             Point wrapper stored in _PointContainerT.
     *  \tparam     _PointContainerT    Type to store the points to select inliers from. Concept: std::vector<\ref rapter::PointPrimitive>. Depr: pcl::PointCloud< _PointT >::Ptr.
     *  \tparam     _IndicesContainerT  Concept: std::vector<int>.
     *  \param[out] minMax              Output container holding the four endpoints.
     *  \param[in]  cloud               Point container to look for inlier points in.
     *  \param[in]  threshold           A point in \p cloud is an inlier, if it is closer than this threshold. Usually the "scale".
     *  \param[in]  indices             Optional input to specify subset of points by indices.
     *  \return                         EXIT_SUCCESS
     */
    template <typename _PointPrimitiveT, class _IndicesContainerT, typename _PointContainerT>
    inline int
    PlanePrimitive::getExtent( ExtentsT                                      & minMax
                             , _PointContainerT                         const& cloud
                             , double                                   const  threshold          /*= 0.01*/
                             , _IndicesContainerT                       const* indices_arg        /*= NULL*/
                             , bool                                     const  force_axis_aligned /*= false */) const
    {
        typedef Eigen::Matrix<Scalar,3,1> Position;

        if ( this->_extents.isUpdated() )
        {
            minMax = _extents.get();
            return 0;
        }

#ifdef RAPTER_USE_PCL

        std::vector<LidT> inliers;
        {
            inliers.reserve( cloud.size() );
            const PidT stop_at = indices_arg ? indices_arg->size() : cloud.size();
            for ( PidT i = 0; i != stop_at; ++i )
            {
                const PidT pid = indices_arg ? (*indices_arg)[i] : i;
                if ( this->getDistance( cloud[pid].template pos() ) < threshold )
                    inliers.push_back( pid );
            }

            //std::cout << "[" << __func__ << "]: " << "indices.size(): " << stop_at << " / " << cloud.size() << std::endl;
        }

        // check size
        if ( !inliers.size() ) return EXIT_FAILURE;

        // project cloud
        _PointContainerT on_plane_cloud;
        //on_plane_cloud.reserve( inliers.size() );
        on_plane_cloud.resize( inliers.size() );
#       pragma omp parallel for num_threads(4)
        for ( UPidT pid_id = 0; pid_id < inliers.size(); ++pid_id )
        {
            on_plane_cloud[pid_id] = _PointPrimitiveT( this->projectPoint(cloud[ inliers[pid_id] ].template pos()),
                                                                          cloud[ inliers[pid_id] ].template dir()
                                                     );
        }

        Eigen::Matrix<Scalar,4,4> frame; // 3 major vectors as columns, and the fourth is the centroid
        {
            processing::PCA<_IndicesContainerT>( frame, on_plane_cloud, /* indices: */ NULL ); // no indices needed, already full cloud

            if ( force_axis_aligned )
            {
                // get the unit axis that is most perpendicular to the 3rd dimension of the frame
                std::pair<Position,Scalar> dim3( Position::Zero(), Scalar(FLT_MAX) );
                {
                    Scalar tmp;
                    if ( (tmp=std::abs(frame.col(2).template head<3>().dot( Position::UnitX() ))) < dim3.second ) { dim3.first = Position::UnitX(); dim3.second = tmp; }
                    if ( (tmp=std::abs(frame.col(2).template head<3>().dot( Position::UnitY() ))) < dim3.second ) { dim3.first = Position::UnitY(); dim3.second = tmp; }
                    if ( (tmp=std::abs(frame.col(2).template head<3>().dot( Position::UnitZ() ))) < dim3.second ) { dim3.first = Position::UnitZ(); dim3.second = tmp; }
                }
                frame.col(0).head<3>() = frame.col(2).head<3>().cross( dim3.first             ).normalized();
                frame.col(1).head<3>() = frame.col(2).head<3>().cross( frame.col(0).head<3>() ).normalized();
            }
            else
            {
#if 1
                Scalar step      = Scalar(1. * M_PI) / Scalar(180.);
                Scalar limits[2] = { -Scalar(M_PI_4), Scalar(M_PI_4) };
                for ( int it = 0; it != 2; ++it, step /= Scalar(5.) )
                {
                    std::pair <Scalar,Scalar> min_volume; // <ang, volume>
                    min_volume.first  = Scalar(-1.);
                    min_volume.second = Scalar(FLT_MAX);
                    int i = 0;
                    for ( Scalar ang = limits[0]; ang < limits[1]; ang += step, ++i )
                    {
                        //                std::cout << "rot by " << ang << ", step: " << step << std::endl;
                        // rotated frame
                        Eigen::Matrix4f tmp_frame = frame;

                        // rotate frame around up_vector by ang
                        Eigen::AngleAxisf rot( ang, tmp_frame.block<3,1>(0,2) );
                        tmp_frame.block<3,1>(0,0) = rot * tmp_frame.block<3,1>(0,0);
                        tmp_frame.block<3,1>(0,1) = rot * tmp_frame.block<3,1>(0,1);

                        // calculate volume
                        _PointContainerT local_cloud;
                        processing::cloud2Local<_PointPrimitiveT,_IndicesContainerT>( local_cloud, tmp_frame, on_plane_cloud, /* indices: */ NULL ); // no indices needed, it's already a full cloud

                        _PointPrimitiveT min_pt, max_pt;
                        processing::getMinMax3D<_IndicesContainerT>( min_pt, max_pt, local_cloud, /* indices: */ NULL );

                        Eigen::Vector3f diag    = max_pt.template pos() - min_pt.template pos();

                        //get location of minimum
                        Eigen::MatrixXf::Index minRow, minCol;
                        diag.minCoeff( &minRow, &minCol );
                        //                std::cout << "minRow: " << minRow << std::endl;
                        float volume = 0.;
                        if ( minRow == 1 )
                            volume = diag(0) * diag(2);
                        else if ( minRow )
                            volume = diag(0) * diag(1);
                        else
                            volume = diag(1) * diag(2);
                        // select min
                        if ( volume < min_volume.second )
                        {
                            min_volume.first  = ang;
                            min_volume.second = volume;
                        }
                    } // for caliper angles

                    // selected apply rotation
                    Eigen::AngleAxisf rot( min_volume.first, frame.block<3,1>(0,2) );
                    frame.block<3,1>(0,0) = rot * frame.block<3,1>(0,0);
                    frame.block<3,1>(0,1) = rot * frame.block<3,1>(0,1);

                    // modify lookup around chosen angle for next iteration
                    limits[0] = -step/2.f;
                    limits[1] = limits[0] + step;
                } //...for caliper levels
#endif
            } //calipers
        } //...estimate frame

        _PointContainerT local_cloud;
        processing::cloud2Local<_PointPrimitiveT,_IndicesContainerT>( local_cloud, frame, on_plane_cloud, /* indices: */ NULL ); // no indices needed, it's already a full cloud

        _PointPrimitiveT min_pt, max_pt;
        processing::getMinMax3D<_IndicesContainerT>( min_pt, max_pt, local_cloud, /* indices: */ NULL );

        minMax.resize( 4 );
        minMax[0]    = minMax[1] = min_pt.template pos();
        minMax[1](1)             = max_pt.template pos()(1);
        minMax[2]    = minMax[3] = max_pt.template pos();
        minMax[3](1)             = min_pt.template pos()(1);

        for ( int d = 0; d != 4; ++d )
        {
            // to world
            minMax[d] = (frame * (Eigen::Matrix<Scalar,4,1>() << minMax[d], Scalar(1)).finished()).template head<3>();
        }

        this->_extents.update( minMax );

        return EXIT_SUCCESS;
#           else
        std::cerr << "[" << __func__ << "]: " << "Needs PCL to work!!!!"
        return exit_FAILURE;
#           endif //...RAPTER_USE_PCL
    } //...getExtent()

    /*! \brief Calculates size, a bit smarter, than taking the area of #getExtent().
     *  \tparam MatrixDerived   Concept: Eigen::Matrix<_Scalar,-1,1>.
     */
    template <class _IndicesContainerT, typename MatrixDerived, typename _Scalar, class _PointContainerT >
    inline MatrixDerived&
    PlanePrimitive::getSpatialSignificance( MatrixDerived            & in
                                          , _PointContainerT    const& points
                                          , _Scalar             const /*scale*/
                                          , _IndicesContainerT       * indices       /*= NULL*/
                                          , bool                const return_squared /*= false */) const
    {
        _IndicesContainerT tmp_population,
                           *pop           = &tmp_population;
        if ( !indices )
            processing::getPopulationOf( tmp_population, this->getTag(TAGS::GID), points );
        else
            pop = indices;

        if ( !(pop->size()) )
        {
            std::cerr << "[" << __func__ << "]: " << "_____________NO points in primitive!!!!_____________" << std::endl;
            in.setConstant( _Scalar(-1.) );
        }
        in.setConstant( _Scalar(0.) );

        _PointContainerT projectedPoints;
        projectedPoints.reserve( points.size() );
        for ( UPidT pId = 0; pId != points.size(); ++pId )
        {
            projectedPoints.push_back( PointPrimitiveT(this->projectPoint(points[pId].template pos()), points[pId].template dir()) );
            projectedPoints.back().copyTagsFrom( points[pId] );
        }

#if 1 // biggest eigen value
        Eigen::Matrix<_Scalar,3,1> eigen_values;
        Eigen::Matrix<_Scalar,3,3> eigen_vectors;
        processing::eigenDecomposition( eigen_values, eigen_vectors, projectedPoints, pop );
        if ( return_squared )
            in(0) = eigen_values( 0 ) * eigen_values( 1 ); // added "* eigen_values(1)", changed by Aron on 240415
        else
            in(0) = std::sqrt( eigen_values(0) * eigen_values(1) );
#else // variance
        Eigen::Matrix<_Scalar,3,1> centroid = processing::getCentroid<_Scalar>( points, &population );
        for ( size_t pid_id = 0; pid_id != population.size(); ++pid_id )
        {
            const int pid = population[pid_id];
            std::cout << "[" << __func__ << "]: " << "\tadding " \
            "points[" << pid <<"].pos() (" << points[pid].template pos().transpose()
                      << " - " << centroid.transpose() << ").squaredNorm(): "
                      << (points[pid].template pos() - centroid).squaredNorm() << "\n";
            in(0) += (points[pid].template pos() - centroid).squaredNorm();
            std::cout << "\tin0 is now " << in(0) << std::endl;
        }
        in(0) /= _Scalar( population.size() );
#endif

        return in;
    } //...getSpatialSignificance()

    /*! \brief Draws the Plane from extrema
     *  \tparam PointsT Concept: std::vector<pcl::PointXYZ>.
     */
    template <class PointsT>
    inline int
    PlanePrimitive::draw( PointsT                               const&  corners
                        , pcl::visualization::PCLVisualizer::Ptr        v
                        , std::string                           const   plane_name
                        , double                                const   r
                        , double                                const   g
                        , double                                const   b
                        , int                                   const   viewport_id /* = 0 */
                        )
    {
#   ifdef RAPTER_USE_PCL
        if ( corners.size() != 4 )
        {
            std::cerr << "[" << __func__ << "]: " << "...cannot draw with not 4 corners" << std::endl;
            return EXIT_FAILURE;
        }
        Eigen::Vector3f centroid( Eigen::Vector3f::Zero() );
        for ( size_t corner_id = 0; corner_id != corners.size(); ++corner_id )
        {
            centroid += corners[corner_id].getVector3fMap();
        }
        centroid /= static_cast<float>(corners.size());

        // polygon containing the for corners spanning the plane's face
        pcl::PointCloud<pcl::PointXYZ>::Ptr plane_polygon_cloud_ptr( new pcl::PointCloud<pcl::PointXYZ> );

        //char title[255];
        for ( size_t corner_id = 0;
              corner_id < corners.size();
              ++corner_id )
        {
            plane_polygon_cloud_ptr->push_back( corners[corner_id] );
        }

//        #pragma omp critical PCLVIS
        {
            // draw plane polygon
            v->addPolygon<pcl::PointXYZ>( plane_polygon_cloud_ptr, r,g,b, plane_name, viewport_id );
            // v->setShapeRenderingProperties( pcl::visualization::PCL_VISUALIZER_OPACITY, .9, plane_name);
            v->setShapeRenderingProperties( pcl::visualization::PCL_VISUALIZER_REPRESENTATION, pcl::visualization::PCL_VISUALIZER_REPRESENTATION_SURFACE, plane_name );
        }

        // show normal
        /* if ( drawNormal )
        {
            v->addArrow( am::util::pcl::asPointXYZ( centroid + plane.Normal() * .2f ), // end point
                         am::util::pcl::asPointXYZ( centroid                        ), // start point
                         r*3., g*3., b*3.,
                         false,                                                                   // show length
                         std::string(title) + "_normal"                                                  // cloud id
                         , viewport_id );
        }

        // draw coorindate system
        if ( drawFrame )
        {
            for ( int axis_id = 0; axis_id < 3; ++axis_id )
            {
                char arrow_name[1024];
                sprintf( arrow_name, "_arrow%d", axis_id );

                v->addArrow( am::util::pcl::asPointXYZ( plane.Frame().block<3,1>(0,3) + plane.Frame().block<3,1>(0,axis_id).normalized() *.2f ), // end point
                             am::util::pcl::asPointXYZ( plane.Frame().block<3,1>(0,3)                             ), // start point
                             (2-axis_id  )%3 *.45 + .1,                                               // r
                             (2-axis_id+1)%3 *.45 + .1,                                               // g
                             (2-axis_id+2)%3 *.45 + .1,                                               // b
                             false,                                                                   // show length
                             std::string(title) + arrow_name                                          // cloud id
                             , viewport_id );
                //v->setShapeRenderingProperties( pcl::visualization::PCL_VISUALIZER_, 3., std::string(title) + arrow_name );
            }
        } */

        return EXIT_SUCCESS;
#   else
        return EXIT_FAILURE;
#   endif // RAPTER_USE_PCL
    } //...draw()

    /*! \brief Draws plane.
     * \tparam  _PointPrimitiveT   Concept: \ref rapter::PointPrimitive.
     * \tparam _PointContainerT   Concept: std::vector< _PointPrimitiveT >.
     * \tparam _IndicesContainerT Concept: std::vector<int>.
     */
    template <class _PointPrimitiveT, class _PointContainerT, class _IndicesContainerT>
    inline int
    PlanePrimitive::draw( PlanePrimitive                        const& plane
                        , _PointContainerT                      const& cloud
                        , Scalar                                const  radius
                        , _IndicesContainerT                    const* indices
                        , pcl::visualization::PCLVisualizer::Ptr       v
                        , std::string                           const& plane_name
                        , double                                const  r
                        , double                                const  g
                        , double                                const  b
                        , int                                   const  viewport_id  /* = 0*/
                        , Scalar                                const  stretch      /* = Scalar( 1. ) */
                        , int                                   const  draw_mode    /* = 0*/
                        , Scalar                                const  alpha        /* = 2.*/
                        )
    {
        int err     = EXIT_SUCCESS;
        //if ( stretch != Scalar(1.) )
        //    std::cerr << "[" << __func__ << "]: " << "WARNING, Stretch for planes is unimplemented!!!" << std::endl;

        typedef Eigen::Matrix<Scalar,3,1> Position;

        std::vector<Position> minMax;
        int      it          = 0;
        int      max_it      = 10;
        Scalar  tmp_radius  = radius;
        do
        {
            err = plane.getExtent<_PointPrimitiveT>( minMax
                                                   , cloud
                                                   , tmp_radius
                                                   , indices
                                                   , /* force_axis_aligned: */ (draw_mode == 1) /*true*/ );
            tmp_radius *= 2.f;
        } while ( (minMax.size() < 2) && (++it < max_it) );

        // if error or couldn't find a scale that was big enough to find "inliers"
        if ( (EXIT_SUCCESS != err) || (it >= max_it) )
        {
            std::cerr << "[" << __func__ << "]: " << "plane.getExtent exceeded max radius increase iteration count...drawing unit " << plane.toString() << std::endl;
            v->addPlane( *plane.modelCoefficients(), plane.pos()(0), plane.pos()(1), plane.pos()(2), plane_name, 0 );
        }
        else
        {
            std::vector<pcl::PointXYZ> ps;
            for ( size_t i = 0; i != minMax.size(); ++i )
            {
                pcl::PointXYZ pnt;
                pnt.x = minMax[i](0); pnt.y = minMax[i](1); pnt.z = minMax[i](2);
                ps.push_back( pnt );
            }
            if ( draw_mode <= 1 ) // 0: classic, 1: classic axis_aligned, 2: qhull
                err += draw( ps, v, plane_name, r, g, b, viewport_id );
            else if ( draw_mode == 2 )
                err += drawConvex( v, plane, cloud, indices, plane_name, r, g, b, viewport_id, alpha );
            else
            {
                std::cerr << "can't recognize draw mode " << draw_mode << std::endl;
                err = EXIT_FAILURE;
            }
        }

        //v->setShapeRenderingProperties( pcl::visualization::PCL_VISUALIZER_SHADING, pcl::visualization::PCL_VISUALIZER_SHADING_FLAT, plane_name );

        return err;
    } //...draw()

    /*! \brief Extract convec hull and display
     *  \tparam PclCloudT Concept: pcl::PointCloud<pcl::PointXYZ>::Ptr plane_polygon_cloud_ptr( new pcl::PointCloud<pcl::PointXYZ> ).
     *  \tparam PointsT Concept: std::vector<pcl::PointXYZ>.
     */
    template < class PclCloudT, class _PointContainerT, class _IndicesContainerT>
    inline int
    PlanePrimitive::getHull( PclCloudT                & plane_polygon_cloud
                           , PlanePrimitive      const& plane
                           , _PointContainerT    const& points
                           , _IndicesContainerT  const* indices
                           , float               const  alpha    /* = 2.f  */
                           , pcl::PolygonMesh         * out_mesh /* = NULL */
                           )
    {
        typedef typename PclCloudT::PointType PclPointT;

        pcl::ConcaveHull<PclPointT>              concave_hull;                                   // object
        //typename pcl::PointCloud<PclPointT>::Ptr cloud_hull( new pcl::PointCloud<PclPointT>() );
        typename pcl::PointCloud<PclPointT> cloud_hull;
        typename pcl::PointCloud<PclPointT>::Ptr cloud_projected( new typename pcl::PointCloud<PclPointT>() );
        std::vector<pcl::Vertices>          polygons;                               // output list indexing the points from cloud_hull, in 2D this is size 1
        //pcl::PointCloud<PclPointT>::Ptr plane_polygon_cloud_ptr( new pcl::PointCloud<PclPointT> );

        cloud_projected->resize(indices->size());

        // get assigned points, project them to the plane and store as PCL cloud
        UPidT i = 0;
        for ( typename _IndicesContainerT::const_iterator it = indices->begin(); it != indices->end(); ++i, ++it )
        {
            cloud_projected->at(i).getVector3fMap() = plane.projectPoint(points[*it].pos()).template cast<float>();
        }

        concave_hull.setAlpha( alpha );
        concave_hull.setInputCloud( cloud_projected );
        concave_hull.reconstruct( cloud_hull, polygons );

        if ( polygons.size() )
        {
            UPidT max_size = 0, max_id = 0;
            for ( i = 0; i != polygons.size(); ++i )
            {
                if ( polygons[i].vertices.size() > max_size )
                {
                    max_size = polygons[i].vertices.size();
                    max_id = i;
                }
            }

            plane_polygon_cloud.resize( polygons[max_id].vertices.size() );
            i = 0;
            for ( std::vector<uint32_t>::const_iterator it  = polygons[max_id].vertices.begin();
                  it != polygons[max_id].vertices.end(); ++i, ++it )
            {
                plane_polygon_cloud.at( i ) = cloud_hull.at(*it);
            }

            if ( out_mesh )
            {
                // Perform reconstruction
                out_mesh->polygons = polygons;

                // Convert the PointCloud into a PCLPointCloud2
                pcl::toPCLPointCloud2 (cloud_hull, out_mesh->cloud);
            }
        }
        else
            std::cout << "no hull" << std::endl;

        return plane_polygon_cloud.size();
    }

    /*! \brief Extract convec hull and display
     *  \tparam PointsT Concept: std::vector<pcl::PointXYZ>.
     */
    template <class _PointContainerT, class _IndicesContainerT>
    inline int
    PlanePrimitive::drawConvex( pcl::visualization::PCLVisualizer::Ptr v
                              , PlanePrimitive      const& plane
                              , _PointContainerT    const& cloud
                              , _IndicesContainerT  const* indices
                              , std::string         const  plane_name
                              , double              const  r
                              , double              const  g
                              , double              const  b
                              , int                 const  viewport_id /* = 0   */
                              , float               const  alpha       /* = 2.f */
                              )
    {
        pcl::PointCloud<pcl::PointXYZ>::Ptr plane_polygon_cloud_ptr( new pcl::PointCloud<pcl::PointXYZ> );
        if ( getHull(*plane_polygon_cloud_ptr, plane, cloud, indices, alpha) )
        {
//            #pragma omp critical PCLVIS
            {
                // draw plane polygon
                v->addPolygon<pcl::PointXYZ>( plane_polygon_cloud_ptr, r,g,b, plane_name, viewport_id );

                // v->setShapeRenderingProperties( pcl::visualization::PCL_VISUALIZER_OPACITY, .9, plane_name);
                v->setShapeRenderingProperties( pcl::visualization::PCL_VISUALIZER_REPRESENTATION, pcl::visualization::PCL_VISUALIZER_REPRESENTATION_SURFACE, plane_name );
            }
        }
        else
        {
            std::cerr << "[" << __func__ << "]: " << "qhull returned 0 points for plane " << plane.toString() << "..." << std::endl;
            return EXIT_FAILURE;
        }

        return EXIT_SUCCESS;
    }

    inline int PlanePrimitive::to4Coeffs( std::vector<Scalar> &coeffs ) const
    {
        coeffs.resize( 4, Scalar(0.) );
        std::copy( _coeffs.data()+3, _coeffs.data()+6, coeffs.begin() );
        // calculate distance from origin
        coeffs[3] = Scalar(-1.) * this->normal().dot( this->pos() );
        return EXIT_SUCCESS;
    }

#   ifdef RAPTER_USE_PCL
    inline pcl::ModelCoefficients::Ptr
    PlanePrimitive::modelCoefficients() const
    {
        pcl::ModelCoefficients::Ptr model_coeffs( new pcl::ModelCoefficients() );
       model_coeffs->values.resize(Dim);
       // copy normal
       std::copy( _coeffs.data()+3, _coeffs.data()+6, model_coeffs->values.begin() );
       // calculate distance from origin
       model_coeffs->values[3] = Scalar(-1.) * this->normal().dot( this->pos() );
       if ( model_coeffs->values[3] != this->getDistance(Eigen::Matrix<Scalar,3,1>::Zero()) )
           std::cout << "these should be similar: " << this->getDistance(Eigen::Matrix<Scalar,3,1>::Zero())
                        << " , " << model_coeffs->values[3] << std::endl;
       return model_coeffs;
    }
#   endif // RAPTER_USE_PCL

    inline bool PlanePrimitive::gidUnset() const { return this->getTag(PlanePrimitive::TAGS::GID) == LONG_VALUES::UNSET; }

//    inline PlanePrimitive::Scalar
//    PlanePrimitive::getFiniteDistance( PlanePrimitive::ExtentsT const& extrema, PlanePrimitive::Position const& pnt ) const
//    {
//        return MyPointFinitePlaneDistanceFunctor::eval( extrema, *this, pnt );
//    }

//    inline Eigen::Matrix<PlanePrimitive::Scalar,3,1>
//    PlanePrimitive::projectPoint( Eigen::Matrix<PlanePrimitive::Scalar,3,1> const& point ) const
//    {
//        return point - (this->getDistance(point) * this->dir() );
//    }
} //...ns rapter

#endif // GO_PLANEPRIMITIVE_HPP


text:
layout: page
show_meta: false
subheadline: "Header"
title: "Style your Header!"
description: "These are your options to style the header of each webpage individually. Feeling Responsive uses Backstretch by Scott Robin to expand them from left to right. The width should be 1600 pixel or higher using a ratio like 16:9 or 21:9 or 2:1."
header:
   image_fullwidth: "header_unsplash_5.jpg"
permalink: "/headers/"
---

    {% for post in site.tags.header %}

{{ post.title }}

    {% endfor %}

redpajama_set_name: RedPajamaGithub


text:
package org.avslor.JourneyThroughAvslor.Engine.Monsters;

/*
 * This interface is the contracted methods for every new charachter class.
 */
public interface iCharacter
{
    //What every character should have
    String getName();
    String getRace();
    String getAlignment();
    String getClassName();
    String getHealthPoints();
    String getMagicPoints();
    int getLevel();
}


text:
class <caret>Constructor(i: Int) {

  def this(i: Int, j: Int) {
    this(i)
  }

  val c = new Constructor(1)
}

class ConstructorChild extends Constructor(0)


text:
<?php
declare(strict_types = 1);

namespace Innmind\Rest\Server\Serializer;

use Innmind\Http\Message\ServerRequest;
use Innmind\Stream\Readable;

interface Encoder
{
    public function __invoke(ServerRequest $request, array $data): Readable;
}


text:
var path = require('path'),
    config,
    fileStorage,
    storage;

if (!!process.env.S3_ACCESS_KEY_ID) {
  fileStorage = true
  storage = {
    active: 'ghost-s3',
    'ghost-s3': {
      accessKeyId:     process.env.S3_ACCESS_KEY_ID,
      secretAccessKey: process.env.S3_ACCESS_SECRET_KEY,
      bucket:          process.env.S3_BUCKET_NAME,
      region:          process.env.S3_BUCKET_REGION,
      assetHost:       process.env.S3_ASSET_HOST_URL
    }
  }
} else if (!!process.env.BUCKETEER_AWS_ACCESS_KEY_ID) {
  fileStorage = true
  storage = {
    active: 'ghost-s3',
    'ghost-s3': {
      accessKeyId:     process.env.BUCKETEER_AWS_ACCESS_KEY_ID,
      secretAccessKey: process.env.BUCKETEER_AWS_SECRET_ACCESS_KEY,
      bucket:          process.env.BUCKETEER_BUCKET_NAME,
      region:          process.env.S3_BUCKET_REGION,
      assetHost:       process.env.S3_ASSET_HOST_URL
    }
  }
} else {
  fileStorage = false
  storage = {}
}

config = {

  // Production (Heroku)
  production: {
    url: process.env.HEROKU_URL,
    mail: {
      transport: 'SMTP',
      from: '"Ember Weekend Blog" <blog@emberweekend.com>',
      options: {
        service: process.env.MAIL_SERVICE,
        auth: {
          user: process.env.SMTP_LOGIN,
          pass: process.env.SMTP_PASSWORD
        }
      }
    },
    fileStorage: fileStorage,
    storage: storage,
    database: {
      client: 'postgres',
      connection: process.env.DATABASE_URL,
      debug: false
    },
    server: {
      socket: '/tmp/nginx.socket'
    },
    paths: {
      contentPath: path.join(__dirname, '/content/')
    }
  },

  // Development
  development: {
    url: 'http://localhost:2368',
    database: {
      client: 'sqlite3',
      connection: {
        filename: path.join(__dirname, '/content/data/ghost-dev.db')
      },
      debug: false
    },
    server: {
      host: '127.0.0.1',
      port: '2368'
    },
    paths: {
      contentPath: path.join(__dirname, '/content/')
    }
  }

};

// Export config
module.exports = config;


text:
#if !defined (__GLIB_GOBJECT_H_INSIDE__) && !defined (GOBJECT_COMPILATION)
#error "Only <glib-object.h> can be included directly."
#endif

G_DEFINE_AUTOPTR_CLEANUP_FUNC(GClosure, g_closure_unref)
G_DEFINE_AUTOPTR_CLEANUP_FUNC(GObject, g_object_unref)
G_DEFINE_AUTOPTR_CLEANUP_FUNC(GInitiallyUnowned, g_object_unref)
G_DEFINE_AUTO_CLEANUP_CLEAR_FUNC(GValue, g_value_unset)


text:
class SMRoamingProfile;

class ThreadRoamingProfilePull : public WorkerThread {
public:
	virtual void Work();
	virtual void Term();

	ThreadRoamingProfilePull() {}
	virtual ~ThreadRoamingProfilePull() {}
private:
	HTTP http_;
	std::string url_;
};

#endif


text:
FROM centos:7

#AUTHOR
MAINTAINER 21jhf <21jhf@163.com>

#安装wget
#RUN yum install -y wget

#更换yum源
RUN mv /etc/yum.repos.d/CentOS-Base.repo /etc/yum.repos.d/CentOS-Base.repo.backup
ADD CentOS7-Base-163.repo /etc/yum.repos.d/CentOS-Base.repo
#	&& wget -O /etc/yum.repos.d/CentOS-Base.repo http://mirrors.aliyun.com/repo/Centos-7.repo \
RUN yum clean all \
	&& yum makecache

#安装工具集
RUN yum install -y zlib zlib-devel pcre pcre-devel gcc gcc-c++ openssl openssl-devel libevent libevent-devel perl unzip net-tools git wget

#配置环境变量
ENV CENTOS_VERSION=7 \
	FASTDFS_PATH=/fastdfs \
    FASTDFS_STORAGE_PATH=/fastdfs/storage \
    FASTDFS_STORAGE_DATA_PATH=/fastdfs/storage/data \
    FASTDHT_PATH=/fastdfs/fastdht \
    NGINX_VERSION=1.11.7 \
    BERKELEY_DB_VERSION=6.2.23 \
	TRACKER_SERVER=

#创建必要的目录
RUN mkdir -p ${FASTDFS_PATH}/download \
 && mkdir -p ${FASTDFS_STORAGE_PATH} \
 && mkdir -p ${FASTDFS_PATH}/client \
 && mkdir -p ${FASTDFS_PATH}/mod \
 && mkdir -p ${FASTDHT_PATH}

#下载
WORKDIR ${FASTDFS_PATH}/download/
RUN git clone https://github.com/happyfish100/libfastcommon.git
RUN wget https://github.com/happyfish100/fastdfs/archive/master.zip -P ${FASTDFS_PATH}/download/fastdfs
RUN wget https://github.com/happyfish100/fastdfs-nginx-module/archive/master.zip -P ${FASTDFS_PATH}/download/nginx_module
RUN wget https://github.com/happyfish100/fastdht/archive/master.zip -P ${FASTDFS_PATH}/download/fastdht
RUN wget "http://nginx.org/download/nginx-${NGINX_VERSION}.tar.gz" -P ${FASTDFS_PATH}/download/nginx
RUN wget "http://download.oracle.com/berkeley-db/db-${BERKELEY_DB_VERSION}.tar.gz" -P ${FASTDFS_PATH}/download
RUN unzip ${FASTDFS_PATH}/download/fastdfs/master.zip -d ${FASTDFS_PATH}/download/fastdfs \
 && unzip ${FASTDFS_PATH}/download/nginx_module/master.zip -d ${FASTDFS_PATH}/download/nginx_module \
 && unzip ${FASTDFS_PATH}/download/fastdht/master.zip -d ${FASTDFS_PATH}/download/fastdht \
 && tar zxvf ${FASTDFS_PATH}/download/nginx/nginx-${NGINX_VERSION}.tar.gz -C ${FASTDFS_PATH}/download/nginx \
 && tar zxvf ${FASTDFS_PATH}/download/db-${BERKELEY_DB_VERSION}.tar.gz -C ${FASTDFS_PATH}/download

#安装libfastcommon
WORKDIR ${FASTDFS_PATH}/download/libfastcommon/
RUN ["/bin/bash", "-c", "./make.sh && ./make.sh install"]

#安装fastdfs
WORKDIR ${FASTDFS_PATH}/download/fastdfs/fastdfs-master
RUN ["/bin/bash", "-c", "./make.sh && ./make.sh install && cp conf/* /etc/fdfs/"]

#安装nginx
WORKDIR ${FASTDFS_PATH}/download/nginx/nginx-${NGINX_VERSION}
RUN ./configure --add-module=${FASTDFS_PATH}/download/nginx_module/fastdfs-nginx-module-master/src \
 && make \
 && make install \
 && cp ${FASTDFS_PATH}/download/nginx_module/fastdfs-nginx-module-master/src/mod_fastdfs.conf /etc/fdfs/

#安装berkeley db
WORKDIR ${FASTDFS_PATH}/download/db-${BERKELEY_DB_VERSION}/build_unix
RUN ../dist/configure --prefix=/usr/local/db-${BERKELEY_DB_VERSION} \
 && make \
 && make install

#安装fastdht
WORKDIR ${FASTDFS_PATH}/download/fastdht/fastdht-master
RUN sed -i "s?CFLAGS='-Wall -D_FILE_OFFSET_BITS=64 -D_GNU_SOURCE'?CFLAGS='-Wall -D_FILE_OFFSET_BITS=64 -D_GNU_SOURCE -I/usr/local/db-${BERKELEY_DB_VERSION}/include/ -L/usr/local/db-${BERKELEY_DB_VERSION}/lib/'?" make.sh
RUN ["/bin/bash", "-c", "./make.sh && ./make.sh install"]
RUN cp /usr/local/db-${BERKELEY_DB_VERSION}/lib/libdb-${BERKELEY_DB_VERSION:0:3}.so /usr/lib64

#添加初始化配置
RUN cp /usr/share/zoneinfo/Asia/Shanghai /etc/localtime
COPY fdht_config/* /etc/fdht/
COPY fdfs_config/* /etc/fdfs/
COPY nginx_config/nginx.conf /usr/local/nginx/conf/nginx.conf
COPY ["start","stop","/fastdfs/"]
RUN chmod +x ${FASTDFS_PATH}/start \
  && chmod +x ${FASTDFS_PATH}/stop \
  && ln -s ${FASTDFS_PATH}/start /usr/local/bin/start_fdfs \
  && ln -s ${FASTDFS_PATH}/stop /usr/local/bin/stop_fdfs

EXPOSE 23000 11411 80

VOLUME ["$FASTDFS_PATH", "/etc/fdfs"]

CMD ["bash","start_fdfs"]


text: Nagios Plugin to check disabled CloudWatch Alarms


text:
package com.gs.collections.impl.lazy;

import com.gs.collections.impl.block.factory.Procedures;
import com.gs.collections.impl.factory.Lists;
import org.junit.Assert;
import org.junit.Before;
import org.junit.Test;

public class ZipWithIndexIterableTest
{
    private ZipWithIndexIterable<Integer> iterableUnderTest;
    private final StringBuilder buffer = new StringBuilder();

    @Before
    public void setUp()
    {
        this.iterableUnderTest = new ZipWithIndexIterable<>(Lists.immutable.of(1, 2, 3, 4));
    }

    private void assertBufferContains(String expected)
    {
        Assert.assertEquals(expected, this.buffer.toString());
    }

    @Test
    public void forEach()
    {
        this.iterableUnderTest.forEach(Procedures.cast(argument1 -> {
            this.buffer.append("(");
            this.buffer.append(argument1);
            this.buffer.append(")");
        }));
        this.assertBufferContains("(1:0)(2:1)(3:2)(4:3)");
    }

    @Test
    public void forEachWIthIndex()
    {
        this.iterableUnderTest.forEachWithIndex((each, index) -> {
            this.buffer.append("|(");
            this.buffer.append(each);
            this.buffer.append("),");
            this.buffer.append(index);
        });
        this.assertBufferContains("|(1:0),0|(2:1),1|(3:2),2|(4:3),3");
    }

    @Test
    public void forEachWith()
    {
        this.iterableUnderTest.forEachWith((argument1, argument2) -> {
            this.buffer.append("|(");
            this.buffer.append(argument1);
            this.buffer.append("),");
            this.buffer.append(argument2);
        }, "A");
        this.assertBufferContains("|(1:0),A|(2:1),A|(3:2),A|(4:3),A");
    }
}


text:
package au.gov.amsa.ais;

import static java.lang.Integer.parseInt;

import java.util.Calendar;
import java.util.regex.Pattern;

import com.github.davidmoten.guavamini.annotations.VisibleForTesting;

import au.gov.amsa.util.nmea.NmeaMessage;
import au.gov.amsa.util.nmea.NmeaMessageParseException;
import au.gov.amsa.util.nmea.NmeaUtil;

/**
 * Parses a custom ExactEarth NMEA line for AMSA so that we can obtain the
 * actual timestamp of an AIS Position Report (types 1,2,3).
 *
 * @author dxm
 *
 */
public class NmeaMessageExactEarthTimestamp {

	private final NmeaMessage nmea;
	private final long time;
	private final String followingSequenceChecksum;

	/**
	 * Constructor.
	 *
	 * @param line
	 */
	public NmeaMessageExactEarthTimestamp(String line) {
		nmea = NmeaUtil.parseNmea(line);
		try {
			Util.checkArgument(isPghp(line), "not an ExactEarth timestamp: "
					+ line);
			getFollowingSequenceChecksum();
			int year = parseInt(getItem(2));
			int month = parseInt(getItem(3));
			int day = parseInt(getItem(4));
			int hour = parseInt(getItem(5));
			int minute = parseInt(getItem(6));
			int second = parseInt(getItem(7));
			int millisecond = parseInt(getItem(8));
			time = getTime(year, month, day, hour, minute, second, millisecond);
			followingSequenceChecksum = extractFollowingSequenceChecksum();
		} catch (RuntimeException e) {
			throw new AisParseException(e);
		}
	}

	private static final Pattern pghpPattern = Pattern
			.compile("^(\\\\.*\\\\)?\\$PGHP.*$");

	/**
	 * Returns true if and only if the given NMEA line is a PGHP line. Remember
	 * that the line can start with a tag block.
	 *
	 * @param line
	 * @return
	 */
	@VisibleForTesting
	static boolean isPghp(String line) {
		if (line == null)
			return false;
		else
			// return Pattern.matches("^(\\\\.*\\\\)?\\$PGHP.*$", line);
			return pghpPattern.matcher(line).matches();
	}

	/**
	 * Returns true if the given line is a custom ExactEarth timestamp.
	 *
	 * @param line
	 * @return
	 */
	public static boolean isExactEarthTimestamp(String line) {
		try {
			new NmeaMessageExactEarthTimestamp(line);
			return true;
		} catch (AisParseException e) {
			return false;
		} catch (NmeaMessageParseException e) {
			return false;
		}
	}

	/**
	 * Returns the item at index, zero based.
	 *
	 * @param index
	 * @return
	 */
	private String getItem(int index) {
		return nmea.getItems().get(index);
	}

	/**
	 * Returns the epoch time in ms.
	 *
	 * @return
	 */
	private static long getTime(int year, int month, int day, int hour,
			int minute, int second, int millisecond) {
		Calendar cal = Calendar.getInstance(Util.TIME_ZONE_UTC);
		cal.set(year, month - 1, day, hour, minute, second);
		cal.set(Calendar.MILLISECOND, millisecond);
		return cal.getTimeInMillis();
	}

	/**
	 * Returns the time in epoch ms.
	 *
	 * @return
	 */
	public long getTime() {
		return time;
	}

	/**
	 * Returns the checksum of the message that this timestamp line refers to.
	 *
	 * @return
	 */
	public String getFollowingSequenceChecksum() {
		return followingSequenceChecksum;
	}

	/**
	 * Returns the checksum of the message that this timestamp refers to.
	 *
	 * @return
	 */
	private String extractFollowingSequenceChecksum() {
		return getItem(13);
	}
}


text:
require 'test_helper'

# Tests for candidate aggregate
class CandidateTest < ActiveSupport::TestCase
  test 'registration has candidates' do
    registration = registrations(:mustermann_spatzennest)
    assert_equal 2, registration.candidates.size
    assert_equal 2, registration.children.size
  end
end


text:
package org.openfact.subsystem.server.logging;

import org.jboss.logging.BasicLogger;
import org.jboss.logging.Logger;
import org.jboss.logging.annotations.MessageLogger;

/**
 * This interface to be fleshed out later when error messages are fully externalized.
 *
 * @author Stan Silvert ssilvert@redhat.com (C) 2013 Red Hat Inc.
 */
@MessageLogger(projectCode = "OPENFACT")
public interface OpenfactLogger extends BasicLogger {

    /**
     * A logger with a category of the package name.
     */
    OpenfactLogger ROOT_LOGGER = Logger.getMessageLogger(OpenfactLogger.class, "org.jboss.openfact");
}


text:
"""NDG XACML one and only functions module

NERC DataGrid
"""
__author__ = "P J Kershaw"
__date__ = "01/04/10"
__copyright__ = ""
__license__ = "BSD - see LICENSE file in top-level directory"
__contact__ = "Philip.Kershaw@stfc.ac.uk"
__revision__ = '$Id$'
#from datetime import datetime, timedelta

from ndg.xacml.core.functions import AbstractFunction, FunctionClassFactoryBase
from ndg.xacml.utils import TypedList as Bag
from ndg.xacml.core.context.exceptions import XacmlContextError

class OneAndOnlyBase(AbstractFunction):
    """Base class for XACML <type>-one-and-only functions

    @cvar TYPE: attribute type for the given implementation.  Derived classes
    should set appropriately
    @type TYPE: NoneType
    """
    TYPE = None

    def evaluate(self, bag):
        """Check a bag has one element only and return it

        @param bag: bag containing one element
        @type bag: ndg.xacml.utils.TypedList
        @return: single item from bag
        @rtype: dependent on bag type set in derived type
        """
        if not isinstance(bag, Bag):
            raise XacmlContextError('Expecting %r derived type for "bag"; '
                                    'got %r' % (Bag, type(bag)))

        if bag.elementType != self.__class__.TYPE:
            raise XacmlContextError('Expecting %r type elements for "bag"; '
                                    'got %r' %
                                    (self.__class__.TYPE, bag.elementType))

        nBagElems = len(bag)
        if nBagElems != 1:
            raise XacmlContextError('Expecting single element for %r bag; got '
                                    '%r' % (self.__class__.TYPE, nBagElems))

        return bag[0]

class FunctionClassFactory(FunctionClassFactoryBase):
    """Class Factory for *-one-and-only XACML function classes

    @cvar FUNCTION_NAMES: one and only function URNs
    @type FUNCTION_NAMES: tuple

    @cvar FUNCTION_NS_SUFFIX: generic suffix for one and only function URNs
    @type FUNCTION_NS_SUFFIX: string

    @cvar FUNCTION_BASE_CLASS: base class for all one and only function classes
    @type FUNCTION_BASE_CLASS: ndg.xacml.core.functions.v1.OneAndOnlyBase
    """
    FUNCTION_NAMES = (
        'urn:oasis:names:tc:xacml:1.0:function:string-one-and-only',
        'urn:oasis:names:tc:xacml:1.0:function:boolean-one-and-only',
        'urn:oasis:names:tc:xacml:1.0:function:integer-one-and-only',
        'urn:oasis:names:tc:xacml:1.0:function:double-one-and-only',
        'urn:oasis:names:tc:xacml:1.0:function:time-one-and-only',
        'urn:oasis:names:tc:xacml:1.0:function:date-one-and-only',
        'urn:oasis:names:tc:xacml:1.0:function:dateTime-one-and-only',
        'urn:oasis:names:tc:xacml:1.0:function:anyURI-one-and-only',
        'urn:oasis:names:tc:xacml:1.0:function:hexBinary-one-and-only',
        'urn:oasis:names:tc:xacml:1.0:function:base64Binary-one-and-only',
        'urn:oasis:names:tc:xacml:1.0:function:dayTimeDuration-one-and-only',
        'urn:oasis:names:tc:xacml:1.0:function:yearMonthDuration-one-and-only',
        'urn:oasis:names:tc:xacml:1.0:function:x500Name-one-and-only',
        'urn:oasis:names:tc:xacml:1.0:function:rfc822Name-one-and-only'
    )
    FUNCTION_NS_SUFFIX = '-one-and-only'
    FUNCTION_BASE_CLASS = OneAndOnlyBase


text:
using System.Collections.Generic;
using System.IO;
using System.Text;
using System.Diagnostics.Contracts;
using System;

// Disable the "this variable is not used" warning as every field would imply it.
#pragma warning disable 0414
// Disable the "this variable is never assigned to".
#pragma warning disable 0067
// Disable the "this event is never assigned to".
#pragma warning disable 0649
// Disable the "this variable is never used".
#pragma warning disable 0169
// Disable the "new keyword not required" warning.
#pragma warning disable 0109
// Disable the "extern without DllImport" warning.
#pragma warning disable 0626
// Disable the "could hide other member" warning, can happen on certain properties.
#pragma warning disable 0108

namespace System.Collections.Specialized
{
  public partial class NotifyCollectionChangedEventArgs : EventArgs
  {
    #region Methods and constructors
    public NotifyCollectionChangedEventArgs(NotifyCollectionChangedAction action, System.Collections.IList newItems, System.Collections.IList oldItems, int startingIndex)
    {
    }

    public NotifyCollectionChangedEventArgs(NotifyCollectionChangedAction action, System.Collections.IList newItems, System.Collections.IList oldItems)
    {
    }

    public NotifyCollectionChangedEventArgs(NotifyCollectionChangedAction action, System.Collections.IList changedItems, int index, int oldIndex)
    {
    }

    public NotifyCollectionChangedEventArgs(NotifyCollectionChangedAction action, Object changedItem, int index, int oldIndex)
    {
    }

    public NotifyCollectionChangedEventArgs(NotifyCollectionChangedAction action, Object changedItem, int index)
    {
    }

    public NotifyCollectionChangedEventArgs(NotifyCollectionChangedAction action, Object changedItem)
    {
    }

    public NotifyCollectionChangedEventArgs(NotifyCollectionChangedAction action)
    {
    }

    public NotifyCollectionChangedEventArgs(NotifyCollectionChangedAction action, System.Collections.IList changedItems)
    {
    }

    public NotifyCollectionChangedEventArgs(NotifyCollectionChangedAction action, Object newItem, Object oldItem, int index)
    {
    }

    public NotifyCollectionChangedEventArgs(NotifyCollectionChangedAction action, Object newItem, Object oldItem)
    {
    }

    public NotifyCollectionChangedEventArgs(NotifyCollectionChangedAction action, System.Collections.IList changedItems, int startingIndex)
    {
    }
    #endregion

    #region Properties and indexers
    public NotifyCollectionChangedAction Action
    {
      get
      {
        return default(NotifyCollectionChangedAction);
      }
    }

    public System.Collections.IList NewItems
    {
      get
      {
        return default(System.Collections.IList);
      }
    }

    public int NewStartingIndex
    {
      get
      {
        return default(int);
      }
    }

    public System.Collections.IList OldItems
    {
      get
      {
        return default(System.Collections.IList);
      }
    }

    public int OldStartingIndex
    {
      get
      {
        return default(int);
      }
    }
    #endregion
  }
}


text:
Basic usage
===========

Frontend
--------
Functionality to subscribe

1. Configure module in frontend part of your application
    ```php
    'modules' => [
        // ...
        'newsletter' \ymaker\newsletter\frontend\Module::class,
    ],
    ```

2. Call widget for rendering of newsletter form
    ```php
    // view file
    <?= \ymaker\newsletter\frontend\widgets\NewsletterForm::widget() ?>
    ```

Backend
-------
Functionality for managing users contacts

1. Configure module in backend part of your application
    ```php
    'modules' => [
        // ...
        'newsletter' => \ymaker\newsletter\backend\Module::class,
    ],
    ```
2. And follow this route: `http://your-app.back.dev/newsletter/default/list`


text:
<?php

class Google_Service_CloudTasks_GetPolicyOptions extends Google_Model
{
  public $requestedPolicyVersion;

  public function setRequestedPolicyVersion($requestedPolicyVersion)
  {
    $this->requestedPolicyVersion = $requestedPolicyVersion;
  }
  public function getRequestedPolicyVersion()
  {
    return $this->requestedPolicyVersion;
  }
}


text:
FROM biocontainers/biocontainers:v1.0.0_cv4

################## METADATA ######################
LABEL base_image="biocontainers:v1.0.0_cv4"
LABEL version="4"
LABEL software="bwa"
LABEL software.version="0.7.15"
LABEL about.summary="Burrow-Wheeler Aligner for pairwise alignment between DNA sequences"
LABEL about.home="http://bio-bwa.sourceforge.net/"
LABEL about.documentation="http://bio-bwa.sourceforge.net/"
LABEL about.license_file="http://bio-bwa.sourceforge.net/"
LABEL about.license="SPDX:GPL-3.0"
LABEL extra.identifiers.biotools="bwa"
LABEL about.tags="Genomics"
LABEL extra.binaries="bwa"

################## MAINTAINER ######################
MAINTAINER Saulo Alves Aflitos <sauloal@gmail.com>

################## INSTALLATION ######################

RUN conda install bwa=0.7.15

WORKDIR /data/

# CMD ["bwa"]


text:
<!DOCTYPE html>

    <meta charset="utf-8">
    <meta http-equiv="X-UA-Compatible" content="IE=edge,chrome=1">
    <meta name="viewport" content="width=device-width">
    <title>Simple Switch</title>

A Simple Switch

Power: OFF

<form action="/">
    Power:

        <input type="checkbox" id="power"/>

</form>


text:
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace Assets.Scripts.Data
{
    public class DataRe
    {
        public static long DateTimeToUnixSeconds(DateTime date)
        {
            TimeSpan span = (DateTime.UtcNow - new DateTime(1970, 1, 1, 0, 0, 0, 0, DateTimeKind.Utc));
            return (long) span.TotalSeconds;
        }

        public static string DateTimeToUniString(DateTime date)
        {
            return date.ToString("yyyy-MM-dd HH:mm:ss");
        }

        public static DateTime UnixTimeToDateTime(long unixSeconds)
        {
            DateTime UnixEpoch = new DateTime(1970, 1, 1, 0, 0, 0, 0, DateTimeKind.Utc);
            return UnixEpoch.AddSeconds(unixSeconds);
        }

        public static string ReadableStringFromUnix(string unix)
        {
            try
            {
                long l = long.Parse(unix);
                return DateTimeToUniString(UnixTimeToDateTime(l));
            }
            catch (Exception)
            {
                return "";
            }
        }

        public static string ReadableStringFromUnix(long unix)
        {
            return DateTimeToUniString(UnixTimeToDateTime(unix));
        }

        public static int[] SplitVersionName(string version)
        {
            string[] s = version.Split('.');
            if (s.Length == 2)
            {
                int[] codes = new int[2];
                codes[0] = Convert.ToInt32(s[0]);
                codes[1] = Convert.ToInt32(s[1]);
                return codes;
            }
            return null;
        }
    }
}


text:
var DonkeyKongVC = (function(global,Pages){

	//SETTINGS
	var config = {
		debug: true,
		logging: false
	};

	if(config.logging) log('new DonkeyKongVC()');

	//VIEW
	var view = null;
	var $view = null;
	var art = null;
		var mainStage = null;
			var mainStage__inner = null;
				var flipBook = null;
				var flipBookImages = null;
				var currentFlipBookImageIndex = null;
				var scene = null;
				var renderer = null;
				var camera = null;
				var lights = null;//Array
				var cabinet = null;
				var gameVideo = null;
				var video = null;
				var sideart = null;
				var bezel = null;
				var sideCover = null;
				var sideCover2 = null;
				var videoTexture = null;
				var focalPoint = null;//Where the camera is looking. At the center of the video game screen.

	//CONTROLLER
	var inited = false;
	var readied = false;
	var cameraDoesRespondToMousePosition = false;//This is enabled after the intro animation completes.
	var mouseXPercentageFromCenter = 0;
	var mouseYPercentageFromCenter = 0;

	//Initialize the page so it can slide in.
	function init() {
		if(config.logging) log('DonkeyKongVC.init()');
		hideRefreshButton();

		//INIT VIEW
		view = document.getElementById('donkey-kong');
		$view = $(view);
		art = $view.find('.donkey-kong__art')[0];
		mainStage = $view.find('.donkey-kong__main-stage')[0];
		mainStage__inner = $view.find('.donkey-kong__main-stage__inner')[0];
		lights = [];

		//INIT CONTROLLER
		//

		inited = true;
	}

	//Start the page's animations, event handling, etc.
	function ready() {
		if(config.logging) log('DonkeyKongVC.ready()');

		//SET STATE
		if(supportsWebGL()){
			create3DScene();
			$(mainStage).addClass('mode__3D');
			$(art).addClass('hasBackgroundImage');
		}else{
			createFlipBook();
			$(mainStage).addClass('mode__2D');
			$(art).css({background:'black'});
		}

		//INIT INTERACTION
		disableSelectionOnMobileBrowsers(art);//Prevent selection of art elements.
		//FastClick.attach(art);//Allow faster interaction on mobile. This prevents double-clicks.
		$(window).bind('resize', onResize);
		$(window).bind('mousemove', onMouseMove);//Now start responding the user's cursor.

		readied = true;
	}

	//Stop the page, freeze the display, remove event handlers, etc.
	function teardown(){
		if(config.logging) log('DonkeyKongVC.teardown()');

		//TEARDOWN VIEW
		$(mainStage).removeClass('mode__3D mode__2d');
		view.id = view.id+'__old';//Change the old view's id, so it can't accidentally be found by the new ViewController.

		this.oldview = view;
		view = null;
		$view = null;
		art = null;
			mainStage = null;
				mainStage__inner = null;
					if(flipBook){
						flipBook.parentElement.removeChild(flipBook);
						flipBook = null;
						flipBookImages = null;
						currentFlipBookImageIndex = null;
					}
					scene = null;
					renderer = null;
					camera = null;
					lights = null;
					cabinet = null;
					if(gameVideo){
						window._AVManager.removeVideo(gameVideo);
						//gameVideo.pause();
						//delete(gameVideo);
						//gameVideo = null;
					}
					video = null;
					bezel = null;
					sideart = null;
					sideCover = null;
					sideCover2 = null;
					videoTexture = null;
					focalPoint = null;

		//TEARDOWN CONTROLLER
		inited = false;
		readied = false;
		mouseXPercentageFromCenter = 0;
		mouseYPercentageFromCenter = 0;
		cameraDoesRespondToMousePosition = false;

		//TEARDOWN INTERACTION
		$(window).unbind('mousemove', onMouseMove);
		$(window).unbind('resize', onResize);
	}

	function create3DScene(){
		createScene();//Defined renderer, camera, and scene.
		createLights();
		createCabinet();

		function createScene(){
			// set the scene size
			//var WIDTH = 400;
			//var HEIGHT = 300;

			// set some camera attributes
			var VIEW_ANGLE = 45;
			var aspectRatio = mainStage__inner.clientWidth/mainStage__inner.clientHeight;
			var NEAR = 0.1;
			var FAR = 10000;

			// get the DOM element to attach to
			// - assume we've got jQuery to hand
			var $container = $('#container');

			renderer = new THREE.WebGLRenderer({antialias: true});//Chrome, Firefox
			//renderer.gammaInput = true;
			//renderer.gammaOutput = true;
			//renderer.physicallyBasedShading = true;

			camera = new THREE.PerspectiveCamera(VIEW_ANGLE, aspectRatio, NEAR, FAR);

			scene = new THREE.Scene();
			scene.add(camera);//Add the camera to the scene.

			$(mainStage__inner).append(renderer.domElement);//Add it to the view.
			var canvas = $(mainStage__inner).find('canvas')[0];
			if(!canvas || !mainStage__inner){
				e.e;
			}
		}

		function createLights(){

			lights[0] = new THREE.PointLight(0xFFFFFF, 1.5);//Put a light on the top right.
			//light = new THREE.AmbientLight(0xFFFFFF);//Put a light on the top right.
			//light = new THREE.DirectionalLight(0xFFFFFF);//Put a light on the top right.
			lights[0].position.x = 100;
			lights[0].position.y = 100;
			lights[0].position.z = 100;
			scene.add(lights[0]);

			lights[1] = new THREE.PointLight(0xFFFFFF, 1.5);//Put a light on the top left.
			lights[1].position.x = -200;
			lights[1].position.y = 100;
			lights[1].position.z = 100;
			scene.add(lights[1]);

			/*scene.remove(light3);
			light3 = new THREE.PointLight(0xFFFFFF);
			light3.position.x = 200;
			light3.position.y = 100;
			light3.position.z = 300;
			scene.add(light3);*/
		}
		function createVideo(){
			var isChrome = (navigator.vendor.toLowerCase().indexOf('google') > -1);
			var isWindows = (navigator.platform.toLowerCase().indexOf('win') > -1);
			var usingChromeOnWindows = (isChrome && isWindows);
			if(usingChromeOnWindows == 1){
				return;
			}

			//CREATE VIDEO
			//http://learningthreejs.com/blog/2012/02/07/live-video-in-webgl
			gameVideo = document.createElement('video');

			gameVideo.autoplay = true;
			gameVideo.preload = 'none';//?
			//gameVideo.loop = true;//Does not work without <source contentType=''> attribute
			gameVideo.addEventListener('ended', gameVideo_onEnd);
			if(Modernizr.video.h264){
				//if(gameVideo.canPlayType || gameVideo.canPlayType('video/mp4')){//Use mp4 if possible, else fallback to ogv.
				gameVideo.src = '../images/arcade-era/donkey-kong/3d-model/video/donkey-kong__shortened.mp4';
			}else{
				gameVideo.src = '../images/arcade-era/donkey-kong/3d-model/video/donkey-kong__ultra-shortened.ogv';
			}
			window._AVManager.addVideo(gameVideo, function(){
				if(config.logging) log('Donkey Kong video is loaded.');
				applyVideoTexture();
			});

			videoTexture = new THREE.Texture(gameVideo);
			videoTexture.minFilter = THREE.LinearFilter;
			videoTexture.magFilter = THREE.LinearFilter;
			videoTexture.format = THREE.RGBFormat;
			videoTexture.generateMipmaps = false;
			videoTexture.flipY = true;

			var videoMaterial = new THREE.MeshLambertMaterial({
				color: 0xffffff,
				map: videoTexture
			});

			var videoWidth = 20;
			var videoAspectRatio = 226/256;//Pixel size of the video.

			function applyVideoTexture(){
				if(!cabinet) return;
				var videoContainer = cabinet.children[19];
				video = videoContainer.children[0];//Use a video for the game screen.
				video.material = videoMaterial;
				video.parent.add(video);//Re-add to the scene so video works. Unsure why this is neccessary.
			}
		}

		function gameVideo_onEnd(event){
			gameVideo.removeEventListener('ended', gameVideo_onEnd);
			window._AVManager.playVideo(gameVideo, true);//(video:HTML5VideoElement, rewind:Boolean, onComplete:Function):void
			gameVideo.addEventListener('ended', gameVideo_onEnd);
		}

		function createCabinet(){

			//createVideo();

			//LOAD AND CREATE CABINET
			var loader = new THREE.OBJMTLLoader();
			loader.addEventListener( 'load', function ( event ) {
				if(!scene) return;
				cabinet = event.content;
				cabinet.position.set(0, 0, 0);
				cabinet.scale.set(1, 1, 1);
				scene.add(cabinet);

				//Find the bezel and make it transparent.
				for(var i in cabinet.children){
					var child = cabinet.children[i];

					if(i == 5){//Prevent the side cabinet texture from repeating.
						var texture = child.children[0].material.map;
						texture.wrapS = texture.wrapT = THREE.ClampToEdgeWrapping;//Tell the texture to not repeat.

					}else if(i == 11){//Make the bezel transparent, so you can see the game inside.
						bezel = child.children[0];
						bezel.material.transparent = true;

					}else if(i == 13){//Make the glass reflective. This does not work, and I have not determined why.
						glass = child.children[0];
						/*glass.material = new THREE.MeshPhongMaterial( {
							color: 0xff0000,
							ambient: 0x00ff00, // should generally match color
							specular: 0x0000ff,
							shininess: 100
						});
						glass.material.transparent = true;*/

					}
				}

				//Move the side panel up a tiny bit so you don't see white pixels along the top from the plastic edging.
				cabinet.children[5].position.y += .1;

				//Wishful Todo: Add interactivity to the cabinet. :)
				//threex.domevent.js
				/*cabinet.on('click', function(){
					cabinet.position.x += 1;
				});*/

				/* CONTENTS OF cabinet.children: (Disregard the names, because they are not accurate.)
				0 (nothing in this?)
				1 black side cabinet, and bezel around the screen
				2 orange button
				3 marquee
				4 insert coin sticker
				5 side art
				6 (unknown? possibly the steel bezel)
				7 speaker mesh (not really visible)
				8 metal coinage area
				9 little rectangles on metal coinage area
				10 instructions sticker
				11 bezel (the window)
				12 controls area
				13 glass
				14 black area around the screen
				15 blue speaker front, below controls
				16 blue buttons
				17 plastic edges
				18 joystick
				19 screen
				*/

				//DEBUG: Use this to quickly find the child you want.
				/*for(var i in cabinet.children){
					if(i == 1){
						var debugChild = cabinet.children[i];
						if(debugChild.children.length){
							debugChild.children[0].material = new THREE.MeshLambertMaterial({color: 0x00ff00});
						}else{
							console.log('no material found');
						}
					}
				}
				//glass.parent.remove(glass);
				//bezel.parent.remove(bezel);
				*/

				//Create a black rectangle to cover up the interior side wall of the cabinet. It is grey and does not look realistic.
				sideCover = new THREE.Mesh(
					new THREE.PlaneGeometry(25, 30),//(w,h)
					new THREE.MeshLambertMaterial({color: 0x000000})
				);
				cabinet.children[0].add(sideCover);
				sideCover.position.set(11.5,50,-11);
				sideCover.rotation.y = -.5*Math.PI;//90 deg counter clockwise

				sideCover2 = new THREE.Mesh(
					new THREE.PlaneGeometry(25, 30),//(w,h)
					new THREE.MeshLambertMaterial({color: 0x000000})
				);
				cabinet.children[0].add(sideCover2);
				sideCover2.position.set(-12,50,-9);
				sideCover2.rotation.y = .5*Math.PI;//90 deg clockwise

				focalPoint = new THREE.Vector3(0+cabinet.position.x,55,5);//Where the camera is looking. At the center of the video game screen.

				apply();
				animateIn();
				setSize();
				render(true);//Start render loop, using requestAnimationFrame.
				createVideo();
			});
			loader.load(
				'../images/arcade-era/donkey-kong/3d-model/donkey-kong-cabinet.obj'//,
				//'../images/arcade-era/donkey-kong/3d-model/donkey-kong-cabinet.mtl'//Loads automatically via .obj
			);
		}
	}

	function createFlipBook(){
		cameraDoesRespondToMousePosition = true;
		flipBook = document.createElement('div');
		$(flipBook).addClass('donkey-kong__flip-book');
		mainStage__inner.appendChild(flipBook);
		flipBookImages = [];
		var useFewerFrames = false;
		var numberOfFrames = 11;
		if(useFewerFrames) numberOfFrames = Math.ceil(numberOfFrames/2);
		for(var i=0; i<numberOfFrames; i++){
			if(useFewerFrames){
				if(!isEven(i)){
					break;//Skip all odd-numbered images so there are half as many.
				}
			}
			var image = new Image();
			image.id = 'donkey-kong__flip-book__image'+i;
			$(image).addClass('donkey-kong__flip-book__image');
			image.src = '../images/arcade-era/donkey-kong/flip-book/'+i+'.jpg';
			flipBookImages.push(image);
			flipBook.appendChild(image);
		}

		onResize();//Set image sizes with JavaScript, so they do not get stretched. Each browser seems to have its own stretching variations, so this is a fool-proof approach.

		//Go to the first image.
		$(flipBookImages).hide();
		$(flipBookImages[0]).show();
		currentFlipBookImageIndex = 0;

		//Allow the user to change the image.
		$(flipBook).bind('click', function(event){
			var x = event.offsetX;
			var y = event.offsetY;

			//Go to the view closest image
			var currentFlipBookImage = getCurrentFlipBookImage();
			var mouseXPercentageFromLeft = x / $(flipBook).width();
			var i = Math.floor(flipBookImages.length * mouseXPercentageFromLeft);
			if(i < 0) i = 0;
			if(i > flipBookImages.length - 1){
				i = flipBookImages.length - 1;
			}
			var newFlipBookImage = flipBookImages[i];
			if(newFlipBookImage != currentFlipBookImage){
				$(flipBookImages).hide();
				$(newFlipBookImage).show();
				currentFlipBookImageIndex = i;
			}

			//Todo: Play an animation loop when the user clicks on the flipbook.
			/*cameraDoesRespondToMousePosition = false;
			var newFlipBookImage = getCurrentFlipBookImage();
			var startingFlipBookImageIndex = currentFlipBookImageIndex;
			animateToImage(newFlipBookImage);
			function animateToImage(image){
				cameraDoesRespondToMousePosition = false;//Disabled interaction.
				$(image).transition({opacity:0, duration:200, complete:function(){
					currentFlipBookImageIndex++;
					if(currentFlipBookImageIndex >= flipBookImages.length){
						currentFlipBookImageIndex = 0;
					}
					var nextImage = flipBookImages[currentFlipBookImageIndex];
					if(startingFlipBookImageIndex != currentFlipBookImageIndex){
						animateToImage(nextImage);
						cameraDoesRespondToMousePosition = true;//Re-enable interactivity.
					}
				}});
			}*/
		});
	}

	function getCurrentFlipBookImage(){
		/*for(var i in flipBookImages){
			if($(flipBookImages[i]).is(':visible')){
				currentFlipBookImageIndex = i;
				return flipBookImages[i];
			}
		}*/
		return flipBookImages[currentFlipBookImageIndex];
	}

	function isEven(value){
		if (value%2 === 0){
			return true;
		}else{
			return false;
		}
	}

	function setSize(){
		if(renderer){
			renderer.setSize(100,100);//Size down the renderer, so it doesn't stretch out its container.

			//Update the camera size.
			camera.aspect = mainStage__inner.clientWidth/mainStage__inner.clientHeight;
			//camera.aspect = window.innerWidth/mainStage__inner.clientHeight;
			camera.updateProjectionMatrix();

			//Update the renderer size.
			renderer.setSize(mainStage__inner.clientWidth, mainStage__inner.clientHeight);//Set it back to the size of its container.
			//renderer.setSize(window.innerWidth, mainStage__inner.clientHeight);
		}else if(flipBook){
			//Keep images square by setting the height of each image to match its width.
			var size = $(flipBookImages[0]).width();
			$(flipBookImages).css({height:size});
		}
		apply();
	}

	function animateIn(){
		//Fade in lights.
		for(var i in lights){
			var light = lights[i];
			tweenLight(light);//Has to be outside of the loop.
		}
		function tweenLight(light){
			var intensity = light.intensity;
			light.intensity = 0;//Set to 0, so we can fade in.

			var lightsTween = new TWEEN.Tween({intensity:0})
				.to({intensity:intensity}, 2000)
				.easing(TWEEN.Easing.Linear.None)
				.onUpdate(function(){
					light.intensity = this.intensity;
					//render();//Don't call this, because it will create a loop.
				})
				.onComplete(function(){
					//render();
				})
				.start();
		}

		//Move cabinet in from bottom.
		/*var cabinetTween = new TWEEN.Tween({y:-70})
			.to({y:0}, 3000)
			.easing(TWEEN.Easing.Quadratic.Out)
			.onUpdate(function(){
				cabinet.position.y = this.y;
				//render();//Don't call this, because it will create a loop.
			})
			.onComplete(function(){
				transitionToUsersCursor();
				//render();
			})
			.start();*/

		//Fade the cabinet in
		$(renderer.domElement).css({opacity:0}).transition({opacity:1, duration:1500});
		transitionToUsersCursor();

		function transitionToUsersCursor(){
			var defaultCameraPosition = calculateCameraPosition(false);//true makes it calculate the default camera position, without responding to the mouse.
			var newCameraPosition = calculateCameraPosition(true);//The camera position in response to the user's mouse.
			var cabinetTween2 = new TWEEN.Tween(defaultCameraPosition)
				.to(newCameraPosition, 100)
				.easing(TWEEN.Easing.Quadratic.InOut)
				.onUpdate(function(){
					camera.position.set(this.x, this.y, this.z);
					//render();//Don't call this, because it will create a loop.
				})
				.onComplete(function(){
					cameraDoesRespondToMousePosition = true;
					//render();
				})
				.start();
		}
	}

	function onResize(event){
		setSize();//Calls render().
	}

	function onMouseMove(event){
		//return;
		//log(event.clientX + ' ' + event.clientY);
		var w = mainStage__inner.clientWidth;
		var h = mainStage__inner.clientHeight;
		var mouseXRelativeToScene = event.clientX - mainStage__inner.offsetLeft;
		var mouseYRelativeToScene = event.clientY - mainStage__inner.offsetTop;
		var mouseXPxFromCenter = mouseXRelativeToScene - w/2;
		var mouseYPxFromCenter = mouseYRelativeToScene - h/2;
		mouseXPercentageFromCenter = mouseXPxFromCenter / (w/2);
		mouseYPercentageFromCenter = mouseYPxFromCenter / (h/2);

		//Shrink the interaction area by a bit.
		//Reduce the effect to 1/3 of original, if your cursor moves outside of the interaction area.
		var interactionAreaRatio = 0.8;
		mouseXPercentageFromCenter *= interactionAreaRatio;
		mouseYPercentageFromCenter *= interactionAreaRatio;
		var interactionReduction = 1/3;
		var delta = null;
		if(mouseXPercentageFromCenter < -1){
			delta = mouseXPercentageFromCenter+1;
			mouseXPercentageFromCenter = -1 + delta * interactionReduction;
		}
		if(mouseXPercentageFromCenter > 1){
			delta = mouseXPercentageFromCenter-1;
			mouseXPercentageFromCenter = 1 + delta * interactionReduction;
		}
		if(mouseYPercentageFromCenter < -1){
			delta = mouseYPercentageFromCenter+1;
			mouseYPercentageFromCenter = -1 + delta * interactionReduction;
		}
		if(mouseYPercentageFromCenter > 1){
			delta = mouseYPercentageFromCenter-1;
			mouseYPercentageFromCenter = 1 + delta * interactionReduction;
		}

		if(!cameraDoesRespondToMousePosition) return;
		if(renderer){
			apply();
		}
		if(flipBook){
			var currentFlipBookImage = getCurrentFlipBookImage();
			var mouseXPercentageFromLeft = (mouseXPercentageFromCenter + 1)/2;
			var i = Math.floor(flipBookImages.length * mouseXPercentageFromLeft);
			if(i < 0) i = 0;
			if(i > flipBookImages.length - 1){
				i = flipBookImages.length - 1;
			}
			var newFlipBookImage = flipBookImages[i];
			if(newFlipBookImage != currentFlipBookImage){
				//$(currentFlipBookImage).css({'z-index':0});
				//$(newFlipBookImage).css({'z-index':1}).transition({opacity:1, duration:50, complete:function(){
					$(newFlipBookImage).show();
					$(currentFlipBookImage).hide();
					currentFlipBookImageIndex = i;
					cameraDoesRespondToMousePosition = true;//Re-enable interaction.
				//}});
			}
		}
	}

	function apply(){
		if(cabinet){
			var newCameraPosition = calculateCameraPosition(cameraDoesRespondToMousePosition);
			camera.position.set(newCameraPosition.x, newCameraPosition.y, newCameraPosition.z);
		}
	}

	function calculateCameraPosition(respondToMouse){
		//When the cursor is at left ("start"), you see the side of the cabinet from afar and low.
		//When the cursor moves right ("end"), you are looking into the cabinet window.
		/*var cameraPositions = {
			x:{start:-50+cabinet.position.x, end:6+cabinet.position.x},//Move towards front.
			y:{start:36, end:65},//Move up towards window.
			z:{start:80, end:40}//Move
		};*/
		var cameraPositions = {
			x:{start:-80+cabinet.position.x, end:6+cabinet.position.x},//Move towards front.
			y:{start:36, end:65},//Move up towards window.
			z:{start:80, end:50}//Move
		};
		for(var i in cameraPositions){
			var axis = cameraPositions[i];
			axis.midpoint = axis.start + (axis.end - axis.start)/2;
			axis.range = axis.end - axis.start;
		}

		var mouseX = 0;
		var mouseY = 0;
		if(respondToMouse){
			mouseX = mouseXPercentageFromCenter;
			mouseY = mouseYPercentageFromCenter;
		}

		var value = {
			x: cameraPositions.x.midpoint + mouseX * cameraPositions.x.range/2,
			y: cameraPositions.y.midpoint + mouseX * cameraPositions.y.range/2 + 5 * mouseY,
			z: cameraPositions.z.midpoint + mouseX * cameraPositions.z.range/2
		};

		//Adjust settings for small screens.
		/*if(window.innerWidth < 768){
			camera.position.z = 90;//Move the camera backwards.
		}else{
			camera.position.z = 70;//Move the camera backwards.
		}*/

		return value;
	}

	function render(doRequestAnimationFrame){
		if(!inited){
			return;
		}
		if(video){
			if(video.readyState === video.HAVE_ENOUGH_DATA){
				videoTexture.needsUpdate = true;
			}
		}
		if(lights){//Debug
			//lights[0].intensity = 1.5;
			//lights[0].position.set(100,100,100);

			//lights[1].intensity = 1.5;
			//lights[1].position.set(-200,100,100);
		}

		TWEEN.update();
		camera.lookAt(focalPoint);
		renderer.render(scene, camera);
		if(doRequestAnimationFrame){
			requestAnimationFrame(function(){
				render(true);
			});
		}
	}

	Pages.page_scripts["/arcade-era/donkey-kong"] = {
		init: init,
		ready: ready,
		teardown: teardown
	};

})(window,Pages);


text:
/*	$NetBSD: paths.h,v 1.41 2012/06/03 21:42:46 joerg Exp $	*/

/*
 * Copyright (c) 1989, 1993
 *	The Regents of the University of California.  All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 * 3. Neither the name of the University nor the names of its contributors
 *    may be used to endorse or promote products derived from this software
 *    without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
 * SUCH DAMAGE.
 *
 *	@(#)paths.h	8.1 (Berkeley) 6/2/93
 */

#ifndef _PATHS_H_
#define	_PATHS_H_

/*
 * Default user search path.
 * Set by login(1), rshd(8), rexecd(8)
 * Used by execvp(3) absent PATH from the environ(7)
 */
#ifdef RESCUEDIR
#define	_PATH_DEFPATH	RESCUEDIR ":/usr/bin:/bin:/usr/pkg/bin:/usr/local/bin"
#else
#define	_PATH_DEFPATH	"/usr/bin:/bin:/usr/pkg/bin:/usr/local/bin"
#endif

/*
 * All standard utilities path.
 * Set by init(8) for system programs & scripts (e.g. /etc/rc)
 * Used by ttyaction(3), whereis(1)
 */
#define	_PATH_STDPATH \
	"/usr/bin:/bin:/usr/sbin:/sbin:/usr/pkg/bin:/usr/pkg/sbin:/usr/local/bin:/usr/local/sbin"

#define	_PATH_AUDIO	"/dev/audio"
#define	_PATH_AUDIO0	"/dev/audio0"
#define	_PATH_AUDIOCTL	"/dev/audioctl"
#define	_PATH_AUDIOCTL0	"/dev/audioctl0"
#define	_PATH_BPF	"/dev/bpf"
#define	_PATH_CLOCKCTL	"/dev/clockctl"
#define	_PATH_CONSOLE	"/dev/console"
#define	_PATH_CONSTTY	"/dev/constty"
#define _PATH_CPUCTL	"/dev/cpuctl"
#define	_PATH_CSMAPPER	"/usr/share/i18n/csmapper"
#define	_PATH_DEFTAPE	"/dev/nrst0"
#define	_PATH_DEVCDB	"/var/run/dev.cdb"
#define	_PATH_DEVDB	"/var/run/dev.db"
#define	_PATH_DEVNULL	"/dev/null"
#define	_PATH_DRUM	"/dev/drum"
#define	_PATH_ESDB	"/usr/share/i18n/esdb"
#define	_PATH_FTPUSERS	"/etc/ftpusers"
#define	_PATH_GETTYTAB	"/etc/gettytab"
#define	_PATH_I18NMODULE "/usr/lib/i18n"
#define	_PATH_ICONV	"/usr/share/i18n/iconv"
#define	_PATH_KMEM	"/dev/kmem"
#define	_PATH_KSYMS	"/dev/ksyms"
#define	_PATH_KVMDB	"/var/db/kvm.db"
#define	_PATH_LOCALE	"/usr/share/locale"
#define	_PATH_MAILDIR	"/var/mail"
#define	_PATH_MAN	"/usr/share/man"
#define	_PATH_MEM	"/dev/mem"
#define	_PATH_MIXER	"/dev/mixer"
#define	_PATH_MIXER0	"/dev/mixer0"
#define	_PATH_NOLOGIN	"/etc/nologin"
#define _PATH_POWER	"/dev/power"
#define	_PATH_PRINTCAP	"/etc/printcap"
#define	_PATH_PUD	"/dev/pud"
#define	_PATH_PUFFS	"/dev/puffs"
#define	_PATH_RANDOM	"/dev/random"
#define	_PATH_SENDMAIL	"/usr/sbin/sendmail"
#define	_PATH_SHELLS	"/etc/shells"
#define	_PATH_SKEYKEYS	"/etc/skeykeys"
#define	_PATH_SOUND	"/dev/sound"
#define	_PATH_SOUND0	"/dev/sound0"
#define	_PATH_SYSMON	"/dev/sysmon"
#define	_PATH_TTY	"/dev/tty"
#define	_PATH_UNIX	"/netbsd"
#define	_PATH_URANDOM	"/dev/urandom"
#define	_PATH_VIDEO	"/dev/video"
#define	_PATH_VIDEO0	"/dev/video0"

/*
 * Provide trailing slash, since mostly used for building pathnames.
 * See the __CONCAT() macro from <sys/cdefs.h> for cpp examples.
 */
#define	_PATH_DEV	"/dev/"
#define	_PATH_DEV_PTS	"/dev/pts/"
#define	_PATH_EMUL_AOUT	"/emul/aout/"
#define	_PATH_TMP	"/tmp/"
#define	_PATH_VARDB	"/var/db/"
#define	_PATH_VARRUN	"/var/run/"
#define	_PATH_VARTMP	"/var/tmp/"

/*
 * Paths that may change if RESCUEDIR is defined.
 * Used by tools in /rescue.
 */
#ifdef RESCUEDIR
#define	_PATH_BSHELL	RESCUEDIR "/sh"
#define	_PATH_CSHELL	RESCUEDIR "/csh"
#define	_PATH_VI	RESCUEDIR "/vi"
#else
#define	_PATH_BSHELL	"/bin/sh"
#define	_PATH_CSHELL	"/bin/csh"
#define	_PATH_VI	"/usr/bin/vi"
#endif

#endif /* !_PATHS_H_ */


text:
module Probs
include("./samplesGenerator.jl")
export generateChanges
# export ifDetected, notDetected, extractFps, extractTps, belowH, aboveH

function ifDetected(cde::Int64, changes::Vector{Int64}, delay::Int64)
    # 1) If change detection event is TP
    for chp in changes
        if abs(chp - cde) <= delay
            return true
        end
    end
    return false
end

function notDetected(cde::Int64, changes::Vector{Int64}, delay::Int64)
    # 2) If change detection event is not TP
    return ! ifDetected(cde, changes, delay)
end

function extractFps(detections::Vector{Int64},
                    trueChanges::Vector{Int64},
                    delay::Int64)
    # 3) Extract False Positives from a sequence of CDEs
    filter(x->notDetected(x, trueChanges, delay), detections)
end

function extractTps(detections::Vector{Int64},
                    trueChanges::Vector{Int64},
                    delay::Int64)
    # 4) Extract True Positives from a sequence of CDEs
    filter(x->ifDetected(x, trueChanges, delay), detections)
end

function ifPredictedTp(cde::Int64, probs::Vector{Float64}, h::Float64)
    # 5) Check if an individual TP is correctly predicted
    probs[cde] >= h
end

function ifPredictedFp(cde::Int64, probs::Vector{Float64}, h::Float64)
    # 6) Check if an individual FP is correctly ignored
    probs[cde] < h
end

function correctlyPredictedTps(probs::Vector{Float64},
                               trueChanges::Vector{Int64},
                               h::Float64)
    # 7) Given probs vector count those provided true changes for
    # which corresponding probs >= h. Time locations must be integers
    filter(x->ifPredictedTp(x, probs, h), trueChanges)
end

function correctlyPredictedFps(probs::Vector{Float64},
                               fPositives::Vector{Int64},
                               h::Float64)
    # 8) Given probs vector count those provided false alarms for
    # which corresponding probs < h. Time locations must be integers
    filter(x->ifPredictedFp(x, probs, h), fPositives)
end

function belowH(h::Float64, probs::Vector{Float64}, delay::Int64)
    # 9) Returns _indices_ given a vector of probs and threshold
    # function. Returs indices of those elements in probs vector which
    # are below threshold value
    ret :: Vector{Int64}
    subprobs = probs[1 : min(delay, length(probs))]
    ret = find( x -> x <= h, subprobs)
end

function aboveH(h, probs, delayConfirm)
    # 10)
    subprobs = probs[1 : min(delayConfirm, length(probs))]
    find(x->(x>h), subprobs)
end

#function initProbs(mu, sigma)
#    # 11)
#    0
#end
#
#function whichBin(num, edges)
#    # 12) Edges:[1,2,3] Bins:[(-inf,1) (1,2) (2,3) (3, inf)] Bins nums: 1,2,3,4
#    n = length(edges)
#    if num <= edges[1]
#        return 1
#    elseif num > edges[end]
#        return n+1
#    else
#        for i in 2:n
#            if edges[i-1] < num <= edges[i]
#                return i
#            end
#        end
#    end
#end

function gaussPdf(x, mu, sigma)
    k = 1/(sigma * sqrt(2*pi))
    p = k * exp(-((x-mu)^2/(2*sigma^2)))
end

# 13, 14 - don't need
function generateChanges(n, mu, sigma, width)
    # 15) Generate sequence of changes
    changes::Array{Int,1}
    values = 1:width
    weights = map(x->gaussPdf(x, mu, sigma), 1:width)
    samples = genSamples(values, weights, n)
    changes = cumsum(samples)
end

function dynamicH(probs,threshold,hmin,hmax,tmax)
    dynamich::Vector{Float64}
    dynamich=map(probs) do p
        if p>=threshold
            hmin
        else
            hmax
        end
    end
    dynamich[1:tmax]
end

end
#------------------ End module Probs-------------------------#

#------------------------------------------------------------#
# module Pmf
# export gaussPmf
#
# using Distributions
# using Bisect
#
# type GaussPmf
#     # Prototype is in thinkbayes.py/def MakeGaussianPmf(mu, sigma, num_sigmas, n=201):
#     mu         :: Float64
#     sigma      :: Float64
#     num_sigmas :: Int
#     n          :: Int
#     edges      :: Vector{Float64}
#     probs      :: Vector{Float64}
#     function GaussPmf(mu::Float64, sigma::Float64)
#         n_default          = 251
#         num_sigmas_default = 3
#         low                = mu - num_sigmas_default * sigma
#         high               = mu + num_sigmas_default * sigma
#         d                  = Normal(mu, sigma)
#         edges              = linspace(low, high, n_default)
#         probs              = pdf(d, edges)
#         new(mu, sigma, num_sigmas_default, n_default, edges, probs)
#     end
# end
#
# function gaussPmf(gp::GaussPmf, val)
#      Bisect.idx_of_closest(gp.probs, float(val))
# end
#
#end
#----------------- End module Pmf ------------------------------#


text:
var express = require('express'),
  router = module.exports = express.Router();

router.get('/', function (req, res, next) {
  res.end('');
});


text:
      <button mat-raised-button (click)="showOCRDetails()" [disabled]="orcLoading">Show OCR Details XML</button>
      <button mat-raised-button (click)="orderByText()" [disabled]="orcLoading">OrderByText</button>
      <button mat-raised-button (click)="orderByPosition()" [disabled]="orcLoading">OrderByPosition</button>

        <mat-progress-bar mode="indeterminate" class="device-prepare-overlay-progressbar">
        </mat-progress-bar>
        Processing image...It might take couple of seconds...

                    {{item.text}} {{item.bounds}}


text:
class Project < ActiveRecord::Base
  has_many :issues, dependent: :destroy
  has_many :user_projects, dependent: :destroy
  has_many :users, through: :user_projects
  has_many :admin_projects, -> { admin }, class_name: 'UserProject'
  has_many :admins, through: :admin_projects, class_name: 'User', source: :user
  has_many :invites, dependent: :destroy
  has_many :requests, dependent: :destroy

  validates :name, presence: true, length: { minimum: 3, maximum: 40 }

  before_create :generate_authentication_token

  enum technology: { ruby_on_rails: 0 }

  def generate_authentication_token
    self.authentication_token ||= generate_unique_code
  end

  def generate_unique_code
    Digest::SHA1.hexdigest([Time.now, rand].join)
  end

  def invite(email)
    user = User.find_by(email: email)
    if user.present?
      add_user(user)
    else
      invites.where(email: email).first_or_create
    end
  end

  def add_user(user, role = :member)
    user_projects.where(user_id: user.id, role: UserProject.roles[role])
      .first_or_create
  end

  def user?(user)
    user_projects.where(user_id: user.id).present?
  end
end


text:
function(_qi_list_append_uniq _list)
  foreach(_elem ${ARGN})
    list(FIND ${_list} ${_elem} _found)
    if(_found STREQUAL "-1")
      set(${_list} ${${_list}} ${_elem})
    endif()
  endforeach()
  set(${_list} ${${_list}} PARENT_SCOPE)
endfunction()

function(_qi_list_prepend_uniq _list)
  foreach(_elem ${ARGN})
    list(FIND ${_list} ${_elem} _found)
    if(_found STREQUAL "-1")
      list(INSERT ${_list} 0 ${_elem})
    endif()
  endforeach()
  set(${_list} ${${_list}} PARENT_SCOPE)
endfunction()

# Add a value to a list of paths,
# keeping the list sorted, whithout
# duplicates and only canonical paths
function(_qi_list_append_path _list)
  foreach(_path ${ARGN})
    get_filename_component(_abs_path ${_path} REALPATH)
    file(TO_CMAKE_PATH ${_abs_path} _abs_path)
    _qi_list_append_uniq(${_list} ${_abs_path})
  endforeach()
  set(${_list} ${${_list}} PARENT_SCOPE)
endfunction()


text:
package com.microsoft.azure.management.monitor.v2015_04_01;

import rx.Observable;
import com.microsoft.azure.management.monitor.v2015_04_01.implementation.EventCategoriesInner;
import com.microsoft.azure.arm.model.HasInner;

/**
 * Type representing EventCategories.
 */
public interface EventCategories extends HasInner<EventCategoriesInner> {
    /**
     * Get the list of available event categories supported in the Activity Logs Service.<br>The current list includes the following: Administrative, Security, ServiceHealth, Alert, Recommendation, Policy.
     *
     * @throws IllegalArgumentException thrown if parameters fail the validation
     * @return the observable for the request
     */
    Observable<LocalizableString> listAsync();

}


text:
#ifndef LOADER_FINI_H
#define LOADER_FINI_H

#include <types.h>

#ifdef __cplusplus
extern "C"
{
#endif

    /**
     * <!-- description -->
     *   @brief This function contains all of the code that is common between
     *     all archiectures and all platforms that is needed for finalizing
     *     the loader. This function will call platform and architecture specific
     *     functions as needed.
     *
     * <!-- inputs/outputs -->
     *   @return LOADER_SUCCESS on success, LOADER_FAILURE on failure.
     */
    NODISCARD int64_t loader_fini(void) NOEXCEPT;

#ifdef __cplusplus
}
#endif

#endif


text:
require 'tab'
require 'os/mac'
require 'extend/ARGV'
require 'bottle_version'

def bottle_filename options={}
  options = { :tag => bottle_tag }.merge(options)
  "#{options[:name]}-#{options[:version]}#{bottle_native_suffix(options)}"
end

def built_as_bottle? f
  return false unless f.installed?
  tab = Tab.for_keg(f.installed_prefix)
  tab.built_as_bottle
end

def bottle_file_outdated? f, file
  filename = file.basename.to_s
  return nil unless f and f.bottle and f.bottle.url \
    and filename.match(bottle_regex)

  bottle_ext = filename[bottle_native_regex, 1]
  bottle_url_ext = f.bottle.url[bottle_native_regex, 1]

  bottle_ext && bottle_url_ext && bottle_ext != bottle_url_ext
end

def bottle_native_suffix options={}
  options = { :tag => bottle_tag }.merge(options)
  ".#{options[:tag]}#{bottle_suffix(options[:revision])}"
end

def bottle_suffix revision=nil
  revision = revision.to_i > 0 ? ".#{revision}" : ""
  ".bottle#{revision}.tar.gz"
end

def bottle_native_regex
  /(\.#{bottle_tag}\.bottle\.(\d+\.)?tar\.gz)$/o
end

def bottle_regex
  Pathname::BOTTLE_EXTNAME_RX
end

def bottle_url(root_url, filename_options={})
  "#{root_url}/#{bottle_filename(filename_options)}"
end

def bottle_tag
  if MacOS.version >= :lion
    MacOS.cat
  elsif MacOS.version == :snow_leopard
    Hardware::CPU.is_64_bit? ? :snow_leopard : :snow_leopard_32
  else
    # Return, e.g., :tiger_g3, :leopard_g5_64, :leopard_64 (which is Intel)
    if Hardware::CPU.type == :ppc
      tag = "#{MacOS.cat}_#{Hardware::CPU.family}".to_sym
    else
      tag = MacOS.cat
    end
    MacOS.prefer_64_bit? ? "#{tag}_64".to_sym : tag
  end
end

def bottle_filename_formula_name filename
  path = Pathname.new filename
  version = BottleVersion.parse(path).to_s
  basename = path.basename.to_s
  basename.rpartition("-#{version}").first
end

class BottleCollector
  def initialize
    @bottles = {}
  end

  def add(checksum, tag)
    @bottles[tag] = checksum
  end

  def fetch_bottle_for(tag)
    return [@bottles[tag], tag] if @bottles[tag]

    find_altivec_tag(tag) || find_or_later_tag(tag)
  end

  def keys; @bottles.keys; end
  def [](arg); @bottles[arg]; end

  # This allows generic Altivec PPC bottles to be supported in some
  # formulae, while also allowing specific bottles in others; e.g.,
  # sometimes a formula has just :tiger_altivec, other times it has
  # :tiger_g4, :tiger_g5, etc.
  def find_altivec_tag(tag)
    if tag.to_s =~ /(\w+)_(g4|g4e|g5)$/
      altitag = "#{$1}_altivec".to_sym
      return [@bottles[altitag], altitag] if @bottles[altitag]
    end
  end

  # Allows a bottle tag to specify a specific OS or later,
  # so the same bottle can target multiple OSs.
  # Not used in core, used in taps.
  def find_or_later_tag(tag)
    results = @bottles.find_all {|k,v| k.to_s =~ /_or_later$/}
    results.each do |key, hsh|
      later_tag = key.to_s[/(\w+)_or_later$/, 1].to_sym
      bottle_version = MacOS::Version.from_symbol(later_tag)
      return [hsh, key] if bottle_version <= MacOS::Version.from_symbol(tag)
    end

    nil
  end
end


text:
using System;

namespace Stripe.Tests.test_data
{
    public static class stripe_account_create_options
    {
        public static StripeAccountCreateOptions ValidAccountWithCard()
        {
            return new StripeAccountCreateOptions()
            {
                BusinessName = "created-business-name-" + Guid.NewGuid(),
                BusinessPrimaryColor = "#" + new Random().Next(0, 6).ToString("D6"),
                BusinessUrl = "http://created.com/" + Guid.NewGuid(),
                DebitNegativeBalances = true,
                DeclineChargeOnAvsFailure = false,
                DeclineChargeOnCvcFailure = true,
                DefaultCurrency = "usd",
                Email = $"Debra{Guid.NewGuid()}@gmail.com",

                ExternalCardAccount = new StripeAccountCardOptions()
                {
                    AddressCountry = "US",
                    AddressLine1 = "24 Beef Flank St",
                    AddressLine2 = "Apt 24",
                    AddressCity = "BIGGIE",
                    AddressState = "NC",
                    AddressZip = "27617",
                    Cvc = "1223",
                    ExpirationMonth = "10",
                    ExpirationYear = "2021",
                    Name = "Joe Meatballs",
                    Number = "4000056655665556",
                    Currency = "usd",
                    DefaultForCurrency = true
                }
            };
        }

        public static StripeAccountCreateOptions ValidAccountWithBankAccount()
        {
            return new StripeAccountCreateOptions()
            {
                BusinessName = "created-business-name-" + Guid.NewGuid(),
                BusinessPrimaryColor = "#" + new Random().Next(0, 6).ToString("D6"),
                BusinessUrl = "http://created.com/" + Guid.NewGuid(),
                DebitNegativeBalances = true,
                DeclineChargeOnAvsFailure = false,
                DeclineChargeOnCvcFailure = true,
                DefaultCurrency = "usd",

                ExternalBankAccount = new StripeAccountBankAccountOptions()
                {
                    AccountNumber = "000123456789",
                    Country = "US",
                    Currency = "usd",
                    AccountHolderType = "company",
                    AccountHolderName = "Jayme Inc",
                    Name = "Jayme Inc",
                    RoutingNumber = "110000000"
                }
            };
        }
    }
}