text:
namespace Gringo {

// {{{ declaration of ClingoApp

ClingoApp::ClingoApp() { }

static bool parseConst(const std::string& str, std::vector<std::string>& out) {
    out.push_back(str);
    return true;
}

static bool parseText(const std::string&, ClingoOptions& out) {
    out.outputFormat = Gringo::Output::OutputFormat::TEXT;
    return true;
}

void ClingoApp::initOptions(Potassco::ProgramOptions::OptionContext& root) {
    using namespace Potassco::ProgramOptions;
    BaseType::initOptions(root);
    grOpts_.defines.clear();
    grOpts_.verbose = false;
    OptionGroup gringo("Gringo Options");
    gringo.addOptions()
        ("text", storeTo(grOpts_, parseText)->flag(), "Print plain text format")
        ("const,c", storeTo(grOpts_.defines, parseConst)->composing()->arg("<id>=<term>"), "Replace term occurrences of <id> with <term>")
        ("output,o,@1", storeTo(grOpts_.outputFormat = Gringo::Output::OutputFormat::INTERMEDIATE, values<Gringo::Output::OutputFormat>()
          ("intermediate", Gringo::Output::OutputFormat::INTERMEDIATE)
          ("text", Gringo::Output::OutputFormat::TEXT)
          ("reify", Gringo::Output::OutputFormat::REIFY)
          ("smodels", Gringo::Output::OutputFormat::SMODELS)), "Choose output format:\n"
             "      intermediate: print intermediate format\n"
             "      text        : print plain text format\n"
             "      reify       : print program as reified facts\n"
             "      smodels     : print smodels format\n"
             "                    (only supports basic features)")
        ("output-debug,@1", storeTo(grOpts_.outputOptions.debug = Gringo::Output::OutputDebug::NONE, values<Gringo::Output::OutputDebug>()
          ("none", Gringo::Output::OutputDebug::NONE)
          ("text", Gringo::Output::OutputDebug::TEXT)
          ("translate", Gringo::Output::OutputDebug::TRANSLATE)
          ("all", Gringo::Output::OutputDebug::ALL)), "Print debug information during output:\n"
         "      none     : no additional info\n"
         "      text     : print rules as plain text (prefix %%)\n"
         "      translate: print translated rules as plain text (prefix %%%%)\n"
         "      all      : combines text and translate")
        ("warn,W,@1"                   , storeTo(grOpts_, parseWarning)->arg("<warn>")->composing(), "Enable/disable warnings:\n"
         "      none:                     disable all warnings\n"
         "      all:                      enable all warnings\n"
         "      [no-]atom-undefined:      a :- b.\n"
         "      [no-]file-included:       #include \"a.lp\". #include \"a.lp\".\n"
         "      [no-]operation-undefined: p(1/0).\n"
         "      [no-]variable-unbounded:  $x > 10.\n"
         "      [no-]global-variable:     :- #count { X } = 1, X = 1.\n"
         "      [no-]other:               clasp related and uncategorized warnings")
        ("rewrite-minimize,@1"      , flag(grOpts_.rewriteMinimize = false), "Rewrite minimize constraints into rules")
        ("keep-facts,@1"            , flag(grOpts_.keepFacts = false), "Do not remove facts from normal rules")
        ("reify-sccs,@1"            , flag(grOpts_.outputOptions.reifySCCs = false), "Calculate SCCs for reified output")
        ("reify-steps,@1"           , flag(grOpts_.outputOptions.reifySteps = false), "Add step numbers to reified output")
        ("foobar,@4"                , storeTo(grOpts_.foobar, parseFoobar) , "Foobar")
        ;
    root.add(gringo);

    OptionGroup basic("Basic Options");
    basic.addOptions()
        ("mode", storeTo(mode_ = mode_clingo, values<Mode>()
            ("clingo", mode_clingo)
            ("clasp", mode_clasp)
            ("gringo", mode_gringo)),
         "Run in {clingo|clasp|gringo} mode")
        ;
    root.add(basic);
}

void ClingoApp::validateOptions(const Potassco::ProgramOptions::OptionContext& root, const Potassco::ProgramOptions::ParsedOptions& parsed, const Potassco::ProgramOptions::ParsedValues& vals) {
    BaseType::validateOptions(root, parsed, vals);
    if (parsed.count("text") > 0) {
        if (parsed.count("output") > 0) {
            error("'--text' and '--output' are mutually exclusive!");
            exit(Clasp::Cli::E_NO_RUN);
        }
        if (parsed.count("mode") > 0 && mode_ != mode_gringo) {
            error("'--text' can only be used with '--mode=gringo'!");
            exit(Clasp::Cli::E_NO_RUN);
        }
        mode_ = mode_gringo;
    }
    if (parsed.count("output") > 0) {
        if (parsed.count("mode") > 0 && mode_ != mode_gringo) {
            error("'--output' can only be used with '--mode=gringo'!");
            exit(Clasp::Cli::E_NO_RUN);
        }
        mode_ = mode_gringo;
    }
}

Clasp::ProblemType ClingoApp::getProblemType() {
    if (mode_ != mode_clasp) return Clasp::Problem_t::Asp;
    return Clasp::ClaspFacade::detectProblemType(getStream());
}
ClingoApp::ClaspOutput* ClingoApp::createOutput(ProblemType f) {
    if (mode_ == mode_gringo) return 0;
    return BaseType::createOutput(f);
}

void ClingoApp::printHelp(const Potassco::ProgramOptions::OptionContext& root) {
    BaseType::printHelp(root);
    printf("\nclingo is part of Potassco: %s\n", "https://potassco.org/clingo");
    printf("Get help/report bugs via : https://potassco.org/support\n");
    fflush(stdout);
}

void ClingoApp::printVersion() {
    char const *py_version = clingo_script_version_(clingo_ast_script_type_python);
    char const *lua_version = clingo_script_version_(clingo_ast_script_type_lua);
    Potassco::Application::printVersion();
    printf("\n");
    printf("libgringo version " CLINGO_VERSION "\n");
    printf("Configuration: %s%s, %s%s\n",
         py_version ? "with Python " : "without Python", py_version ?  py_version : "",
        lua_version ? "with Lua "    : "without Lua",   lua_version ? lua_version : "");
    printf("\n");
    BaseType::printLibClaspVersion();
	printf("\n");
	BaseType::printLicense();
}
bool ClingoApp::onModel(Clasp::Solver const& s, Clasp::Model const& m) {
    bool ret = !grd || grd->onModel(m);
    return BaseType::onModel(s, m) && ret;
}
void ClingoApp::shutdown() {
    // TODO: can be removed in future...
    //       or could be bound differently given the new interface...
    if (grd) grd->solveFuture_ = nullptr;
    Clasp::Cli::ClaspAppBase::shutdown();
}
void ClingoApp::onEvent(Clasp::Event const& ev) {
#if CLASP_HAS_THREADS
    Clasp::ClaspFacade::StepReady const *r = Clasp::event_cast<Clasp::ClaspFacade::StepReady>(ev);
    if (r && grd) { grd->onFinish(r->summary->result); }
#endif
    BaseType::onEvent(ev);
}
void ClingoApp::run(Clasp::ClaspFacade& clasp) {
    try {
        using namespace std::placeholders;
        if (mode_ != mode_clasp) {
            ProblemType     pt  = getProblemType();
            Clasp::ProgramBuilder* prg = &clasp.start(claspConfig_, pt);
            grOpts_.verbose = verbose() == UINT_MAX;
            Clasp::Asp::LogicProgram* lp = mode_ != mode_gringo ? static_cast<Clasp::Asp::LogicProgram*>(prg) : 0;
            grd = Gringo::gringo_make_unique<ClingoControl>(g_scripts(), mode_ == mode_clingo, clasp_.get(), claspConfig_, std::bind(&ClingoApp::handlePostGroundOptions, this, _1), std::bind(&ClingoApp::handlePreSolveOptions, this, _1), nullptr, 20);
            grd->parse(claspAppOpts_.input, grOpts_, lp);
            grd->main();
        }
        else {
            ClaspAppBase::run(clasp);
        }
    }
    catch (Gringo::GringoError const &e) {
        std::cerr << e.what() << std::endl;
        throw std::runtime_error("fatal error");
    }
    catch (...) { throw; }
}

// }}}

} // namespace Gringo

extern "C" CLINGO_VISIBILITY_DEFAULT int clingo_main_(int argc, char *argv[]) {
    Gringo::ClingoApp app;
    return app.main(argc, argv);
}


text:
<?php

/*
 * This file is part of the PHP CS utility.
 *
 * (c) Fabien Potencier <fabien@symfony.com>
 *
 * This source file is subject to the MIT license that is bundled
 * with this source code in the file LICENSE.
 */

namespace Symfony\CS\Fixer\Symfony;

use Symfony\CS\AbstractFixer;
use Symfony\CS\Tokenizer\Token;
use Symfony\CS\Tokenizer\Tokens;

/**
 * @author Dariusz Rumiński <dariusz.ruminski@gmail.com>
 */
final class UnalignDoubleArrowFixer extends AbstractFixer
{
    /**
     * {@inheritdoc}
     */
    public function isCandidate(Tokens $tokens)
    {
        return $tokens->isTokenKindFound(T_DOUBLE_ARROW);
    }

    /**
     * {@inheritdoc}
     */
    public function getDescription()
    {
        return 'Unalign double arrow symbols.';
    }

    /**
     * {@inheritdoc}
     */
    public function fix(\SplFileInfo $file, Tokens $tokens)
    {
        foreach ($tokens as $index => $token) {
            if (!$token->isGivenKind(T_DOUBLE_ARROW)) {
                continue;
            }

            $this->fixWhitespace($tokens[$index - 1]);
            $this->fixWhitespace($tokens[$index + 1]);
        }
    }

    /**
     * If given token is a single line whitespace then fix it to be a single space.
     *
     * @param Token $token
     */
    private function fixWhitespace(Token $token)
    {
        if ($token->isWhitespace(" \t")) {
            $token->setContent(' ');
        }
    }
}

redpajama_set_name: RedPajamaGithub


text:
```shell
sudo yum install epel-release
sudo yum install python36

```


text:
layout: attachment
title: Motor Shield Power and Motor Connections
date:
type: attachment
published: false
status: inherit
categories: []
tags: []
meta:
  _wp_attached_file: 2012/08/imag0123.jpg
  _wp_attachment_image_alt: Motor Shield Power and Motor Connections
author:
  login: AlexDGlover
  email: alex@alexdglover.com
  display_name: AlexDGlover
  first_name: Alex
  last_name: Glover
excerpt: Motor Shield Power and Motor Connections
---

Motor Shield Power and Motor Connections


text:
using Orleans.Serialization.Cloning;
using Orleans.Serialization.Serializers;
using System.Collections;
using System.Collections.Generic;

namespace Orleans.Serialization.Codecs
{
    /// <summary>
    /// Serializer for <see cref="ArrayList"/>.
    /// </summary>
    [RegisterSerializer]
    public sealed class ArrayListCodec : GeneralizedReferenceTypeSurrogateCodec<ArrayList, ArrayListSurrogate>
    {
        /// <summary>
        /// Initializes a new instance of the <see cref="ArrayListCodec"/> class.
        /// </summary>
        /// <param name="surrogateSerializer">The surrogate serializer.</param>
        public ArrayListCodec(IValueSerializer<ArrayListSurrogate> surrogateSerializer) : base(surrogateSerializer)
        {
        }

        /// <inheritdoc/>
        public override ArrayList ConvertFromSurrogate(ref ArrayListSurrogate surrogate) => surrogate.Values switch
        {
            null => default,
            object => new ArrayList(surrogate.Values)
        };

        /// <inheritdoc/>
        public override void ConvertToSurrogate(ArrayList value, ref ArrayListSurrogate surrogate)
        {
            if (value is null)
            {
                surrogate = default;
            }
            else
            {
                var result = new List<object>(value.Count);
                foreach (var item in value)
                {
                    result.Add(item);
                }

                surrogate = new ArrayListSurrogate
                {
                    Values = result
                };
            }
        }
    }

    /// <summary>
    /// Surrogate type used by <see cref="ArrayListCodec"/>.
    /// </summary>
    [GenerateSerializer]
    public struct ArrayListSurrogate
    {
        /// <summary>
        /// Gets or sets the values.
        /// </summary>
        /// <value>The values.</value>
        [Id(1)]
        public List<object> Values { get; set; }
    }

    /// <summary>
    /// Copier for <see cref="ArrayList"/>.
    /// </summary>
    [RegisterCopier]
    public sealed class ArrayListCopier : IDeepCopier<ArrayList>, IBaseCopier<ArrayList>
    {
        private readonly IDeepCopier<object> _copier;

        /// <summary>
        /// Initializes a new instance of the <see cref="ArrayListCopier"/> class.
        /// </summary>
        /// <param name="copier">The copier.</param>
        public ArrayListCopier(IDeepCopier<object> copier)
        {
            _copier = copier;
        }

        /// <inheritdoc/>
        public ArrayList DeepCopy(ArrayList input, CopyContext context)
        {
            if (context.TryGetCopy<ArrayList>(input, out var result))
            {
                return result;
            }

            if (input.GetType() != typeof(ArrayList))
            {
                return context.DeepCopy(input);
            }

            result = new ArrayList(input.Count);
            context.RecordCopy(input, result);
            foreach (var item in input)
            {
                result.Add(_copier.DeepCopy(item, context));
            }

            return result;
        }

        /// <inheritdoc/>
        public void DeepCopy(ArrayList input, ArrayList output, CopyContext context)
        {
            foreach (var item in input)
            {
                output.Add(_copier.DeepCopy(item, context));
            }
        }
    }
}


text:
using System;
using System.Collections.Generic;
using System.Linq;
using System.Net;
using System.Threading.Tasks;
using EasyRpc.AspNetCore.Errors;

namespace EasyRpc.AspNetCore.Serializers
{
    /// <summary>
    /// Abstract base class for content serializer
    /// </summary>
    public abstract class BaseSerializer : IContentSerializer
    {
        /// <summary>
        /// Error handler for serializer
        /// </summary>
        protected IErrorHandler ErrorHandler;

        /// <summary>
        /// Default constructor
        /// </summary>
        /// <param name="errorHandler"></param>
        protected BaseSerializer(IErrorHandler errorHandler)
        {
            ErrorHandler = errorHandler;
        }

        /// <inheritdoc />
        public abstract IEnumerable<string> SupportedContentTypes { get; }

        /// <inheritdoc />
        public virtual bool IsDefault { get; set; }

        /// <inheritdoc />
        public abstract bool CanDeserialize(RequestExecutionContext context, string contentType);

        /// <inheritdoc />
        public abstract bool CanSerialize(RequestExecutionContext context, string accepts);

        /// <inheritdoc />
        public abstract Task SerializeToResponse(RequestExecutionContext context);

        /// <inheritdoc />
        public abstract ValueTask<T> DeserializeFromRequest<T>(RequestExecutionContext context);

        /// <summary>
        /// Set success code and content type in response
        /// </summary>
        /// <param name="context"></param>
        /// <param name="contentType"></param>
        protected void SetStatusAndContent(RequestExecutionContext context, string contentType)
        {
            context.HttpContext.Response.ContentType = contentType;

            context.HttpContext.Response.StatusCode = context.HttpStatusCode;
        }
    }
}


text:
// <summary>
//   The product.
// </summary>
namespace Chloroplastiq.Grammar
{
    using System;
    using System.Collections.Generic;
    using System.Text;

    /// <summary>
    /// The product.
    /// </summary>
    public class Product
    {
        #region Constructors and Destructors

        /// <summary>
        /// Initializes a new instance of the <see cref="Product"/> class.
        /// </summary>
        /// <param name="w">
        /// The w.
        /// </param>
        /// <param name="p">
        /// The p.
        /// </param>
        public Product(string w, Dictionary<char, string> p)
        {
            this.Axiom = w;
            this.Alphabet = this.Axiom;
            this.Rules = p;
        }

        #endregion

        #region Fields

        /// <summary>
        /// Gets or sets the alphabet.
        /// </summary>
        public string Alphabet { get; set; }

        /// <summary>
        /// Gets or sets the rules.
        /// </summary>
        public IDictionary<char, string> Rules { get; set; }

        #endregion

        // / <summary>
        // / Gets or sets Axiom
        // / </summary>

        // / <summary>
        // / Gets or sets Angle
        // / </summary>
        #region Public Properties

        /// <summary>
        /// Gets or sets the angle.
        /// </summary>
        public float Angle { get; set; }

        /// <summary>
        /// Gets or sets the axiom.
        /// </summary>
        public string Axiom { get; set; }

        // / <summary>
        // / Gets or sets Iterations
        // / </summary>

        /// <summary>
        /// Gets or sets the iterations.
        /// </summary>
        public ushort Iterations { get; set; }

        #endregion

        #region Public Methods and Operators

        /// <summary>
        /// The yield.
        /// </summary>
        /// <param name="current">
        /// The current.
        /// </param>
        /// <param name="iter">
        /// The iteration.
        /// </param>
        /// <param name="rules">
        /// The rules.
        /// </param>
        /// <returns>
        /// The <see cref="string"/>.
        /// </returns>
        public string Yield(string current, int iter, IDictionary<char, string> rules)
        {
            var next = new string[current.Length]; // create an array representing the smallest possible substrings
            var none = true;
            for (var i = 0; i < current.Length; i++)
            {
                var c = current[i];
                foreach (var r in rules)
                {
                    if (c == r.Key)
                    {
                        // If it matches, replace that string with the successor
                        next[i] = r.Value;
                        none = false;
                    }
                }

                if (none)
                {
                    // If no rules apply, leave the symbol the same
                    next[i] = c.ToString();
                }

                none = true;
            }

            var result = new StringBuilder();
            foreach (var s in next)
            {
                result.Append(s);
            }

            Console.WriteLine(result);

            if (iter == 0)
            {
                return result.ToString();
            }

            return this.Yield(result.ToString(), iter - 1, rules);
        }

        #endregion
    }
}


text:
<TITLE>Review for Devil's Advocate, The (1997)</TITLE>
<LINK REL="STYLESHEET" TYPE="text/css" HREF="/ramr.css">

Devil's Advocate, The (1997)

reviewed by
Randy Turgeon

The Devil's Advocate

Summary

A hotshot lawyer gets an obviously guilty child molester acquitted, and
shortly after during the victory celebration gets offered an opportunity to
show his prowess in New York City. The lawyer, Kevin Lomax (Keanu Reeves)
is not offered a job yet, he is asked to simply pick a jury. He accepts.
The jury he selects work out well and before long he is offered a job with
the firm. Making his decision easy is the fact that not only is he offered
big money, but a gorgeous apartment. He convinces his wife, Mary Ann
(Charlize Theron) to make the move to New York.

The first case given to him is a big test; a "winless" case concerning a
man who sacrifices animals in his basement. The charge was health code
violations and Kevin once again shows his skill and earns an acquittal. His
new boss and partner in the firm, John Milton (Al Pacino) is quite
impressed and takes Kevin under his wing, explaining many of his
philosophies on law, women and sex, and angles the promise of a blissful,
wealthy life. Kevin's next case is a dream case, given to him by Milton
himself (much to the chagrin to his colleagues), defending a triple murder
suspect who has had a history of problems with the law.

Although Kevin's career is taking off, his home life is not doing very
well. Mary Ann is starting to have numerous problems. She is experiencing
severe depression over Kevin's long hours, and before long is having
horrible dreams and hallucinations of people turning into ghouls, their
faces becoming horribly disfigured. Kevin does not help matters by
dismissing his wife. He does not spend more time with her as he explains to
Milton that he needs to spend as much time on the case as possible to get
it over with, then focus all of his attention on his wife. Not helping
matters is the fact that Kevin is having ideas about a possible affair with
a sexy lawyer (Connie Nielson) also working with the firm.

Mary Ann falls deeper into her madness as Kevin spends more time away from
home. Kevin eventually looses control of his life and has to
institutionalize his wife, and gets disturbing news from his mother (Judith
Ivey) about the mystery concerning the identity of his father. He also
starts to lose control of his case.
Kevin learns that all of his problems have been caused by the work of one
man. That man is his boss, Mr. Milton, a truly evil character who just may
be the devil himself. Kevin must somehow confront Milton and thwart
whatever diabolical plan he has in store. But how do you defeat the devil?

Commentary

Why is it that most courtroom scenes in the movies are absurd? Do
filmmakers really believe that "normal" courtroom drama doesn't fit the
bill and they have to juice them up? The courtroom scenes in this movie
would never happen in a real courtroom, which wouldn't have been too bad if
it weren't Keanu Reeves trying to pull it off. I give Reeves credit for
trying hard, but throughout the movie I never saw the Kevin Lomax
character, just an actor trying very hard to play Kevin Lomax and coming up
short. Charlize Theron defines the term "over-the-top" in her performance
as Mary Ann Lomax, a disappointment in contrast to her good performance in
"2 Days in the Valley".

The only good performance in the movie is by Al Pacino, but I kept asking
myself what the heck he was doing in this mess? Maybe he felt it would be
interesting playing the devil, and you can tell he is having fun doing so,
but his skill as an actor cannot save the poor performances and lackluster
script that surround him. It's pretty standard stuff, including the fact
that the hotshot lawyer appears to be the only competent person on the
planet who can do anything right in the courtroom.

Please read no further if you do not want the ending spoiled, but I have
to get something off of my chest. In 1986 I remember watching a movie
called "Wisdom" with Emilio Estevez and Demi Moore, and the ending of that
film did the worst possible thing that a movie could do. What I like to
call "Guess what, it was all a dream" scenario. In "Wisdom" the two lead
characters are killed at the end, only to have one of the characters "wake
up" from an apparent and say "Gosh, I'm glad that didn't really happen!". I
considered it inexcusable the way the audience was toyed with. Well, the
same thing happens in "The Devils Advocate", and although arguments could
be made surrounding whether it was actually a dream (perhaps Milton went
back in time to try a different route for his plan, since it failed and he
is the Devil), but the point is that the last 90% of the film didn't
happen. I know it's a stretch, after all it is a movie and nothing really
happened, but I just get annoyed to get toyed with like that.

Of course, the dream ending could almost be forgiven if the story that
precedes it was at least an interesting one. As I recall, "Wisdom" was a
decent film. "The Devil's Advocate" is not.

The Devils Advocate * (out of five)

Directed by Taylor Hackford
John Milton..................Al Pacino
Kevin Lomax................Keanu Reeves
Mary Ann Lomax...........Charlize Theron
Mrs. Lomax..................Judith Ivey
Eddie Barzoon...............Jeffrey Jones
Christabella..................Connie Nielson

Written by Randy Turgeon, March 18, 1998.

Randy Turgeon

Come see our web site!
www.xtdl.com/~canran

The review above was posted to the
rec.arts.movies.reviews newsgroup (de.rec.film.kritiken for German reviews).

The Internet Movie Database accepts no responsibility for the contents of the
review and has no editorial control. Unless stated otherwise, the copyright
belongs to the author.

Please direct comments/criticisms of the review to relevant newsgroups.

Broken URLs inthe reviews are the responsibility of the author.

The formatting of the review is likely to differ from the original due
to ASCII to HTML conversion.

Related links: index of all rec.arts.movies.reviews reviews


text:
#ifndef DEBUGGER_PROCESS_H
#define DEBUGGER_PROCESS_H

#include "Debugger.Global.h"
#include "Debugger.Thread.h"
#include "Debugger.Dll.h"
#include "Debugger.Breakpoint.h"
#include "Static.Pattern.h"

namespace GleeBug
{
    /**
    \brief Process information structure.
    */
    class Process
    {
    public:
        HANDLE hProcess;
        uint32 dwProcessId;
        uint32 dwMainThreadId;
        CREATE_PROCESS_DEBUG_INFO createProcessInfo; //hFile is invalid, possibly other handles too!

        Thread* thread;
        bool systemBreakpoint;
        bool permanentDep;

        ThreadMap threads;
        BreakpointMap breakpoints;
        SoftwareBreakpointMap softwareBreakpointReferences;
        BreakpointCallbackMap breakpointCallbacks;
        BreakpointInfo hardwareBreakpoints[4];
        MemoryBreakpointSet memoryBreakpointRanges;
        MemoryBreakpointMap memoryBreakpointPages;

        /**
        \brief Constructor.
        \param hProcess Process handle.
        \param dwProcessId Identifier for the process.
        \param dwMainThreadId Identifier for the main thread.
        \param createProcessInfo The process creation info.
        */
        explicit Process(HANDLE hProcess, uint32 dwProcessId, uint32 dwMainThreadId, const CREATE_PROCESS_DEBUG_INFO & createProcessInfo);

        /**
        \brief Copy constructor.
        */
        Process(const Process &) = delete;

        /**
        \brief Read memory from the process.
        \param address The virtual address to read from.
        \param [out] buffer Destination buffer. Cannot be null. May be filled partially on failure.
        \param size The size to read.
        \param bytesRead (Optional) Number of bytes read (should be equal to size on success).
        \param safe Whether to call MemReadSafe or MemReadUnsafe.
        \return true if it succeeds, false if it fails.
        */
        bool MemRead(ptr address, void* buffer, ptr size, ptr* bytesRead = nullptr, bool safe = true) const
        {
            if(safe)
                return MemReadSafe(address, buffer, size, bytesRead);
            return MemRead(address, buffer, size, bytesRead);
        }

        /**
        \brief Read memory from the process. This function should be used for internal reasons only!
        \param address The virtual address to read from.
        \param [out] buffer Destination buffer. Cannot be null. May be filled partially on failure.
        \param size The size to read.
        \param bytesRead (Optional) Number of bytes read (should be equal to size on success).
        \return true if it succeeds, false if it fails.
        */
        bool MemReadUnsafe(ptr address, void* buffer, ptr size, ptr* bytesRead = nullptr) const;

        /**
        \brief Safely read memory from the process, filtering out breakpoint bytes.
        \param address The virtual address to read from.
        \param [out] buffer Destination buffer. Cannot be null. May be filled partially on failure.
        \param size The size to read.
        \param bytesRead (Optional) Number of bytes read (should be equal to size on success).
        \return true if it succeeds, false if it fails.
        */
        bool MemReadSafe(ptr address, void* buffer, ptr size, ptr* bytesRead = nullptr) const;

        /**
        \brief Write memory to the process.
        \param address The virtual address to write to.
        \param [in] buffer Source buffer. Cannot be null.
        \param size The size to write.
        \param bytesWritten (Optional) Number of bytes written (should be equal to size on success).
        \param safe Wheter to call MemWriteSafe or MemWriteUnsafe.
        \return true if it succeeds, false if it fails.
        */
        bool MemWrite(ptr address, const void* buffer, ptr size, ptr* bytesWritten = nullptr, bool safe = true)
        {
            if(safe)
                return MemWriteSafe(address, buffer, size, bytesWritten);
            return MemWriteUnsafe(address, buffer, size, bytesWritten);
        }

        /**
        \brief Write memory to the process. This function should be used for internal reasons only!
        \param address The virtual address to write to.
        \param [in] buffer Source buffer. Cannot be null.
        \param size The size to write.
        \param bytesWritten (Optional) Number of bytes written (should be equal to size on success).
        \return true if it succeeds, false if it fails.
        */
        bool MemWriteUnsafe(ptr address, const void* buffer, ptr size, ptr* bytesWritten = nullptr);

        /**
        \brief Safely write memory to the process, preserving breakpoint bytes.
        \param address The virtual address to write to.
        \param [in] buffer Source buffer. Cannot be null.
        \param size The size to write.
        \param bytesWritten (Optional) Number of bytes written (should be equal to size on success).
        \return true if it succeeds, false if it fails.
        */
        bool MemWriteSafe(ptr address, const void* buffer, ptr size, ptr* bytesWritten = nullptr);

        /**
        \brief Check if an address is a valid read pointer.
        \param address The address to check.
        \return true if the address is valid, false otherwise.
        */
        bool MemIsValidPtr(ptr address) const;

        /**
        \brief Memory protect (execute VirtualProtect in the context of the process).
        \param address The address to change protection for.
        \param size The size to change protection for.
        \param newProtect The new protection.
        \param [out] oldProtect The old protection.
        \return true if it succeeds, false if it fails.
        */
        bool MemProtect(ptr address, ptr size, DWORD newProtect, DWORD* oldProtect = nullptr);

        /**
        \brief Finds the first occurrence of a pattern in process memory.
        \param data The address to start searching from.
        \param datasize The size to search in.
        \param pattern The pattern to find.
        \param safe Use the safe memory functions (eg do not consider software breakpoint data).
        \return Memory address when found, 0 when not found.
        */
        ptr MemFindPattern(ptr data, size_t datasize, const Pattern::WildcardPattern & pattern, bool safe = true) const;

        /**
        \brief Finds the first occurrence of a pattern in process memory.
        \param data The address to start searching from.
        \param datasize The size to search in.
        \param pattern The pattern to find.
        \param safe Use the safe memory functions (eg do not consider software breakpoint data).
        \return Memory address when found, 0 when not found.
        */
        ptr MemFindPattern(ptr data, size_t datasize, const std::string & pattern, bool safe = true) const
        {
            return MemFindPattern(data, datasize, Pattern::Transform(pattern), safe);
        }

        /**
        \brief Finds the first occurrence of a pattern in process memory.
        \param data The address to start searching from.
        \param datasize The size to search in.
        \param pattern The pattern to find.
        \param patternsize The size of the pattern to find.
        \param safe Use the safe memory functions (eg do not consider software breakpoint data).
        \return Memory address when found, 0 when not found.
        */
        ptr MemFindPattern(ptr data, size_t datasize, const uint8* pattern, size_t patternsize, bool safe = true) const;

        /**
        \brief Writes a pattern in process memory. This function writes as many bytes as possible from the pattern.
        \param [in,out] data The address to write the pattern in.
        \param datasize The size to write in.
        \param pattern Specifies the pattern.
        \param safe Use the safe memory functions (eg do not consider software breakpoint data).
        \return true if it succeeds, false if it fails.
        */
        bool MemWritePattern(ptr data, size_t datasize, const Pattern::WildcardPattern & pattern, bool safe = true);

        /**
        \brief Writes a pattern in process memory. This function writes as many bytes as possible from the pattern.
        \param [in,out] data The address to write the pattern in.
        \param datasize The size to write in.
        \param pattern Specifies the pattern. The pattern supports wildcards (1? ?? ?6 78).
        \param safe Use the safe memory functions (eg do not consider software breakpoint data).
        \return true if it succeeds, false if it fails.
        */
        bool MemWritePattern(ptr data, size_t datasize, const std::string & pattern, bool safe = true)
        {
            return MemWritePattern(data, datasize, Pattern::Transform(pattern), safe);
        }

        /**
        \brief Search and replace a pattern in process memory.
        \param [in,out] data The address to search and replace in.
        \param datasize The size to search and replace in.
        \param searchpattern The pattern to find.
        \param replacepattern The pattern to replace the found occurrence with.
        \param safe Use the safe memory functions (eg do not consider software breakpoint data).
        \return true if it succeeds, false if it fails.
        */
        bool MemSearchAndReplace(ptr data, size_t datasize, const Pattern::WildcardPattern & searchpattern, const Pattern::WildcardPattern & replacepattern, bool safe = true);

        /**
        \brief Search and replace a pattern in process memory.
        \param [in,out] data The address to search and replace in.
        \param datasize The size to search and replace in.
        \param searchpattern The pattern to find. The pattern supports wildcards (1? ?? ?6 78).
        \param replacepattern The pattern to replace the found occurrence with. The pattern supports wildcards (1? ?? ?6 78).
        \param safe Use the safe memory functions (eg do not consider software breakpoint data).
        \return true if it succeeds, false if it fails.
        */
        bool MemSearchAndReplace(ptr data, size_t datasize, const std::string & searchpattern, const std::string & replacepattern, bool safe = true)
        {
            return MemSearchAndReplace(data, datasize, Pattern::Transform(searchpattern), Pattern::Transform(replacepattern), safe);
        }

        /**
        \brief Sets a software breakpoint.
        \param address The address to set the breakpoint on.
        \param singleshoot (Optional) True to remove the breakpoint after the first hit.
        \param type (Optional) The software breakpoint type.
        \return true if the breakpoint was set, false otherwise.
        */
        bool SetBreakpoint(ptr address, bool singleshoot = false, SoftwareType type = SoftwareType::ShortInt3);

        /**
        \brief Sets a software breakpoint.
        \param address The address to set the breakpoint on.
        \param cbBreakpoint The breakpoint callback. Can be written using BIND1(this, MyDebugger::cb).
        \param singleshoot (Optional) True to remove the breakpoint after the first hit.
        \param type (Optional) The software breakpoint type.
        \return true if the breakpoint was set, false otherwise.
        */
        bool SetBreakpoint(ptr address, const BreakpointCallback & cbBreakpoint, bool singleshoot = false, SoftwareType type = SoftwareType::ShortInt3);

        /**
        \brief Sets a software breakpoint.
        \tparam T Generic type parameter. Must be a subclass of Debugger.
        \param address The address to set the breakpoint on.
        \param debugger This pointer to a subclass of Debugger.
        \param callback Pointer to the callback. Written like: &MyDebugger::cb
        \param singleshoot (Optional) True to remove the breakpoint after the first hit.
        \param type (Optional) The software breakpoint type.
        \return true if the breakpoint was set, false otherwise.
        */
        template <typename T>
        bool SetBreakpoint(ptr address, T* debugger, void(T::*callback)(const BreakpointInfo & info), bool singleshoot = false, SoftwareType type = SoftwareType::ShortInt3)
        {
            static_cast<void>(static_cast<Debugger*>(debugger));
            return SetBreakpoint(address, std::bind(callback, debugger, std::placeholders::_1), singleshoot, type);
        }

        /**
        \brief Deletes a software breakpoint.
        \param address The address to delete the breakpoint from.
        \return true if the breakpoint was deleted, false otherwise.
        */
        bool DeleteBreakpoint(ptr address);

        /**
        \brief Attempts to find a free hardware breakpoint slot.
        \param [out] slot First free slot found, has no meaning when the function fails.
        \return true if a free slot was found, false otherwise.
        */
        bool GetFreeHardwareBreakpointSlot(HardwareSlot & slot) const;

        /**
        \brief Sets a hardware breakpoint.
        \param address The address to set the hardware breakpoint on.
        \param slot The hardware breakpoint register slot. Use Process::GetFreeHardwareBreakpointSlot.
        \param type (Optional) The hardware breakpoint type.
        \param size (Optional) The hardware breakpoint size.
        \param singleshoot (Optional) True to remove the breakpoint after the first hit.
        \return true if the hardware breakpoint was set, false otherwise.
        */
        bool SetHardwareBreakpoint(ptr address, HardwareSlot slot, HardwareType type = HardwareType::Execute, HardwareSize size = HardwareSize::SizeByte, bool singleshoot = false);

        /**
        \brief Sets a hardware breakpoint.
        \param address The address to set the hardware breakpoint on.
        \param slot The hardware breakpoint register slot. Use Process::GetFreeHardwareBreakpointSlot.
        \param cbBreakpoint The breakpoint callback. Can be written using BIND1(this, MyDebugger::cb).
        \param type (Optional) The hardware breakpoint type.
        \param size (Optional) The hardware breakpoint size.
        \param singleshoot (Optional) True to remove the breakpoint after the first hit.
        \return true if the hardware breakpoint was set, false otherwise.
        */
        bool SetHardwareBreakpoint(ptr address, HardwareSlot slot, const BreakpointCallback & cbBreakpoint, HardwareType type = HardwareType::Execute, HardwareSize size = HardwareSize::SizeByte, bool singleshoot = false);

        /**
        \brief Sets a hardware breakpoint.
        \tparam T Generic type parameter. Must be a subclass of Debugger.
        \param address The address to set the hardware breakpoint on.
        \param slot The hardware breakpoint register slot. Use Process::GetFreeHardwareBreakpointSlot.
        \param debugger This pointer to a subclass of Debugger.
        \param callback Pointer to the callback. Written like: &MyDebugger::cb
        \param type (Optional) The hardware breakpoint type.
        \param size (Optional) The hardware breakpoint size.
        \param singleshoot (Optional) True to remove the breakpoint after the first hit.
        \return true if the hardware breakpoint was set, false otherwise.
        */
        template <typename T>
        bool SetHardwareBreakpoint(ptr address, HardwareSlot slot, T* debugger, void(T::*callback)(const BreakpointInfo & info), HardwareType type = HardwareType::Execute, HardwareSize size = HardwareSize::SizeByte, bool singleshoot = false)
        {
            static_cast<void>(static_cast<Debugger*>(debugger));
            return SetHardwareBreakpoint(address, slot, std::bind(callback, debugger, std::placeholders::_1), type, size, singleshoot);
        }

        /**
        \brief Deletes a hardware breakpoint.
        \param address The address the hardware breakpoint is set on.
        \return true if the hardware breakpoint was deleted, false otherwise.
        */
        bool DeleteHardwareBreakpoint(ptr address);

        /**
        \brief Sets new page protection to trigger an exception for certain memory breakpoint types.
        \param page The page address.
        \param data The current protection of the page.
        \param type The memory breakpoint type to trigger an exception for.
        \return true if it succeeds, false if it fails.
        */
        bool SetNewPageProtection(ptr page, MemoryBreakpointData & data, MemoryType type);

        /**
        \brief Sets a memory breakpoint.
        \param address The address to set the memory breakpoint on.
        \param size Size of the memory breakpoint (in bytes).
        \param type (Optional) The memory breakpoint type.
        \param singleshoot (Optional) True to remove the breakpoint after the first hit.
        \return true if the memory breakpoint was set, false otherwise.
        */
        bool SetMemoryBreakpoint(ptr address, ptr size, MemoryType type = MemoryType::Access, bool singleshoot = true);

        /**
        \brief Sets a memory breakpoint.
        \param address The address to set the memory breakpoint on.
        \param size Size of the memory breakpoint (in bytes).
        \param cbBreakpoint The breakpoint callback. Can be written using BIND1(this, MyDebugger::cb).
        \param type (Optional) The memory breakpoint type.
        \param singleshoot (Optional) True to remove the breakpoint after the first hit.
        \return true if the memory breakpoint was set, false otherwise.
        */
        bool SetMemoryBreakpoint(ptr address, ptr size, const BreakpointCallback & cbBreakpoint, MemoryType type = MemoryType::Access, bool singleshoot = true);

        /**
        \brief Sets a hardware breakpoint.
        \tparam T Generic type parameter. Must be a subclass of Debugger.
        \param address The address to set the hardware breakpoint on.
        \param size Size of the memory breakpoint (in bytes).
        \param debugger This pointer to a subclass of Debugger.
        \param callback Pointer to the callback. Written like: &MyDebugger::cb
        \param type (Optional) The memory breakpoint type.
        \param singleshoot (Optional) True to remove the breakpoint after the first hit.
        \return true if the memory breakpoint was set, false otherwise.
        */
        template <typename T>
        bool SetMemoryBreakpoint(ptr address, ptr size, T* debugger, void(T::*callback)(const BreakpointInfo & info), MemoryType type = MemoryType::Access, bool singleshoot = true)
        {
            static_cast<void>(static_cast<Debugger*>(debugger));
            return SetMemoryBreakpoint(address, size, std::bind(callback, debugger, std::placeholders::_1), type, singleshoot);
        }

        /**
        \brief Deletes a hardware breakpoint.
        \param address The address the hardware breakpoint is set on.
        \return true if the hardware breakpoint was deleted, false otherwise.
        */
        bool DeleteMemoryBreakpoint(ptr address);

        /**
        \brief Deletes a breakpoint.
        \param info The breakpoint information.
        \return true if the breakpoint was deleted, false otherwise.
        */
        bool DeleteGenericBreakpoint(const BreakpointInfo & info);

        /**
        \brief Step over.
        \param cbStep Step callback. Can be written using BIND(this, MyDebugger::cb).
        */
        void StepOver(const StepCallback & cbStep);

        /**
        \brief Step over.
        \tparam T Generic type parameter. Must be a subclass of Debugger.
        \param debugger This pointer to a subclass of Debugger.
        \param callback Pointer to the callback. Written like: &MyDebugger::cb
        */
        template<typename T>
        void StepOver(T* debugger, void(T::*callback)())
        {
            static_cast<void>(static_cast<Debugger*>(debugger));
            StepOver(std::bind(callback, debugger));
        }
    };
};

#endif //DEBUGGER_PROCESS_H


text:
<?php
/**
 * Error class - calls a 404 page.
 *
 * @author Tony Le - tonyle.microsoft@gmail.com
 * @version 1.0
 * @date November 28, 2015
 */

namespace Core;

use Core\Controller;
use Core\View;

/**
 * Error class to generate 404 pages.
 */
class Error extends Controller
{
    /**
     * $error holder.
     *
     * @var string
     */
    private $error = null;

    /**
     * Save error to $this->error.
     *
     * @param string $error
     */
    public function __construct($error)
    {
        parent::__construct();
        $this->error = $error;
    }

    /**
     * Load a 404 page with the error message.
     */
    public function index()
    {
        header("HTTP/1.0 404 Not Found");

        $data['title'] = '404';
        $data['error'] = $this->error;

        View::renderTemplate('header', $data);
        View::render('error/404', $data);
        View::renderTemplate('footer', $data);
    }

    /**
     * Display errors.
     *
     * @param  array  $error an error of errors
     * @param  string $class name of class to apply to div
     *
     * @return string return the errors inside divs
     */
    public static function display($error, $class = 'alert alert-danger')
    {
        if (is_array($error)) {
            foreach ($error as $error) {
                $row.= "
$error
";
            }
            return $row;
        } else {
            if (isset($error)) {
                return "
$error
";
            }
        }
    }
}


text:
'use strict';

describe('Main', function () {
  var App, component;

  beforeEach(function () {
    var container = document.createElement('div');
    container.id = 'content';
    document.body.appendChild(container);

    App = require('../../../src/scripts/components/App.jsx');
    component = App();
  });

  it('should create a new instance of App', function () {
    expect(component).toBeDefined();
  });
});


text:
package natlab.tame.builtin.classprop.ast;

import beaver.Symbol;

/**
 * A list of CP values. can be indexed by integers. It's the only non-expr node.
 * Used while parsing, but shouldn't pop up in an actual CP tree.
 */

public class CPList extends Symbol {
	CP element;
	CPList next;

	public CPList(CP element, CPList next){
		this.element = element;
		this.next = next;
	}

	public CP get(int index){
		if (index == 0) return element;
		return (next.get(index-1));
	}

	public int size(){
		if (next == null) return 1;
		return next.size()+1;
	}

	/**
	 * returns the list as bunch of chain nodes
	 */
	public CP asChain(){
		if (next == null) return element;
		return new CPChain(element,next.asChain());
	}

	/**
	 * returns the list as bunch of union nodes
	 */
	public CP asUnion(){
		if (next == null) return element;
		return new CPUnion(element,next.asUnion());
	}

	@Override
	public String toString() {
		return element.toString()+(next==null?":":":"+next);
	}

}


text:
package com.oculusinfo.tile.rest.legend;

import com.oculusinfo.tile.rendering.LayerConfiguration;

import java.awt.image.BufferedImage;

public interface LegendService {
	public BufferedImage getLegend (LayerConfiguration config, String layer, int zoomLevel, int width,
	                                int height, boolean doAxis, boolean renderHorizontally);
}


text:
<?php

/**
This file was not meant not to replace your functions.php file.
Just copy and paste the codes below into your own functions.php file.
*/

/**
 * Slightly Modified Options Framework
 */
require_once ('admin/index.php');


text:
using System;
using UnityEngine;

[AddComponentMenu("NGUI/Tween/Tween Color")]
public class TweenColor : UITweener
{
	private void Cache()
	{
		this.mCached = true;
		this.mWidget = base.GetComponent<UIWidget>();
		if (this.mWidget != (UnityEngine.Object)null)
		{
			return;
		}
		this.mSr = base.GetComponent<SpriteRenderer>();
		if (this.mSr != (UnityEngine.Object)null)
		{
			return;
		}
		Renderer component = base.GetComponent<Renderer>();
		if (component != (UnityEngine.Object)null)
		{
			this.mMat = component.material;
			return;
		}
		this.mLight = base.GetComponent<Light>();
		if (this.mLight == (UnityEngine.Object)null)
		{
			this.mWidget = base.GetComponentInChildren<UIWidget>();
		}
	}

	[Obsolete("Use 'value' instead")]
	public Color color
	{
		get
		{
			return this.value;
		}
		set
		{
			this.value = value;
		}
	}

	public Color value
	{
		get
		{
			if (!this.mCached)
			{
				this.Cache();
			}
			if (this.mWidget != (UnityEngine.Object)null)
			{
				return this.mWidget.color;
			}
			if (this.mMat != (UnityEngine.Object)null)
			{
				return this.mMat.color;
			}
			if (this.mSr != (UnityEngine.Object)null)
			{
				return this.mSr.color;
			}
			if (this.mLight != (UnityEngine.Object)null)
			{
				return this.mLight.color;
			}
			return Color.black;
		}
		set
		{
			if (!this.mCached)
			{
				this.Cache();
			}
			if (this.mWidget != (UnityEngine.Object)null)
			{
				this.mWidget.color = value;
			}
			else if (this.mMat != (UnityEngine.Object)null)
			{
				this.mMat.color = value;
			}
			else if (this.mSr != (UnityEngine.Object)null)
			{
				this.mSr.color = value;
			}
			else if (this.mLight != (UnityEngine.Object)null)
			{
				this.mLight.color = value;
				this.mLight.enabled = (value.r + value.g + value.b > 0.01f);
			}
		}
	}

	protected override void OnUpdate(Single factor, Boolean isFinished)
	{
		this.value = Color.Lerp(this.from, this.to, factor);
	}

	public static TweenColor Begin(GameObject go, Single duration, Color color)
	{
		TweenColor tweenColor = UITweener.Begin<TweenColor>(go, duration);
		tweenColor.from = tweenColor.value;
		tweenColor.to = color;
		if (duration <= 0f)
		{
			tweenColor.Sample(1f, true);
			tweenColor.enabled = false;
		}
		return tweenColor;
	}

	[ContextMenu("Set 'From' to current value")]
	public override void SetStartToCurrentValue()
	{
		this.from = this.value;
	}

	[ContextMenu("Set 'To' to current value")]
	public override void SetEndToCurrentValue()
	{
		this.to = this.value;
	}

	[ContextMenu("Assume value of 'From'")]
	private void SetCurrentValueToStart()
	{
		this.value = this.from;
	}

	[ContextMenu("Assume value of 'To'")]
	private void SetCurrentValueToEnd()
	{
		this.value = this.to;
	}

	public Color from = Color.white;

	public Color to = Color.white;

	private Boolean mCached;

	private UIWidget mWidget;

	private Material mMat;

	private Light mLight;

	private SpriteRenderer mSr;
}


text:
const accountSid = 'ACXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX';
const authToken = 'your_auth_token';
const client = require('twilio')(accountSid, authToken);

client.messages('MM800f449d0399ed014aae2bcc0cc2f2ec').post({
  body: '',
}, (err, message) => {
  // will be an empty string
  process.stdout.write(message.body);
});


text:
package io.reactivex.tck;

import java.util.Arrays;

import org.reactivestreams.Publisher;
import org.testng.annotations.Test;

import io.reactivex.Flowable;

@Test
public class AmbTckTest extends BaseTck<Long> {

    @SuppressWarnings("unchecked")
    @Override
    public Publisher<Long> createPublisher(long elements) {
        return
            Flowable.amb(Arrays.asList(
                    Flowable.fromIterable(iterate(elements)),
                    Flowable.<Long>never()
                )
            )
        ;
    }
}


text:
module com.github.ruediste.salta.jsr330 {
	requires transitive javax.inject;
	requires transitive com.github.ruediste.salta.core;
	requires java.logging;
	requires net.bytebuddy;
	requires com.google.common;

	exports com.github.ruediste.salta.jsr330;
	exports com.github.ruediste.salta.jsr330.binder;
	exports com.github.ruediste.salta.jsr330.util;

}


text:
export {
  event,
  select,
  selectAll
} from "d3-selection";

import "d3-selection-multi";


text:
<?xml version="1.0" encoding="utf-8"?>

<Deployment xmlns="http://schemas.microsoft.com/windowsphone/2009/deployment" AppPlatformVersion="7.0">
  <App xmlns="" ProductID="{44ea676d-92fb-4c17-a090-c5a5b911c5cc}" Title="Petroledger" RuntimeType="Silverlight" Version="1.0.0.0" Genre="apps.normal" Author="W. Brian Gourlie" Description="Track fill-ups, efficiency, trips and maintanence for all your vehicles using a simple, intuitive interface." Publisher="W. Brian Gourlie">
    <IconPath IsRelative="true" IsResource="false">ApplicationIcon.png</IconPath>
    <Capabilities>
      <Capability Name="ID_CAP_CAMERA" />
      <Capability Name="ID_CAP_GAMERSERVICES" />
      <Capability Name="ID_CAP_IDENTITY_DEVICE" />
      <Capability Name="ID_CAP_IDENTITY_USER" />
      <Capability Name="ID_CAP_INTEROPSERVICES" />
      <Capability Name="ID_CAP_LOCATION" />
      <Capability Name="ID_CAP_MEDIALIB" />
      <Capability Name="ID_CAP_MICROPHONE" />
      <Capability Name="ID_CAP_NETWORKING" />
      <Capability Name="ID_CAP_NETWORKING_ADMIN" />
      <Capability Name="ID_CAP_PHONEDIALER" />
      <Capability Name="ID_CAP_PUSH_NOTIFICATION" />
      <Capability Name="ID_CAP_RINGTONE_ADD" />
      <Capability Name="ID_CAP_SENSORS" />
      <Capability Name="ID_CAP_WEBBROWSERCOMPONENT" />
    </Capabilities>
    <Tasks>
      <DefaultTask Name="_default" NavigationPage="MainPage.xaml" />
    </Tasks>
    <Tokens>
      <PrimaryToken TokenID="PetroledgerToken" TaskName="_default">
        <TemplateType5>
          <BackgroundImageURI IsRelative="true" IsResource="false">Background.png</BackgroundImageURI>
          <Count>0</Count>
          <Title>Petroledger</Title>
        </TemplateType5>
      </PrimaryToken>
    </Tokens>
  </App>
</Deployment>


text:
<?xml version="1.0" encoding="UTF-8"?>
<!--

    Copyright 2018 StreamSets Inc.

    Licensed under the Apache License, Version 2.0 (the "License");
    you may not use this file except in compliance with the License.
    You may obtain a copy of the License at

        http://www.apache.org/licenses/LICENSE-2.0

    Unless required by applicable law or agreed to in writing, software
    distributed under the License is distributed on an "AS IS" BASIS,
    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
    See the License for the specific language governing permissions and
    limitations under the License.

-->
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">

  <modelVersion>4.0.0</modelVersion>
  <parent>
    <artifactId>streamsets-datacollector-root-lib</artifactId>
    <groupId>com.streamsets</groupId>
    <version>3.8.0-SNAPSHOT</version>
    <relativePath>../root-lib/pom.xml</relativePath>
  </parent>

  <groupId>com.streamsets</groupId>
  <artifactId>streamsets-datacollector-pulsar-protolib</artifactId>
  <version>3.8.0-SNAPSHOT</version>
  <description>StreamSets Data Collector Pulsar ProtoLib</description>
  <name>StreamSets Data Collector Pulsar ProtoLib</name>
  <packaging>jar</packaging>

  <properties>
    <pulsar.version>2.2.0</pulsar.version>
    <guava.version>24.1-jre</guava.version>
  </properties>

  <dependencies>
    <dependency>
      <groupId>org.apache.pulsar</groupId>
      <artifactId>pulsar-client</artifactId>
      <version>${pulsar.version}</version>
      <scope>compile</scope>
    </dependency>

    <dependency>
      <groupId>com.streamsets</groupId>
      <artifactId>streamsets-datacollector-api</artifactId>
      <scope>provided</scope>
    </dependency>
    <dependency>
      <groupId>log4j</groupId>
      <artifactId>log4j</artifactId>
      <scope>provided</scope>
    </dependency>
    <dependency>
      <groupId>org.slf4j</groupId>
      <artifactId>slf4j-api</artifactId>
      <scope>provided</scope>
    </dependency>
    <dependency>
      <groupId>org.slf4j</groupId>
      <artifactId>slf4j-log4j12</artifactId>
      <scope>provided</scope>
    </dependency>
    <dependency>
      <groupId>io.dropwizard.metrics</groupId>
      <artifactId>metrics-core</artifactId>
      <scope>provided</scope>
    </dependency>

    <dependency>
      <groupId>com.streamsets</groupId>
      <artifactId>streamsets-datacollector-stagesupport</artifactId>
      <scope>compile</scope>
    </dependency>

    <dependency>
      <groupId>com.streamsets</groupId>
      <artifactId>streamsets-datacollector-sdk</artifactId>
      <scope>test</scope>
    </dependency>
    <dependency>
      <groupId>junit</groupId>
      <artifactId>junit</artifactId>
      <scope>test</scope>
    </dependency>
    <dependency>
      <groupId>org.mockito</groupId>
      <artifactId>mockito-core</artifactId>
      <scope>test</scope>
    </dependency>

    <dependency>
      <groupId>com.google.guava</groupId>
      <artifactId>guava</artifactId>
      <version>${guava.version}</version>
    </dependency>
    <dependency>
      <groupId>org.powermock</groupId>
      <artifactId>powermock-api-mockito</artifactId>
      <scope>test</scope>
    </dependency>
    <dependency>
      <groupId>org.powermock</groupId>
      <artifactId>powermock-module-junit4</artifactId>
      <scope>test</scope>
    </dependency>
    <dependency>
      <groupId>com.streamsets</groupId>
      <artifactId>streamsets-datacollector-stagesupport</artifactId>
      <version>${project.version}</version>
      <type>test-jar</type>
      <scope>test</scope>
    </dependency>

  </dependencies>

</project>


text:
package org.apache.stratos.cli.beans;

public class AutoscalePolicy {

    private String id;

    private String displayName;

    private String description;

    public String getId() {
        return id;
    }

    public void setId(String id) {
        this.id = id;
    }

    public String getDisplayName() {
        return displayName;
    }

    public void setDisplayName(String displayName) {
        this.displayName = displayName;
    }

    public String getDescription() {
        return description;
    }

    public void setDescription(String description) {
        this.description = description;
    }
}


text:
<?xml version="1.0" encoding="utf-8"?>
<css>
  <cssfile>
    <css_set_id>0</css_set_id>
    <css_updated>1383006095</css_updated>
    <css_group>ipb_messenger</css_group>
    <css_content>/************************************************************************/
/* IP.Board 3 CSS - By Rikki Tissier - (c)2008 Invision Power Services	*/
/************************************************************************/
/* ipb_messenger.css - Messenger styles									*/
/************************************************************************/

#messenger_utilities { width: 19%; }

#messenger_content { width: 80%; }

	#messenger_content h2 {
		clear: none;
		font-size: 1.4em;
	}

#folder_list, #space_allowance,
#message_search, #participants,
#invite_more {
	position: relative;
}

#space_allowance p { line-height: 150%;}
#message_list {	clear: right; }
#message_compose .input_check {	margin-left: 245px;}
#invite_more_dialogue { display: none;}
#invite_more_dialogue ul { padding: 4px;}
#invite_more_autocomplete {	width: 99%; }

#folder_list li {
	margin-bottom: 8px;
	margin-left: 4px;
	padding: 0px;
}

	#folder_list #folders {
		margin-bottom: 12px;
	}

	#folder_list .total {
		background-color: #d5dde5;
		font-size: 0.75em;
		font-weight: bold;
		padding: 3px 6px;
		margin-right: 10px;
		right: 0;
		position: absolute;
	}

	#participants #participants_list span.name.left_convo a {
		color: #8a8a8a;
		font-style: italic;
	}

	#participants #participants_list span.name.blocked a {
		color: #ad2930;
	}

#space_allowance {
	clear: both;
}

li.new_folder {
	padding-left: 20px;
}

.add_folder.input_submit {
	padding: 1px 3px;
}

.edit_folders {
	background: #eef3f8;
	font-size: 0.8em;
	font-weight: bold;
	margin-right: 2px;
	padding: 2px;
	right: 3px;
	position: absolute;
}

	.f_delete {
		color: #f00;
	}

.col_m_subject {
	width:40%;
}</css_content>
    <css_position>1</css_position>
    <css_app>members</css_app>
    <css_app_hide>1</css_app_hide>
    <css_attributes><![CDATA[title="Main" media="screen,print"]]></css_attributes>
    <css_removed>0</css_removed>
    <css_modules>messaging</css_modules>
    <css_master_key>root</css_master_key>
  </cssfile>
  <cssfile>
    <css_set_id>0</css_set_id>
    <css_updated>1383006095</css_updated>
    <css_group>ipb_mlist</css_group>
    <css_content><![CDATA[/************************************************************************/
/* IP.Board 3 CSS - By Rikki Tissier - (c)2008 Invision Power Services	*/
/************************************************************************/
/* ipb_mlist.css - Member list styles									*/
/************************************************************************/

#mlist_tabs { margin-top: 35px; }
	#mlist_tabs li { text-align: center; }
		#mlist_tabs li a { padding: 5px 8px; }

div#member_filters {
	margin-top: 10px;
	margin-bottom: 15px;
}

	div#member_filters fieldset.other_filters {
		text-align: center;
		padding: 6px;
		margin-top: 10px;
		clear: both;
	}

	div#member_filters fieldset.submit {
		background: #d5dde5;
		padding: 6px;
	}

	div#member_filters ul {
		margin-bottom: 12px;
		margin-top: 8px;
		width: 49%;
		float: left;
	}

	div#member_filters li {
		border-bottom: 1px solid #d5dde5;
		margin-right: 20px;
		padding: 8px 0 8px 0;
		clear: both;
	}

		div#member_filters li .desc {
			margin: 0;
			display: inline;
		}

	div#member_filters label {
		text-align: right;
		margin-right: 15px;
		width: 150px;
		display: block;
		float: left;
	}

	div#member_filters li.field.custom input[type=text],
	div#member_filters li.field.custom textarea {
		width: 50%;
	}

div#member_filters li.field.custom .input_check {
	width: 5%;
}]]></css_content>
    <css_position>1</css_position>
    <css_app>members</css_app>
    <css_app_hide>1</css_app_hide>
    <css_attributes><![CDATA[title="Main" media="screen,print"]]></css_attributes>
    <css_removed>0</css_removed>
    <css_modules/>
    <css_master_key>root</css_master_key>
  </cssfile>
  <cssfile>
    <css_set_id>0</css_set_id>
    <css_updated>1383006095</css_updated>
    <css_group>ipb_photo_editor</css_group>
    <css_content>/************************************************************************/
/* IP.Board 3 CSS - By Matt Mecham - (c)2011 Invision Power Services	*/
/************************************************************************/
/* ipb_photo_editor.css - Photo editor styles							*/
/************************************************************************/

/* New photo stuffs */
#ips_photoWrap {
	width: 700px;
	border: 1px solid #D5DDE5;
	margin: 0px auto;
	padding: 6px;
}

#ips_sidePanel {
	float: left;
	width: 200px;
}

#ips_cropperStart, #ips_cropperControls {

	text-align: right;
	width: 200px;
	margin-top: 8px;
}

#ips_currentPhoto {

	text-align: center;
}
	#ips_currentPhoto img {
		border: 1px solid #D5DDE5;
		background: white;
		max-width: 200px;
		height: auto;
	}

#gravatar, #upload_photo {
	width: 150px;
}

#ips_photoOptions {
	margin-left: 210px;
}

li.ips_option {
	border: 1px solid #D5DDE5;
	min-height: 120px;
	margin-bottom: 5px;
}

.ips_photoPreview {
	width: 100px;
	height: 100px;
	display: block;
	overflow: hidden;
	margin: 6px;
	float: left;
	border: 1px solid #D5DDE5;

}

	.ips_photoPreview label {
		text-align: center;
		background: white;
	}

	.ips_photoPreview label img {
		max-width:120px;
		max-height:120px;
	}

.ips_photoControls {
	padding-top: 10px;
	margin-left: 120px;
}

.ips_photoOptionText {
	margin-left: 18px;
	line-height: 130%;
	padding-bottom: 3px;
}

.imgCrop_wrap { display: inline-block; }</css_content>
    <css_position>1</css_position>
    <css_app>members</css_app>
    <css_app_hide>1</css_app_hide>
    <css_attributes><![CDATA[title="Main" media="screen,print"]]></css_attributes>
    <css_removed>0</css_removed>
    <css_modules>photo</css_modules>
    <css_master_key>root</css_master_key>
  </cssfile>
  <cssfile>
    <css_set_id>0</css_set_id>
    <css_updated>1383006095</css_updated>
    <css_group>ipb_profile</css_group>
    <css_content><![CDATA[/************************************************************************/
/* IP.Board 3 CSS - By Rikki Tissier - (c)2008 Invision Power Services	*/
/************************************************************************/
/* ipb_profile.css - Profile specific styles							*/
/************************************************************************/

#profile_photo { max-width: 138px; max-height: 138px; }
#profile_content_main {
	min-height: 75px;
	line-height: 1.3;
	margin-bottom: 20px;
}
#pane_info .ipsLayout_right { width: 260px !important; margin-right: -290px; }
#friends_overview .ipsUserPhoto_link { margin: 0 2px 5px 2px; display: inline-block; }

#profile_panes_wrap .reputation {
	float: none;
	margin: 0 0 5px 0;
	padding: 10px;
	text-align: center;
	font-weight: normal;
	display: block;
}
	#profile_panes_wrap .reputation .number {
		font-size: 20px;
		font-weight: bold;
		display: block;
	}

#profile_panes_wrap .ipsList_data .row_data {
	display: block;
	margin-left: 130px;
}

.warn_panel { text-align: center; margin: 8px 0; }
.photo_holder { position: relative; }
#change_photo {
	position: absolute;
	top: 0; left: 0;
	background: rgba(0,0,0,0.2);
	color: #fff;
	opacity: 0.3;
	-webkit-border-radius: 3px;
	-moz-border-radius: 3px;
	border-radius: 3px;
	-webkit-transition: all 0.4s ease-in-out;
	-moz-transition: all 0.4s ease-in-out;
}
	.photo_holder:hover #change_photo {
		opacity: 1;
		background: #000;
	}

#user_info_cell {
	display: table-cell;
	white-space: nowrap;
	padding-right: 15px;
}
#user_status_cell {
	display: table-cell;
	width: 100%;
	vertical-align: top;
}
#user_latest_status {
	background: url({style_images_url}/stems/profile_status_stem.png ) no-repeat 0px 50%;
	padding-left: 11px;
}

#user_latest_status > div {
	padding: 10px 15px;
	background-color: #ebece5;
	color: #343434;
	font-size: 14px;
	-webkit-border-radius: 6px;
	-moz-border-radius: 6px;
	border-radius: 6px;
	min-height: 45px;
	word-wrap: break-word;
}

#user_latest_status > div > span { display: block; }
#user_utility_links { margin-top: 10px; text-align: right; }
.rating { margin-top: 10px; }

#status_wrapper .ipsBox_container {
	margin-bottom: 9px;
}]]></css_content>
    <css_position>1</css_position>
    <css_app>members</css_app>
    <css_app_hide>1</css_app_hide>
    <css_attributes><![CDATA[title="Main" media="screen,print"]]></css_attributes>
    <css_removed>0</css_removed>
    <css_modules/>
    <css_master_key>root</css_master_key>
  </cssfile>
</css>


text:
module AsposeCellsCloud
  #
  class Cells < BaseObject
    attr_accessor :max_row, :max_column, :cell_count, :rows, :columns, :cell_list, :link
    # attribute mapping from ruby-style variable name to JSON key
    def self.attribute_map
      {

        #
        :'max_row' => :'MaxRow',

        #
        :'max_column' => :'MaxColumn',

        #
        :'cell_count' => :'CellCount',

        #
        :'rows' => :'Rows',

        #
        :'columns' => :'Columns',

        #
        :'cell_list' => :'CellList',

        #
        :'link' => :'link'

      }
    end

    # attribute type
    def self.swagger_types
      {
        :'max_row' => :'Integer',
        :'max_column' => :'Integer',
        :'cell_count' => :'Integer',
        :'rows' => :'LinkElement',
        :'columns' => :'LinkElement',
        :'cell_list' => :'Array<LinkElement>',
        :'link' => :'Link'

      }
    end

    def initialize(attributes = {})
      return if !attributes.is_a?(Hash) || attributes.empty?

      # convert string to symbol for hash key
      attributes = attributes.inject({}){|memo,(k,v)| memo[k.to_sym] = v; memo}

      if attributes[:'MaxRow']
        self.max_row = attributes[:'MaxRow']
      end

      if attributes[:'MaxColumn']
        self.max_column = attributes[:'MaxColumn']
      end

      if attributes[:'CellCount']
        self.cell_count = attributes[:'CellCount']
      end

      if attributes[:'Rows']
        self.rows = attributes[:'Rows']
      end

      if attributes[:'Columns']
        self.columns = attributes[:'Columns']
      end

      if attributes[:'CellList']
        if (value = attributes[:'CellList']).is_a?(Array)
          self.cell_list = value
        end
      end

      if attributes[:'link']
        self.link = attributes[:'link']
      end

    end

  end
end