text:
using namespace llvm;

// General options for llc.  Other pass-specific options are specified
// within the corresponding llc passes, and target-specific options
// and back-end code generation options are specified with the target machine.
//
static cl::opt<std::string>
InputFilename(cl::Positional, cl::desc("<input bitcode>"), cl::init("-"));

static cl::opt<std::string>
OutputFilename("o", cl::desc("Output filename"), cl::value_desc("filename"));

// Determine optimization level.
static cl::opt<char>
OptLevel("O",
         cl::desc("Optimization level. [-O0, -O1, -O2, or -O3] "
                  "(default = '-O2')"),
         cl::Prefix,
         cl::ZeroOrMore,
         cl::init(' '));

static cl::opt<std::string>
TargetTriple("mtriple", cl::desc("Override target triple for module"));

static cl::opt<std::string>
MArch("march", cl::desc("Architecture to generate code for (see --version)"));

static cl::opt<std::string>
MCPU("mcpu",
  cl::desc("Target a specific cpu type (-mcpu=help for details)"),
  cl::value_desc("cpu-name"),
  cl::init(""));

static cl::list<std::string>
MAttrs("mattr",
  cl::CommaSeparated,
  cl::desc("Target specific attributes (-mattr=help for details)"),
  cl::value_desc("a1,+a2,-a3,..."));

static cl::opt<Reloc::Model>
RelocModel("relocation-model",
             cl::desc("Choose relocation model"),
             cl::init(Reloc::Default),
             cl::values(
            clEnumValN(Reloc::Default, "default",
                       "Target default relocation model"),
            clEnumValN(Reloc::Static, "static",
                       "Non-relocatable code"),
            clEnumValN(Reloc::PIC_, "pic",
                       "Fully relocatable, position independent code"),
            clEnumValN(Reloc::DynamicNoPIC, "dynamic-no-pic",
                       "Relocatable external references, non-relocatable code"),
            clEnumValEnd));

static cl::opt<llvm::CodeModel::Model>
CMModel("code-model",
        cl::desc("Choose code model"),
        cl::init(CodeModel::Default),
        cl::values(clEnumValN(CodeModel::Default, "default",
                              "Target default code model"),
                   clEnumValN(CodeModel::Small, "small",
                              "Small code model"),
                   clEnumValN(CodeModel::Kernel, "kernel",
                              "Kernel code model"),
                   clEnumValN(CodeModel::Medium, "medium",
                              "Medium code model"),
                   clEnumValN(CodeModel::Large, "large",
                              "Large code model"),
                   clEnumValEnd));

static cl::opt<bool>
RelaxAll("mc-relax-all",
  cl::desc("When used with filetype=obj, "
           "relax all fixups in the emitted object file"));

cl::opt<TargetMachine::CodeGenFileType>
FileType("filetype", cl::init(TargetMachine::CGFT_AssemblyFile),
  cl::desc("Choose a file type (not all types are supported by all targets):"),
  cl::values(
       clEnumValN(TargetMachine::CGFT_AssemblyFile, "asm",
                  "Emit an assembly ('.s') file"),
       clEnumValN(TargetMachine::CGFT_ObjectFile, "obj",
                  "Emit a native object ('.o') file"),
       clEnumValN(TargetMachine::CGFT_Null, "null",
                  "Emit nothing, for performance testing"),
       clEnumValEnd));

cl::opt<bool> NoVerify("disable-verify", cl::Hidden,
                       cl::desc("Do not verify input module"));

cl::opt<bool> DisableDotLoc("disable-dot-loc", cl::Hidden,
                            cl::desc("Do not use .loc entries"));

cl::opt<bool> DisableCFI("disable-cfi", cl::Hidden,
                         cl::desc("Do not use .cfi_* directives"));

cl::opt<bool> EnableDwarfDirectory("enable-dwarf-directory", cl::Hidden,
    cl::desc("Use .file directives with an explicit directory."));

static cl::opt<bool>
DisableRedZone("disable-red-zone",
  cl::desc("Do not emit code that uses the red zone."),
  cl::init(false));

static cl::opt<bool>
EnableFPMAD("enable-fp-mad",
  cl::desc("Enable less precise MAD instructions to be generated"),
  cl::init(false));

static cl::opt<bool>
DisableFPElim("disable-fp-elim",
  cl::desc("Disable frame pointer elimination optimization"),
  cl::init(false));

static cl::opt<bool>
DisableFPElimNonLeaf("disable-non-leaf-fp-elim",
  cl::desc("Disable frame pointer elimination optimization for non-leaf funcs"),
  cl::init(false));

static cl::opt<bool>
EnableUnsafeFPMath("enable-unsafe-fp-math",
  cl::desc("Enable optimizations that may decrease FP precision"),
  cl::init(false));

static cl::opt<bool>
EnableNoInfsFPMath("enable-no-infs-fp-math",
  cl::desc("Enable FP math optimizations that assume no +-Infs"),
  cl::init(false));

static cl::opt<bool>
EnableNoNaNsFPMath("enable-no-nans-fp-math",
  cl::desc("Enable FP math optimizations that assume no NaNs"),
  cl::init(false));

static cl::opt<bool>
EnableHonorSignDependentRoundingFPMath("enable-sign-dependent-rounding-fp-math",
  cl::Hidden,
  cl::desc("Force codegen to assume rounding mode can change dynamically"),
  cl::init(false));

static cl::opt<bool>
GenerateSoftFloatCalls("soft-float",
  cl::desc("Generate software floating point library calls"),
  cl::init(false));

static cl::opt<llvm::FloatABI::ABIType>
FloatABIForCalls("float-abi",
  cl::desc("Choose float ABI type"),
  cl::init(FloatABI::Default),
  cl::values(
    clEnumValN(FloatABI::Default, "default",
               "Target default float ABI type"),
    clEnumValN(FloatABI::Soft, "soft",
               "Soft float ABI (implied by -soft-float)"),
    clEnumValN(FloatABI::Hard, "hard",
               "Hard float ABI (uses FP registers)"),
    clEnumValEnd));

static cl::opt<llvm::FPOpFusion::FPOpFusionMode>
FuseFPOps("fp-contract",
  cl::desc("Enable aggresive formation of fused FP ops"),
  cl::init(FPOpFusion::Standard),
  cl::values(
    clEnumValN(FPOpFusion::Fast, "fast",
               "Fuse FP ops whenever profitable"),
    clEnumValN(FPOpFusion::Standard, "on",
               "Only fuse 'blessed' FP ops."),
    clEnumValN(FPOpFusion::Strict, "off",
               "Only fuse FP ops when the result won't be effected."),
    clEnumValEnd));

static cl::opt<bool>
DontPlaceZerosInBSS("nozero-initialized-in-bss",
  cl::desc("Don't place zero-initialized symbols into bss section"),
  cl::init(false));

static cl::opt<bool>
DisableSimplifyLibCalls("disable-simplify-libcalls",
  cl::desc("Disable simplify-libcalls"),
  cl::init(false));

static cl::opt<bool>
EnableGuaranteedTailCallOpt("tailcallopt",
  cl::desc("Turn fastcc calls into tail calls by (potentially) changing ABI."),
  cl::init(false));

static cl::opt<bool>
DisableTailCalls("disable-tail-calls",
  cl::desc("Never emit tail calls"),
  cl::init(false));

static cl::opt<unsigned>
OverrideStackAlignment("stack-alignment",
  cl::desc("Override default stack alignment"),
  cl::init(0));

static cl::opt<bool>
EnableRealignStack("realign-stack",
  cl::desc("Realign stack if needed"),
  cl::init(true));

static cl::opt<std::string>
TrapFuncName("trap-func", cl::Hidden,
  cl::desc("Emit a call to trap function rather than a trap instruction"),
  cl::init(""));

static cl::opt<bool>
EnablePIE("enable-pie",
  cl::desc("Assume the creation of a position independent executable."),
  cl::init(false));

static cl::opt<bool>
SegmentedStacks("segmented-stacks",
  cl::desc("Use segmented stacks if possible."),
  cl::init(false));

static cl::opt<bool>
UseInitArray("use-init-array",
  cl::desc("Use .init_array instead of .ctors."),
  cl::init(false));

static cl::opt<std::string> StopAfter("stop-after",
  cl::desc("Stop compilation after a specific pass"),
  cl::value_desc("pass-name"),
  cl::init(""));
static cl::opt<std::string> StartAfter("start-after",
  cl::desc("Resume compilation after a specific pass"),
  cl::value_desc("pass-name"),
  cl::init(""));

static cl::opt<unsigned>
SSPBufferSize("stack-protector-buffer-size", cl::init(8),
              cl::desc("Lower bound for a buffer to be considered for "
                       "stack protection"));

// GetFileNameRoot - Helper function to get the basename of a filename.
static inline std::string
GetFileNameRoot(const std::string &InputFilename) {
  std::string IFN = InputFilename;
  std::string outputFilename;
  int Len = IFN.length();
  if ((Len > 2) &&
      IFN[Len-3] == '.' &&
      ((IFN[Len-2] == 'b' && IFN[Len-1] == 'c') ||
       (IFN[Len-2] == 'l' && IFN[Len-1] == 'l'))) {
    outputFilename = std::string(IFN.begin(), IFN.end()-3); // s/.bc/.s/
  } else {
    outputFilename = IFN;
  }
  return outputFilename;
}

static tool_output_file *GetOutputStream(const char *TargetName,
                                         Triple::OSType OS,
                                         const char *ProgName) {
  // If we don't yet have an output filename, make one.
  if (OutputFilename.empty()) {
    if (InputFilename == "-")
      OutputFilename = "-";
    else {
      OutputFilename = GetFileNameRoot(InputFilename);

      switch (FileType) {
      case TargetMachine::CGFT_AssemblyFile:
        if (TargetName[0] == 'c') {
          if (TargetName[1] == 0)
            OutputFilename += ".cbe.c";
          else if (TargetName[1] == 'p' && TargetName[2] == 'p')
            OutputFilename += ".cpp";
          else
            OutputFilename += ".s";
        } else
          OutputFilename += ".s";
        break;
      case TargetMachine::CGFT_ObjectFile:
        if (OS == Triple::Win32)
          OutputFilename += ".obj";
        else
          OutputFilename += ".o";
        break;
      case TargetMachine::CGFT_Null:
        OutputFilename += ".null";
        break;
      }
    }
  }

  // Decide if we need "binary" output.
  bool Binary = false;
  switch (FileType) {
  case TargetMachine::CGFT_AssemblyFile:
    break;
  case TargetMachine::CGFT_ObjectFile:
  case TargetMachine::CGFT_Null:
    Binary = true;
    break;
  }

  // Open the file.
  std::string error;
  unsigned OpenFlags = 0;
  if (Binary) OpenFlags |= raw_fd_ostream::F_Binary;
  tool_output_file *FDOut = new tool_output_file(OutputFilename.c_str(), error,
                                                 OpenFlags);
  if (!error.empty()) {
    errs() << error << '\n';
    delete FDOut;
    return 0;
  }

  return FDOut;
}

// main - Entry point for the llc compiler.
//
int main(int argc, char **argv) {
  sys::PrintStackTraceOnErrorSignal();
  PrettyStackTraceProgram X(argc, argv);

  // Enable debug stream buffering.
  EnableDebugBuffering = true;

  LLVMContext &Context = getGlobalContext();
  llvm_shutdown_obj Y;  // Call llvm_shutdown() on exit.

  // Initialize targets first, so that --version shows registered targets.
  InitializeAllTargets();
  InitializeAllTargetMCs();
  InitializeAllAsmPrinters();
  InitializeAllAsmParsers();

  // Initialize codegen and IR passes used by llc so that the -print-after,
  // -print-before, and -stop-after options work.
  PassRegistry *Registry = PassRegistry::getPassRegistry();
  initializeCore(*Registry);
  initializeCodeGen(*Registry);
  initializeLoopStrengthReducePass(*Registry);
  initializeLowerIntrinsicsPass(*Registry);
  initializeUnreachableBlockElimPass(*Registry);

  // Register the target printer for --version.
  cl::AddExtraVersionPrinter(TargetRegistry::printRegisteredTargetsForVersion);

  cl::ParseCommandLineOptions(argc, argv, "llvm system compiler\n");

  // Load the module to be compiled...
  SMDiagnostic Err;
  std::auto_ptr<Module> M;
  Module *mod = 0;
  Triple TheTriple;

  bool SkipModule = MCPU == "help" ||
                    (!MAttrs.empty() && MAttrs.front() == "help");

  // If user just wants to list available options, skip module loading
  if (!SkipModule) {
    M.reset(ParseIRFile(InputFilename, Err, Context));
    mod = M.get();
    if (mod == 0) {
      Err.print(argv[0], errs());
      return 1;
    }

    // If we are supposed to override the target triple, do so now.
    if (!TargetTriple.empty())
      mod->setTargetTriple(Triple::normalize(TargetTriple));
    TheTriple = Triple(mod->getTargetTriple());
  } else {
    TheTriple = Triple(Triple::normalize(TargetTriple));
  }

  if (TheTriple.getTriple().empty())
    TheTriple.setTriple(sys::getDefaultTargetTriple());

  // Get the target specific parser.
  std::string Error;
  const Target *TheTarget = TargetRegistry::lookupTarget(MArch, TheTriple,
                                                         Error);
  if (!TheTarget) {
    errs() << argv[0] << ": " << Error;
    return 1;
  }

  // Package up features to be passed to target/subtarget
  std::string FeaturesStr;
  if (MAttrs.size()) {
    SubtargetFeatures Features;
    for (unsigned i = 0; i != MAttrs.size(); ++i)
      Features.AddFeature(MAttrs[i]);
    FeaturesStr = Features.getString();
  }

  CodeGenOpt::Level OLvl = CodeGenOpt::Default;
  switch (OptLevel) {
  default:
    errs() << argv[0] << ": invalid optimization level.\n";
    return 1;
  case ' ': break;
  case '0': OLvl = CodeGenOpt::None; break;
  case '1': OLvl = CodeGenOpt::Less; break;
  case '2': OLvl = CodeGenOpt::Default; break;
  case '3': OLvl = CodeGenOpt::Aggressive; break;
  }

  TargetOptions Options;
  Options.LessPreciseFPMADOption = EnableFPMAD;
  Options.NoFramePointerElim = DisableFPElim;
  Options.NoFramePointerElimNonLeaf = DisableFPElimNonLeaf;
  Options.AllowFPOpFusion = FuseFPOps;
  Options.UnsafeFPMath = EnableUnsafeFPMath;
  Options.NoInfsFPMath = EnableNoInfsFPMath;
  Options.NoNaNsFPMath = EnableNoNaNsFPMath;
  Options.HonorSignDependentRoundingFPMathOption =
      EnableHonorSignDependentRoundingFPMath;
  Options.UseSoftFloat = GenerateSoftFloatCalls;
  if (FloatABIForCalls != FloatABI::Default)
    Options.FloatABIType = FloatABIForCalls;
  Options.NoZerosInBSS = DontPlaceZerosInBSS;
  Options.GuaranteedTailCallOpt = EnableGuaranteedTailCallOpt;
  Options.DisableTailCalls = DisableTailCalls;
  Options.StackAlignmentOverride = OverrideStackAlignment;
  Options.RealignStack = EnableRealignStack;
  Options.TrapFuncName = TrapFuncName;
  Options.PositionIndependentExecutable = EnablePIE;
  Options.EnableSegmentedStacks = SegmentedStacks;
  Options.UseInitArray = UseInitArray;
  Options.SSPBufferSize = SSPBufferSize;

  std::auto_ptr<TargetMachine>
    target(TheTarget->createTargetMachine(TheTriple.getTriple(),
                                          MCPU, FeaturesStr, Options,
                                          RelocModel, CMModel, OLvl));
  assert(target.get() && "Could not allocate target machine!");
  assert(mod && "Should have exited after outputting help!");
  TargetMachine &Target = *target.get();

  if (DisableDotLoc)
    Target.setMCUseLoc(false);

  if (DisableCFI)
    Target.setMCUseCFI(false);

  if (EnableDwarfDirectory)
    Target.setMCUseDwarfDirectory(true);

  if (GenerateSoftFloatCalls)
    FloatABIForCalls = FloatABI::Soft;

  // Disable .loc support for older OS X versions.
  if (TheTriple.isMacOSX() &&
      TheTriple.isMacOSXVersionLT(10, 6))
    Target.setMCUseLoc(false);

  // Figure out where we are going to send the output.
  OwningPtr<tool_output_file> Out
    (GetOutputStream(TheTarget->getName(), TheTriple.getOS(), argv[0]));
  if (!Out) return 1;

  // Build up all of the passes that we want to do to the module.
  PassManager PM;

  // Add an appropriate TargetLibraryInfo pass for the module's triple.
  TargetLibraryInfo *TLI = new TargetLibraryInfo(TheTriple);
  if (DisableSimplifyLibCalls)
    TLI->disableAllFunctions();
  PM.add(TLI);

  // Add the target data from the target machine, if it exists, or the module.
  if (const TargetData *TD = Target.getTargetData())
    PM.add(new TargetData(*TD));
  else
    PM.add(new TargetData(mod));

  // Override default to generate verbose assembly.
  Target.setAsmVerbosityDefault(true);

  if (RelaxAll) {
    if (FileType != TargetMachine::CGFT_ObjectFile)
      errs() << argv[0]
             << ": warning: ignoring -mc-relax-all because filetype != obj";
    else
      Target.setMCRelaxAll(true);
  }

  {
    formatted_raw_ostream FOS(Out->os());

    AnalysisID StartAfterID = 0;
    AnalysisID StopAfterID = 0;
    const PassRegistry *PR = PassRegistry::getPassRegistry();
    if (!StartAfter.empty()) {
      const PassInfo *PI = PR->getPassInfo(StartAfter);
      if (!PI) {
        errs() << argv[0] << ": start-after pass is not registered.\n";
        return 1;
      }
      StartAfterID = PI->getTypeInfo();
    }
    if (!StopAfter.empty()) {
      const PassInfo *PI = PR->getPassInfo(StopAfter);
      if (!PI) {
        errs() << argv[0] << ": stop-after pass is not registered.\n";
        return 1;
      }
      StopAfterID = PI->getTypeInfo();
    }

    // Ask the target to add backend passes as necessary.
    if (Target.addPassesToEmitFile(PM, FOS, FileType, NoVerify,
                                   StartAfterID, StopAfterID)) {
      errs() << argv[0] << ": target does not support generation of this"
             << " file type!\n";
      return 1;
    }

    // Before executing passes, print the final values of the LLVM options.
    cl::PrintOptionValues();

    PM.run(*mod);
  }

  // Declare success.
  Out->keep();

  return 0;
}


text:
/**
 * Created by IvanIsrael on 11/06/2017.
 */
/**
 * Created by IvanIsrael on 04/04/2017.
 */
module.exports = {
  db:
    "mongodb+srv://tequiladb:qwerty1234@retanadb.f6f7y.mongodb.net/retanadb?retryWrites=true&w=majority",
  sessionSecret: "developmentSessionSecret",
};

redpajama_set_name: RedPajamaGithub


text:
<?php

namespace Monolog\Handler;

use Monolog\Logger;
use Monolog\Formatter\JsonFormatter;
use PhpAmqpLib\Message\AMQPMessage;
use PhpAmqpLib\Channel\AMQPChannel;
use AMQPExchange;

class AmqpHandler extends AbstractProcessingHandler
{
    /**
     * @var AMQPExchange|AMQPChannel $exchange
     */
    protected $exchange;

    /**
     * @var string
     */
    protected $exchangeName;

    /**
     * @param AMQPExchange|AMQPChannel $exchange     AMQPExchange (php AMQP ext) or PHP AMQP lib channel, ready for use
     * @param string                   $exchangeName
     * @param int                      $level
     * @param bool                     $bubble       Whether the messages that are handled can bubble up the stack or not
     */
    public function __construct($exchange, $exchangeName = 'log', $level = Logger::DEBUG, $bubble = true)
    {
        if ($exchange instanceof AMQPExchange) {
            $exchange->setName($exchangeName);
        } elseif ($exchange instanceof AMQPChannel) {
            $this->exchangeName = $exchangeName;
        } else {
            throw new \InvalidArgumentException('PhpAmqpLib\Channel\AMQPChannel or AMQPExchange instance required');
        }
        $this->exchange = $exchange;

        parent::__construct($level, $bubble);
    }

    /**
     * {@inheritDoc}
     */
    protected function write(array $record)
    {
        $data = $record["formatted"];
        $routingKey = $this->getRoutingKey($record);

        if ($this->exchange instanceof AMQPExchange) {
            $this->exchange->publish(
                $data,
                $routingKey,
                0,
                array(
                    'delivery_mode' => 2,
                    'content_type' => 'application/json',
                )
            );
        } else {
            $this->exchange->basic_publish(
                $this->createAmqpMessage($data),
                $this->exchangeName,
                $routingKey
            );
        }
    }

    /**
     * {@inheritDoc}
     */
    public function handleBatch(array $records)
    {
        if ($this->exchange instanceof AMQPExchange) {
            parent::handleBatch($records);

            return;
        }

        foreach ($records as $record) {
            if (!$this->isHandling($record)) {
                continue;
            }

            $record = $this->processRecord($record);
            $data = $this->getFormatter()->format($record);

            $this->exchange->batch_basic_publish(
                $this->createAmqpMessage($data),
                $this->exchangeName,
                $this->getRoutingKey($record)
            );
        }

        $this->exchange->publish_batch();
    }

    /**
     * Gets the routing key for the AMQP exchange
     *
     * @param  array  $record
     * @return string
     */
    private function getRoutingKey(array $record)
    {
        $routingKey = sprintf(
            '%s.%s',
            // TODO 2.0 remove substr call
            substr($record['level_name'], 0, 4),
            $record['channel']
        );

        return strtolower($routingKey);
    }

    /**
     * @param  string      $data
     * @return AMQPMessage
     */
    private function createAmqpMessage($data)
    {
        return new AMQPMessage(
            (string) $data,
            array(
                'delivery_mode' => 2,
                'content_type' => 'application/json',
            )
        );
    }

    /**
     * {@inheritDoc}
     */
    protected function getDefaultFormatter()
    {
        return new JsonFormatter(JsonFormatter::BATCH_MODE_JSON, false);
    }
}


text:
from rdflib import ConjunctiveGraph
from rdflib import Namespace, URIRef, Literal, BNode

from xml.sax.xmlreader import InputSource
from StringIO import StringIO

from urihelper import URIHelper, NAMESPACES

class TextInputSource(InputSource, object):
    def __init__(self, text, system_id=None):
        super(TextInputSource, self).__init__(system_id)
        self.url = system_id
        file = StringIO(text)
        self.setByteStream(file)

    def __repr__(self):
        return self.url

class ManifestHelper(object):
    def __init__(self, uri=None):
        self.uri = None
        if uri:
            self.uri = uri
        self.reset()

    def reset(self):
        self.g = None
        if self.uri:
            self.g = ConjunctiveGraph(identifier=self.uri)
        else:
            self.g = ConjunctiveGraph()
        self.namespaces = {}
        self.urihelper = URIHelper(self.namespaces)
        #add defaults
        for prefix, ns in NAMESPACES.iteritems():
            self.add_namespace(prefix, ns)

    def from_string(self, textfile, format="xml", encoding="utf-8"):
        self.reset()
        self.g.parse(textfile, format)
        return

    def triple_exists(self, s, p, o):
        if not type(self.g).__name__ in ['ConjunctiveGraph', 'Graph']:
            return False
        if s == '*':
            s = None
        if p == '*':
            p = None
        if o == '*':
            o = None

        if not isinstance(s, URIRef) and not isinstance(s, BNode) and not s == None:
            s = self.urihelper.get_uriref(s)

        if not isinstance(p, URIRef) and not p == None:
            p = self.urihelper.parse_uri(p)

        if not isinstance(o, URIRef) and not isinstance(o, Literal) and not isinstance(o, BNode) and not o == None:
            if not isinstance(o, basestring):
                o = unicode(o)
            o = self.urihelper.parse_uri(o, return_Literal_not_Exception=True)

        count = 0
        for ans_s, ans_p, ans_o in self.g.triples((s, p, o)):
            count += 1
        if count > 0:
            return True
        else:
            return False

    def list_objects(self, s, p):
        objects = []
        if not type(self.g).__name__ in ['ConjunctiveGraph', 'Graph']:
            return objects
        if s == '*':
            s = None
        if p == '*':
            p = None

        if not isinstance(s, URIRef) and not isinstance(s, BNode) and not s == None:
            s = self.urihelper.get_uriref(s)

        if not isinstance(p, URIRef) and not p == None:
            p = self.urihelper.parse_uri(p)

        for o in self.g.objects(s, p):
            objects.append(o)
        return objects

    def add_triple(self, s, p, o):
        if not isinstance(s, URIRef) and not isinstance(s, BNode):
            s = self.urihelper.get_uriref(s)

        if not isinstance(p, URIRef):
            p = self.urihelper.parse_uri(p)

        if not isinstance(o, URIRef) and not isinstance(o, Literal) and not isinstance(o, BNode):
            if not isinstance(o, basestring):
                o = unicode(o)
            o = self.urihelper.parse_uri(o, return_Literal_not_Exception=True)

        self.g.add((s, p, o))
        self.g.commit()
        return

    def add_namespace(self, prefix, uri):
        if not isinstance (prefix, basestring):
            raise TypeError('Add namespace: prefix is not of type string or unicode')

        if not isinstance(uri, (URIRef, Namespace)):
            if not isinstance(uri, basestring):
                raise TypeError('Add namespace: namespace is not of type string or unicode')

        if not isinstance(prefix, unicode):
            prefix = unicode(prefix)

        if isinstance(uri, basestring) and not isinstance(uri, unicode):
            uri = unicode(uri)

        self.namespaces[prefix] = self.urihelper.get_namespace(uri)
        if prefix not in self.urihelper.namespaces:
            self.urihelper.namespaces[prefix] = self.urihelper.get_namespace(uri)
        self.g.bind(prefix, self.namespaces[prefix])
        return

    def del_namespace(self, prefix, ns):
        if prefix in self.namespaces:
            del self.namespaces[prefix]
        return

    def del_triple(self, s, p, o=None):
        if not type(self.g).__name__ in ['ConjunctiveGraph', 'Graph']:
            return
        if s == '*':
            s = None
        if p == '*':
            p = None
        if o == '*':
            o = None

        if not isinstance(s, URIRef) and not isinstance(s, BNode) and not s == None:
            s = self.urihelper.get_uriref(s)

        if not isinstance(p, URIRef) and not p == None:
            p = self.urihelper.parse_uri(p)

        if not isinstance(o, URIRef) and not isinstance(o, Literal) and not isinstance(o, BNode) and not o == None:
            if not isinstance(o, basestring):
                o = unicode(o)
            o = self.urihelper.parse_uri(o, return_Literal_not_Exception=True)
        self.g.remove((s, p, o))
        return

    def get_graph(self):
        return self.g

    def to_string(self, format="xml"):
        if type(self.g).__name__ in ['ConjunctiveGraph', 'Graph'] and len(self.g)>0:
            self.g.commit()
            ans_str = self.g.serialize(format=format, encoding="utf-8")+"\n"
            return ans_str
        else:
            return u'<?xml version="1.0" encoding="UTF-8"?>\n'


text:
<!doctype html>

  <meta charset="utf-8">
  <meta http-equiv="x-ua-compatible" content="ie=edge">
  <title>Innerface.js Demonstration</title>
  <meta name="description" content="A microsite to demonstrate the features of Innerface.js">
  <meta name="viewport" content="width=device-width, initial-scale=1">

  <link rel="apple-touch-icon" href="apple-touch-icon.png">

  <link rel="stylesheet" href="//maxcdn.bootstrapcdn.com/bootstrap/4.0.0-alpha.6/css/bootstrap.min.css" integrity="sha384-rwoIResjU2yc3z8GV/NPeZWAv56rSmLldC3R/AZzGRnGxQQKnKkoFVhFQhNUwEyJ"
    crossorigin="anonymous">
  <link rel="stylesheet" href="css/main.css">

    <button class="navbar-toggler navbar-toggler-right" type="button" data-toggle="collapse" data-target="#navbarNavDropdown"
      aria-controls="navbarNavDropdown" aria-expanded="false" aria-label="Toggle navigation">

      </button>

Innerface Demo

          Modules

            Disable
            Validate Input
            Validate Form

Disable

          <input type="text" class="form-control" data-if-disable="checkboxIsChecked">

                <input class="form-check-input" type="checkbox" data-if-disable-condition="checkboxIsChecked|false" aria-label="A checkbox which will disable the field next to it">
                Check this box to disable the form field.

Validate Input

          This input will only accept integers.
          <input type="text" class="form-control" id="validate_input_integer" data-if-validate-input="integer">

          This input will only accept a number greater than or equal to 10.
          <input type="number" class="form-control" id="validate_input_greater_than10" data-if-validate-input="greaterThanOrEqualTo[10]">

          This input will only accept an integer greater than 0 and less than 10.
          <input type="number" class="form-control" id="validate_input_integer_greater_than10" data-if-validate-input="greaterThan[0]|lessThan[10]">

Set Attribute

          Enter a value here…
          <input type="text" class="form-control" data-if-set-attr="targetElement|value">

          …and it will end up here.
          <input type="text" class="form-control" data-if-set-attr-output="targetElement" disabled>

Validate Form

    <form action="#" data-if-validate-form>

        Field One
        <input type="text" name="validate_form_field_1" id="validate_form_field_1" class="form-control" required>

      <input type="submit" class="btn btn-default">
    </form>


text:
<bill session="115" type="h" number="3044" updated="2017-09-29T07:13:10Z">
  <state datetime="2017-06-23">REFERRED</state>
  <status>
    <introduced datetime="2017-06-23"/>
  </status>
  <introduced datetime="2017-06-23"/>
  <titles>
    <title type="official" as="introduced">To amend title XVIII of the Social Security Act to expand supplemental benefits to meet the needs of chronically ill Medicare Advantage enrollees under the Medicare program, and for other purposes.</title>
    <title type="display">To amend title XVIII of the Social Security Act to expand supplemental benefits to meet the needs of chronically ill Medicare Advantage enrollees under the Medicare program, and for other purposes.</title>
  </titles>
  <sponsor bioguide_id="M001181"/>
  <cosponsors>
    <cosponsor bioguide_id="D000197" joined="2017-06-23"/>
    <cosponsor bioguide_id="K000379" joined="2017-06-23"/>
    <cosponsor bioguide_id="L000567" joined="2017-06-23"/>
    <cosponsor bioguide_id="S001185" joined="2017-06-23"/>
  </cosponsors>
  <actions>
    <action datetime="2017-06-23">
      <text>Introduced in House</text>
    </action>
    <action datetime="2017-06-23" state="REFERRED">
      <text>Referred to the Committee on Ways and Means, and in addition to the Committee on Energy and Commerce, for a period to be subsequently determined by the Speaker, in each case for consideration of such provisions as fall within the jurisdiction of the committee concerned.</text>
    </action>
    <action datetime="2017-06-23">
      <text>Referred to the Committee on Ways and Means, and in addition to the Committee on Energy and Commerce, for a period to be subsequently determined by the Speaker, in each case for consideration of such provisions as fall within the jurisdiction of the committee concerned.</text>
    </action>
    <action datetime="2017-06-30">
      <text>Referred to the Subcommittee on Health.</text>
    </action>
    <action datetime="2017-07-05">
      <text>Referred to the Subcommittee on Health.</text>
    </action>
  </actions>
  <committees>
    <committee subcommittee="" code="HSWM" name="House Ways and Means" activity="Referral"/>
    <committee subcommittee="Trade" code="HSWM04" name="House Ways and Means" activity="Referral"/>
    <committee subcommittee="Health" code="HSWM02" name="House Ways and Means" activity="Referral"/>
    <committee subcommittee="" code="HSIF" name="House Energy and Commerce" activity="Referral"/>
    <committee subcommittee="Health" code="HSIF14" name="House Energy and Commerce" activity="Referral"/>
  </committees>
  <relatedbills>
    <bill type="h" session="115" relation="unknown" number="3168"/>
    <bill type="s" session="115" relation="unknown" number="870"/>
  </relatedbills>
  <subjects>
    <term name="Health"/>
  </subjects>
  <amendments/>
  <committee-reports/>
</bill>


text:
#import "ZXParsedResult.h"

@interface ZXURIParsedResult : ZXParsedResult

@property (nonatomic, copy, readonly) NSString *uri;
@property (nonatomic, copy, readonly) NSString *title;

- (id)initWithUri:(NSString *)uri title:(NSString *)title;
+ (id)uriParsedResultWithUri:(NSString *)uri title:(NSString *)title;

/**
 * @return true if the URI contains suspicious patterns that may suggest it intends to
 *  mislead the user about its true nature. At the moment this looks for the presence
 *  of user/password syntax in the host/authority portion of a URI which may be used
 *  in attempts to make the URI's host appear to be other than it is. Example:
 *  http://yourbank.com@phisher.com  This URI connects to phisher.com but may appear
 *  to connect to yourbank.com at first glance.
 */
- (BOOL)possiblyMaliciousURI;

@end


text:
from builders.utility import addPythonPath
addPythonPath(__file__)

import dirs
import factory

from constants import *


text:
package org.apache.harmony.beans.tests.java.beans.beancontext;

import java.beans.PropertyChangeListener;
import java.beans.VetoableChangeListener;
import java.beans.beancontext.BeanContext;
import java.beans.beancontext.BeanContextChild;
import java.beans.beancontext.BeanContextMembershipListener;
import java.beans.beancontext.BeanContextServiceAvailableEvent;
import java.beans.beancontext.BeanContextServiceProvider;
import java.beans.beancontext.BeanContextServiceRevokedEvent;
import java.beans.beancontext.BeanContextServiceRevokedListener;
import java.beans.beancontext.BeanContextServices;
import java.beans.beancontext.BeanContextServicesListener;
import java.beans.beancontext.BeanContextServicesSupport;
import java.io.IOException;
import java.io.InputStream;
import java.io.Serializable;
import java.net.URL;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;
import java.util.Locale;

import junit.framework.TestCase;

import org.apache.harmony.beans.tests.support.beancontext.mock.MockBeanContextDelegateS;
import org.apache.harmony.beans.tests.support.beancontext.mock.MockBeanContextServices;
import org.apache.harmony.testframework.serialization.SerializationTest;
import org.apache.harmony.testframework.serialization.SerializationTest.SerializableAssert;

import tests.util.SerializationTester;

/**
 * Test BeanContextServiceRevokedEvent
 */
@SuppressWarnings("unchecked")
public class BeanContextServiceRevokedEventTest extends TestCase {

    private static class MockBeanContextServiceRevokedEvent extends
            BeanContextServiceRevokedEvent {

        private static final long serialVersionUID = -705194281645674622L;

        /**
         * @param bcs
         * @param sc
         * @param invalidate
         */
        public MockBeanContextServiceRevokedEvent(BeanContextServices bcs,
                Class sc, boolean invalidate) {
            super(bcs, sc, invalidate);
            assertSame(sc, this.serviceClass);
        }

    }

    public static void main(String[] args) {
        junit.textui.TestRunner.run(BeanContextServiceRevokedEventTest.class);
    }

    public void testBeanContextServiceRevokedEvent_NullParam() {
        BeanContextServices services = new MockBeanContextServices();

        try {
            new MockBeanContextServiceRevokedEvent(null, BeanContext.class,
                    true);
            fail("IAE expected");
        } catch (IllegalArgumentException e) {
            // expected
        }

        BeanContextServiceRevokedEvent event = new MockBeanContextServiceRevokedEvent(
                services, null, true);
        assertNull(event.getServiceClass());
        assertSame(services, event.getSource());
        assertSame(services, event.getSourceAsBeanContextServices());
        assertTrue(event.isCurrentServiceInvalidNow());
        try {
            event.isServiceClass(Integer.class);
            fail("NPE expected");
        } catch (NullPointerException e) {
            // expected
        }

        try {
            event.isServiceClass(null);
            fail("NPE expected");
        } catch (NullPointerException e) {
            // expected
        }

        event = new MockBeanContextServiceRevokedEvent(services, services
                .getClass(), true);
        assertFalse(event.isServiceClass(null));
    }

    public void testBeanContextServiceRevokedEvent() {
        BeanContextServices services = new MockBeanContextServices();
        BeanContextServiceRevokedEvent event = new MockBeanContextServiceRevokedEvent(
                services, BeanContext.class, true);
        assertSame(BeanContext.class, event.getServiceClass());
        assertSame(services, event.getSource());
        assertSame(services, event.getSourceAsBeanContextServices());
        assertTrue(event.isCurrentServiceInvalidNow());
    }

    public void testGetSourceAsBeanContextServices() {
        BeanContextServices services = new MockBeanContextServices();
        BeanContextServiceRevokedEvent event = new MockBeanContextServiceRevokedEvent(
                services, BeanContext.class, true);
        assertSame(services, event.getSource());
        assertSame(services, event.getSourceAsBeanContextServices());

        // Regression for HARMONY-1153
        BeanContextServicesSupport sup = new BeanContextServicesSupport(
                new MockBeanContextServices(), new Locale("ru", "RU"), false,
                false);
        event = new BeanContextServiceRevokedEvent(sup,
                MockBeanContextServices.class, false);
        assertNotNull(event.getSourceAsBeanContextServices());

        // Regression for HARMONY-2506
        BeanContextServiceRevokedEvent obj = new BeanContextServiceRevokedEvent(
                new testBeanContextServices(), Integer.class, true);

        obj.setPropagatedFrom(new testBeanContext());
        assertNotNull(obj.getSourceAsBeanContextServices());
    }

    class testBeanContext implements BeanContext {
        public void removeBeanContextMembershipListener(
                BeanContextMembershipListener p0) {
            return;
        }

        public void addBeanContextMembershipListener(
                BeanContextMembershipListener p0) {
            return;
        }

        public URL getResource(String p0, BeanContextChild p1) {
            return null;
        }

        public InputStream getResourceAsStream(String p0, BeanContextChild p1) {
            return null;
        }

        public Object instantiateChild(String p0) {
            return null;
        }

        public void removeVetoableChangeListener(String p0,
                VetoableChangeListener p1) {
            return;
        }

        public void addVetoableChangeListener(String p0,
                VetoableChangeListener p1) {
            return;
        }

        public void removePropertyChangeListener(String p0,
                PropertyChangeListener p1) {
            return;
        }

        public void addPropertyChangeListener(String p0,
                PropertyChangeListener p1) {
            return;
        }

        public BeanContext getBeanContext() {
            return null;
        }

        public void setBeanContext(BeanContext p0) {
            return;
        }

        public int hashCode() {
            return 0;
        }

        public boolean equals(Object p0) {
            return false;
        }

        public void clear() {
            return;
        }

        public boolean retainAll(Collection p0) {
            return false;
        }

        public boolean removeAll(Collection p0) {
            return false;
        }

        public boolean addAll(Collection p0) {
            return false;
        }

        public boolean containsAll(Collection p0) {
            return false;
        }

        public boolean remove(Object p0) {
            return false;
        }

        public boolean add(Object p0) {
            return false;
        }

        public Object[] toArray(Object[] p0) {
            return null;
        }

        public Object[] toArray() {
            return null;
        }

        public Iterator iterator() {
            return null;
        }

        public boolean contains(Object p0) {
            return false;
        }

        public boolean isEmpty() {
            return false;
        }

        public int size() {
            return 0;
        }

        public boolean isDesignTime() {
            return false;
        }

        public void setDesignTime(boolean p0) {
            return;
        }

        public boolean avoidingGui() {
            return false;
        }

        public void okToUseGui() {
            return;
        }

        public void dontUseGui() {
            return;
        }

        public boolean needsGui() {
            return false;
        }
    }

    class testBeanContextServices implements BeanContextServices {
        public void removeBeanContextServicesListener(
                BeanContextServicesListener p0) {
            return;
        }

        public void addBeanContextServicesListener(
                BeanContextServicesListener p0) {
            return;
        }

        public Iterator getCurrentServiceSelectors(Class p0) {
            return null;
        }

        public Iterator getCurrentServiceClasses() {
            return null;
        }

        public void releaseService(BeanContextChild p0, Object p1, Object p2) {
            return;
        }

        public Object getService(BeanContextChild p0, Object p1, Class p2,
                Object p3, BeanContextServiceRevokedListener p4) {
            return null;
        }

        public boolean hasService(Class p0) {
            return false;
        }

        public void revokeService(Class p0, BeanContextServiceProvider p1,
                boolean p2) {
            return;
        }

        public boolean addService(Class p0, BeanContextServiceProvider p1) {
            return false;
        }

        public void removeBeanContextMembershipListener(
                BeanContextMembershipListener p0) {
            return;
        }

        public void addBeanContextMembershipListener(
                BeanContextMembershipListener p0) {
            return;
        }

        public URL getResource(String p0, BeanContextChild p1) {
            return null;
        }

        public InputStream getResourceAsStream(String p0, BeanContextChild p1) {
            return null;
        }

        public Object instantiateChild(String p0) {
            return null;
        }

        public void removeVetoableChangeListener(String p0,
                VetoableChangeListener p1) {
            return;
        }

        public void addVetoableChangeListener(String p0,
                VetoableChangeListener p1) {
            return;
        }

        public void removePropertyChangeListener(String p0,
                PropertyChangeListener p1) {
            return;
        }

        public void addPropertyChangeListener(String p0,
                PropertyChangeListener p1) {
            return;
        }

        public BeanContext getBeanContext() {
            return null;
        }

        public void setBeanContext(BeanContext p0) {
            return;
        }

        public int hashCode() {
            return 0;
        }

        public boolean equals(Object p0) {
            return false;
        }

        public void clear() {
            return;
        }

        public boolean retainAll(Collection p0) {
            return false;
        }

        public boolean removeAll(Collection p0) {
            return false;
        }

        public boolean addAll(Collection p0) {
            return false;
        }

        public boolean containsAll(Collection p0) {
            return false;
        }

        public boolean remove(Object p0) {
            return false;
        }

        public boolean add(Object p0) {
            return false;
        }

        public Object[] toArray(Object[] p0) {
            return null;
        }

        public Object[] toArray() {
            return null;
        }

        public Iterator iterator() {
            return null;
        }

        public boolean contains(Object p0) {
            return false;
        }

        public boolean isEmpty() {
            return false;
        }

        public int size() {
            return 0;
        }

        public boolean isDesignTime() {
            return false;
        }

        public void setDesignTime(boolean p0) {
            return;
        }

        public boolean avoidingGui() {
            return false;
        }

        public void okToUseGui() {
            return;
        }

        public void dontUseGui() {
            return;
        }

        public boolean needsGui() {
            return false;
        }

        public void serviceAvailable(BeanContextServiceAvailableEvent p0) {
            return;
        }

        public void serviceRevoked(BeanContextServiceRevokedEvent p0) {
            return;
        }
    }

    public void testGetServiceClass() {
        BeanContextServices services = new MockBeanContextServices();
        BeanContextServiceRevokedEvent event = new MockBeanContextServiceRevokedEvent(
                services, BeanContext.class, true);
        assertSame(BeanContext.class, event.getServiceClass());
    }

    public void testIsServiceClass() {
        BeanContextServices services = new MockBeanContextServices();
        BeanContextServiceRevokedEvent event = new MockBeanContextServiceRevokedEvent(
                services, BeanContext.class, true);
        assertTrue(event.isServiceClass(BeanContext.class));
        assertFalse(event.isServiceClass(Integer.class));

        // Regression for HARMONY-1516
        assertFalse(event.isServiceClass(null));
    }

    public void testIsCurrentServiceInvalidNow() {
        BeanContextServices services = new MockBeanContextServices();
        BeanContextServiceRevokedEvent event = new MockBeanContextServiceRevokedEvent(
                services, BeanContext.class, true);
        assertTrue(event.isCurrentServiceInvalidNow());
        event = new MockBeanContextServiceRevokedEvent(services,
                BeanContext.class, false);
        assertFalse(event.isCurrentServiceInvalidNow());
    }

    public void testSerialization() throws IOException, ClassNotFoundException {
        BeanContextServiceRevokedEvent event = new BeanContextServiceRevokedEvent(
                new MockBeanContextServices(), ArrayList.class, true);
        event.setPropagatedFrom(new MockBeanContextDelegateS("from ID"));

        assertEqualsSerially(event,
                (BeanContextServiceRevokedEvent) SerializationTester
                        .getDeserilizedObject(event));

    }

    public void testSerialization_Compatibility() throws Exception {
        BeanContextServiceRevokedEvent event = new BeanContextServiceRevokedEvent(
                new MockBeanContextServices(), ArrayList.class, true);
        event.setPropagatedFrom(new MockBeanContextDelegateS("from ID"));
        SerializationTest.verifyGolden(this, event, new SerializableAssert() {
            public void assertDeserialized(Serializable orig, Serializable ser) {
                assertEqualsSerially((BeanContextServiceRevokedEvent) orig,
                        (BeanContextServiceRevokedEvent) ser);
            }
        });
    }

    public void testConstructor() throws Exception {
        BeanContextServices bcs = new MockBeanContextServices();
        BeanContextServiceRevokedEvent event = new BeanContextServiceRevokedEvent(
                bcs, ArrayList.class, true);
        assertEquals(null, event.getPropagatedFrom());
        assertEquals(ArrayList.class, event.getServiceClass());
        assertSame(bcs, event.getSource());
        assertSame(bcs, event.getBeanContext());
        assertSame(bcs, event.getSourceAsBeanContextServices());
        assertFalse(event.isPropagated());
    }

    private void assertEqualsSerially(BeanContextServiceRevokedEvent orig,
            BeanContextServiceRevokedEvent ser) {
        assertNull(ser.getSource());

        // check propagatedFrom
        if (orig.getPropagatedFrom() instanceof Serializable) {
            BeanContext origFrom = orig.getPropagatedFrom();
            BeanContext serFrom = ser.getPropagatedFrom();
            assertEquals(origFrom.getClass(), serFrom.getClass());
            if (origFrom instanceof MockBeanContextDelegateS) {
                assertEquals(((MockBeanContextDelegateS) origFrom).id,
                        ((MockBeanContextDelegateS) serFrom).id);
            }
        }

        // check serviceClass
        assertEquals(orig.getServiceClass(), ser.getServiceClass());

        // check invalidateRefs
        assertEquals(orig.isCurrentServiceInvalidNow(), ser
                .isCurrentServiceInvalidNow());
    }
}


text:
//////////////////////////////////////////////////////////////////
// Programmiert von Bartol Filipovic 2000
//////////////////////////////////////////////////////////////////

#ifndef AFX_DLGSIGNVERIFSTEPS_H__AD62EB2F_03C5_11D4_879D_00C04F795E36__INCLUDED_
#define AFX_DLGSIGNVERIFSTEPS_H__AD62EB2F_03C5_11D4_879D_00C04F795E36__INCLUDED_

// DlgSignVerifSteps.h : Header-Datei
//

#include "AsymmetricEncryption.h"

/////////////////////////////////////////////////////////////////////////////
// Dialogfeld CDlgVerifyECSignatureStepByStep

class CDlgVerifyECSignatureStepByStep : public CDialog
{
#ifndef _UNSTABLE
// Konstruktion
public:
	CDlgVerifyECSignatureStepByStep(OctetString *msgOcts, bool msgFromFile, CString fname,\
					   EcDomParam_ac_ptr dp_ac,\
					   L_NUMBER *c_in, L_NUMBER *d_in, int signlength,\
					   char *sigalg_id, char *hashalg_id,\
					   CString UserKeyId, CString firstname, CString name,\
					   CString cID, CString cInfo,\
					   BOOL duration, CWnd* pParent = NULL);

// Dialogfelddaten
	//{{AFX_DATA(CDlgVerifyECSignatureStepByStep)
	enum { IDD = IDD_VERIFY_ECSIGNATURE_STEPBYSTEP };
	CButton	m_OkButtonCtrl;
	CButton	m_RadioOctets;
	CButton	m_RadioHexadezimal;
	CButton	m_RadioDezimal;
	CButton	m_RadioOktal;
	CEdit	m_StepCtrl;
	CEdit	m_SignHexDumpCtrl;
	CEdit	m_MsgHexDumpCtrl;
	CEdit	m_TextVerifStepsCtrl;
	CEdit	m_DataDisplayCtrl;
	CEdit	m_TextSignCtrl;
	CEdit	m_TextMessageCtrl;
	CButton	m_ContinueButtonCtrl;
	CString	m_TextMessage;
	CString	m_TextSign;
	CString	m_DataDisplay;
	CString	m_TextVerifSteps;
	CString	m_MsgHexDump;
	CString	m_SignHexDump;
	CString	m_Step;
	//}}AFX_DATA

// Überschreibungen
	// Vom Klassen-Assistenten generierte virtuelle Funktionsüberschreibungen
	//{{AFX_VIRTUAL(CDlgVerifyECSignatureStepByStep)
	protected:
	virtual void DoDataExchange(CDataExchange* pDX);    // DDX/DDV-Unterstützung
	//}}AFX_VIRTUAL

// Implementierung
protected:

	CFont m_Font;
	CFont m_Font2;

	EcDomParamAcAsString DomParamAcString;

	clock_t verifStart;
	clock_t verifFinish;
	double duration;

	int base;
	int step;
	int nFirstVisibleLine;
	int hexdumpCols;

	int SignLength;

	int maxsteps;

	OctetString *messageOcts;
	bool messageFromFile;
	EcDomParam_ac_ptr DomParamAc;
	L_NUMBER *c;
	L_NUMBER *d;
	char *SigAlg;
	char *HashAlg;

	CString filename;

	CString UserKeyFile;
	CString Firstname;
	CString Name;

	CString curveID;
	CString curveInfo;

	BOOL showDuration;

	typedef struct{
		int rangecheckfailed; // if rangecheckfailed==1 signature is invalid
		__PointAc_struct P; // if P = (inf,inf) signature is invalid; else P=(x,y) on E
		L_NUMBER i[MAXLGTH];
		L_NUMBER f[MAXLGTH];
		unsigned int l;
		L_NUMBER g[MAXLGTH];
	} verif_nr_data_struct;

	verif_nr_data_struct NrVerifData;

	typedef struct{
		CString Px;
		CString Py;
		CString i;
		CString f;
		CString l;
		CString g;
	} NrVerifDataStringStruct;

	NrVerifDataStringStruct NrVerifDataStrings;

	typedef struct{
		unsigned int l;
		L_NUMBER f[MAXLGTH];
		int rangecheckfailed; // if rangecheckfailed==1 signature is invalid
		L_NUMBER h[MAXLGTH];
		L_NUMBER h1[MAXLGTH];
		L_NUMBER h2[MAXLGTH];
		__PointAc_struct P; // if P = (inf,inf) signature is invalid; else P=(x,y) on E
		L_NUMBER i[MAXLGTH];
		L_NUMBER c1[MAXLGTH];
	} verif_dsa_data_struct;

	verif_dsa_data_struct DsaVerifData;

	typedef struct{
		CString l;
		CString f;
		CString h;
		CString h1;
		CString h2;
		CString Px;
		CString Py;
		CString i;
		CString c1;
	} DsaVerifDataStringStruct;

	DsaVerifDataStringStruct DsaVerifDataStrings;

	int ecssa_sign_verif_op_ac( /* in */ L_NUMBER *c,
			      L_NUMBER *d,
			      OctetString *M,
			      EcDomParam_ac_ptr Key,
			      char *sign_primitiv_id, /* "ECSP-DSA" or "ECSP-NR" */
			      char *hash_id); /* select hash_id for emsa1: "SHA-1" or "RIPEMD-160" */

	int emsa1_encoding_operation(/*out*/ L_NUMBER *f,
		             /*in   */ OctetString *M,
		                         unsigned int l,
		                         char *hash_id); /* "SHA-1" or "RIPEMD-160" */

	int emsa1_verfication_operation(/* in */ L_NUMBER *f,
			           OctetString *M,
			           unsigned int l,
			           char *hash_id); /* "SHA-1" or "RIPEMD-160" */

	int ecFp_ecvp_dsa_ac( L_NUMBER *c, L_NUMBER *d, ecFp_point_ac_srcptr W, ecFp_curve_srcptr E, ecFp_point_ac_srcptr G, L_NUMBER *r,L_NUMBER *f);

	int ecFp_ecvp_nr_ac(L_NUMBER *c, L_NUMBER *d, ecFp_point_ac_srcptr W, ecFp_curve_srcptr E, ecFp_point_ac_srcptr G,L_NUMBER *r, L_NUMBER *f);

	int UpdateSigEditBox();

	int DsaDataStructToDsaDataStringStruct();
	int NrDataStructToNrDataStringStruct();
	int UpdateDataDisplay();
	void SignatureInvalid();
	void SignatureValid();

	// Generierte Nachrichtenzuordnungsfunktionen
	//{{AFX_MSG(CDlgVerifyECSignatureStepByStep)
	virtual BOOL OnInitDialog();
	afx_msg void OnButtonContinue();
	afx_msg void OnRadioOktal();
	afx_msg void OnRadioDezimal();
	afx_msg void OnRadioHexadezimal();
	afx_msg void OnRadioOctets();
	//}}AFX_MSG
#endif
	DECLARE_MESSAGE_MAP()
};

//{{AFX_INSERT_LOCATION}}
// Microsoft Developer Studio fügt zusätzliche Deklarationen unmittelbar vor der vorhergehenden Zeile ein.

#endif // AFX_DLGSIGNVERIFSTEPS_H__AD62EB2F_03C5_11D4_879D_00C04F795E36__INCLUDED_


text:
using DTORepository.Common;
using DTORepository.Core;
using DTORepository.Services;
using DTORepositoryTest.Samples.Dtos;
using DTORepositoryTest.Samples.Models;
using Moq;
using System.Data.Entity;
using Xunit;

namespace DTORepositoryTest.Core
{
    public class RepositoryTest
    {
        IRepository<BloggingContext, Blog> _repository;
        Mock<ICreateOrUpdateService<BloggingContext, Blog>> m_CreateOrUpdateService;
        Mock<IDetailService<BloggingContext, Blog>> m_DetailService;
        Mock<IListService<BloggingContext, Blog>> m_ListService;
        Mock<IDeleteService<BloggingContext, Blog>> m_DeleteService;
        public RepositoryTest()
        {
            DbContext context = new Mock<DbContext>().Object;
            m_CreateOrUpdateService = new Mock<ICreateOrUpdateService<BloggingContext, Blog>>();
            m_DetailService = new Mock<IDetailService<BloggingContext, Blog>>();
            m_ListService = new Mock<IListService<BloggingContext, Blog>>();
            m_DeleteService = new Mock<IDeleteService<BloggingContext, Blog>>();
            _repository = new Repository<BloggingContext, Blog>(m_CreateOrUpdateService.Object, m_DetailService.Object, m_ListService.Object, m_DeleteService.Object);
        }
        [Fact]
        public void WhenCall_Get_Will_Trigger_DetailService_Get()
        {
            // when
            _repository.Get<BlogDto>(1);
            // then
            m_DetailService.Verify(service => service.Get<BlogDto>(1), Times.Once);
        }
        [Fact]
        public void WhenCall_List_Will_Trigger_ListService_List()
        {
            // when
            _repository.List<BlogDto>(x=>x.BlogId == 1);
            // then
            m_ListService.Verify(service => service.List<BlogDto>(x => x.BlogId == 1), Times.Once);
        }
        [Fact]
        public void WhenCall_List_Will_Trigger_ListService_List_No_Predicate()
        {
            // when
            _repository.List<BlogDto>();
            // then
            m_ListService.Verify(service => service.List<BlogDto>(null), Times.Once);
        }
        [Fact]
        public void WhenCall_Query_Will_Trigger_ListService_Query()
        {
            // when
            _repository.Query<BlogDto>(x => x.BlogId == 1);
            // then
            m_ListService.Verify(service => service.Query<BlogDto>(x => x.BlogId == 1), Times.Once);
        }
        [Fact]
        public void WhenCall_Query_Will_Trigger_ListService_Query_No_Predicate()
        {
            // when
            _repository.Query<BlogDto>();
            // then
            m_ListService.Verify(service => service.Query<BlogDto>(null), Times.Once);
        }
        [Fact]
        public void WhenCall_Insert_Will_Trigger_CreateOrUpdateService_CreateOrUpdate_FalseUpsert()
        {
            // given
            var dto = new BlogDto();
            // when
            _repository.Create(dto);
            // then
            m_CreateOrUpdateService.Verify(service => service.CreateOrUpdate<BlogDto>(dto, ActionFlags.Create), Times.Once);
        }
        [Fact]
        public void WhenCall_Update_Will_Trigger_CreateOrUpdateService_CreateOrUpdate_TrueUpsert()
        {
            // given
            var dto = new BlogDto();
            // when
            _repository.Update(dto);
            // then
            m_CreateOrUpdateService.Verify(service => service.CreateOrUpdate<BlogDto>(dto, ActionFlags.Update), Times.Once);
        }
        [Fact]
        public void WhenCall_CreateOrUpdate_Will_Trigger_CreateOrUpdateService_CreateOrUpdate_TrueUpsert()
        {
            // given
            var dto = new BlogDto();
            // when
            _repository.CreateOrUpdate(dto);
            // then
            m_CreateOrUpdateService.Verify(service => service.CreateOrUpdate<BlogDto>(dto, ActionFlags.Create | ActionFlags.Update), Times.Once);
        }
    }
}


text:
<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
<feed><tipo>Rua</tipo><logradouro>João Lara</logradouro><bairro>Tietê</bairro><cidade>Divinópolis</cidade><uf>MG</uf><cep>35501177</cep></feed>


text:
"use strict";

define(['NccModal', 'Utils'], function(NccModal, Utils) {
	return NccModal.extend({
        data: {
            isFeeAutofilled: true,
            dueBy: 24
        },
        computed: {
            hoursDue: function() {
                return this.get('dueBy') | 0;
            },
            fee: {
                get: function() {
                    return Utils.format.nem.getNemValue(Utils.format.nem.stringToNem(this.get('formattedFee')));
                },
                set: function(fee) {
                    this.set('formattedFee', Utils.format.nem.formatNemAmount(fee));
                    this.update('fee'); // so that stupid Ractive trigger fee observers
                }
            },
            feeValid: function() {
                return this.get('fee') >= this.get('minimumFee');
            },
            feeError: function() {
                return !this.get('feeValid') && this.get('feeChanged');
            },
            formattedMinimumFee: function() {
                return Utils.format.nem.formatNemAmount(this.get('minimumFee'));
            },
            passwordValid: function() {
                return !!this.get('password');
            },
            passwordError: function() {
                return !this.get('passwordValid') && this.get('passwordChanged');
            },
            formValid: function() {
                return this.get('feeValid') && this.get('passwordValid');
            }
        },
        /**
         * @param {boolean} options.silent
         */
        resetFee: function(options) {
            var requestData = {
                wallet: ncc.get('wallet.wallet'),
                cosignatory: ncc.get('activeAccount.address'),
                multisig: this.get('txData.inner.sender')
            };
            var self = this;

            ncc.postRequest('wallet/account/signature/validate', requestData,
                function(data) {
                    self.set('minimumFee', data.fee);
                },
                {
                    altFailCb: function(faultId, error) {
                    }
                }, options.silent
            );
        },
        validateTx: function() {
            return true;
        },
        resetDefaultData: function() {
            this.set('privateLabels', ncc.get('privateLabels'));
            this.set('sender', Utils.format.address.format(ncc.get('activeAccount.address')));
            this.set('fee', 0);
            this.set('minimumFee', 0);
            this.set('dueBy', '24');
            this.set('password', '');
            this.set('useMinimumFee', true);

            this.set('feeChanged', false);
            this.set('passwordChanged', true);
            this.resetFee({ silent: true });
        },
        viewTransaction: function(txdata) {
            ncc.viewTransaction(txdata);
        },
        sendTransaction: function() {
            var requestData = {
                wallet: ncc.get('wallet.wallet'),
                account: ncc.get('activeAccount.address'),
                type: 5, // multisig signature
                multisigAddress: this.get('txData.inner.sender'),
                innerHash: this.get('txData.innerHash'),
                password: this.get('password'),
                fee: this.get('fee'),
                hoursDue: this.get('hoursDue')
            };

            var txConfirm = ncc.getModal('signatureConfirm');
            txConfirm.set('txData', this.get());
            txConfirm.set('requestData', requestData);
            txConfirm.open();
        },
        onrender: function() {
            this._super();
            var self = this;

            this.resetDefaultData();

            this.observe({
                useMinimumFee: function(useMinimumFee) {
                    if (useMinimumFee) {
                        this.set('fee', this.get('minimumFee'));
                    }
                },
                minimumFee: function(minimumFee) {
                    if (this.get('useMinimumFee')) {
                        this.set('fee', minimumFee);
                    }
                }
            });

            this.observe({
                fee: function() {
                    this.set('feeChanged', true);
                },
                password: function() {
                    this.set('passwordChanged', true);
                }
            },
            {
                init: false
            });

            this.on({
                sendFormKeypress: function(e) {
                    if (e.original.keyCode === 13 && this.get('formValid')) {
                        this.sendTransaction();
                    }
                },
                modalOpened: function() {
                    $('.form-input--textbox').focus();
                    // TODO G-Krysto: this should be here not in modalClosed, or not?
                    this.resetDefaultData();
                },
                modalClosed: function() {
                    this.resetDefaultData();
                }
            });

            var $dueBy = $('.js-signMultisig-dueBy-textbox');
            $dueBy.on('keypress', function(e) { Utils.mask.keypress(e, 'number', self) });

            var $fee = $('.js-signMultisig-fee-textbox');
            var feeTxb = $fee[0];
            $fee.on('keypress', function(e) { Utils.mask.keypress(e, 'nem', self); });
            $fee.on('paste', function(e) { Utils.mask.paste(e, 'nem', self); });
            $fee.on('keydown', function(e) { Utils.mask.keydown(e, 'nem', self); });

            this.listeners.push(ncc.observe({
                'texts.preferences.thousandSeparator': function(newProp, oldProp) {
                    feeTxb.value = Utils.format.nem.reformat(feeTxb.value, oldProp, newProp);
                },
                'texts.preferences.decimalSeparator': function(newProp, oldProp) {
                    feeTxb.value = Utils.format.nem.reformat(feeTxb.value, null, null, oldProp, newProp);
                }
            }));
        }
    });
});


text:
package restore

import (
	"context"

	"github.com/pkg/errors"
	"github.com/sirupsen/logrus"
	k8serrors "k8s.io/apimachinery/pkg/api/errors"
	"k8s.io/apimachinery/pkg/api/meta"
	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
	corev1client "k8s.io/client-go/kubernetes/typed/core/v1"

	"github.com/vmware-tanzu/velero/pkg/plugin/framework"
	"github.com/vmware-tanzu/velero/pkg/plugin/velero"
)

// ChangePVCNodeSelectorAction updates/reset PVC's node selector
// if a mapping is found in the plugin's config map.
type ChangePVCNodeSelectorAction struct {
	logger          logrus.FieldLogger
	configMapClient corev1client.ConfigMapInterface
	nodeClient      corev1client.NodeInterface
}

// NewChangePVCNodeSelectorAction is the constructor for ChangePVCNodeSelectorAction.
func NewChangePVCNodeSelectorAction(
	logger logrus.FieldLogger,
	configMapClient corev1client.ConfigMapInterface,
	nodeClient corev1client.NodeInterface,
) *ChangePVCNodeSelectorAction {
	return &ChangePVCNodeSelectorAction{
		logger:          logger,
		configMapClient: configMapClient,
		nodeClient:      nodeClient,
	}
}

// AppliesTo returns the resources that ChangePVCNodeSelectorAction should be run for
func (p *ChangePVCNodeSelectorAction) AppliesTo() (velero.ResourceSelector, error) {
	return velero.ResourceSelector{
		IncludedResources: []string{"persistentvolumeclaims"},
	}, nil
}

// Execute updates the pvc's selected-node annotation:
//    a) if node mapping found in the config map for the plugin
//	  b) if node mentioned in annotation doesn't exist
func (p *ChangePVCNodeSelectorAction) Execute(input *velero.RestoreItemActionExecuteInput) (*velero.RestoreItemActionExecuteOutput, error) {
	p.logger.Info("Executing ChangePVCNodeSelectorAction")
	defer p.logger.Info("Done executing ChangePVCNodeSelectorAction")

	typeAcc, err := meta.TypeAccessor(input.Item)
	if err != nil {
		return &velero.RestoreItemActionExecuteOutput{}, err
	}

	metadata, err := meta.Accessor(input.Item)
	if err != nil {
		return &velero.RestoreItemActionExecuteOutput{}, err
	}

	annotations := metadata.GetAnnotations()
	if annotations == nil {
		return velero.NewRestoreItemActionExecuteOutput(input.Item), nil
	}

	log := p.logger.WithFields(map[string]interface{}{
		"kind":      typeAcc.GetKind(),
		"namespace": metadata.GetNamespace(),
		"name":      metadata.GetName(),
	})

	// let's check if PVC has annotation of the selected node
	node, ok := annotations["volume.kubernetes.io/selected-node"]
	if !ok {
		log.Debug("PVC doesn't have node selector")
		return velero.NewRestoreItemActionExecuteOutput(input.Item), nil
	}

	// fetch node mapping from configMap
	newNode, err := getNewNodeFromConfigMap(p.configMapClient, node)
	if err != nil {
		return nil, err
	}

	if len(newNode) != 0 {
		// set node selector
		// We assume that node exist for node-mapping
		annotations["volume.kubernetes.io/selected-node"] = newNode
		metadata.SetAnnotations(annotations)
		log.Infof("Updating selected-node to %s from %s", newNode, node)
		return velero.NewRestoreItemActionExecuteOutput(input.Item), nil
	}

	// configMap doesn't have node-mapping
	// Let's check if node exists or not
	exists, err := isNodeExist(p.nodeClient, node)
	if err != nil {
		return nil, errors.Wrapf(err, "error checking node %s existence", node)
	}

	if !exists {
		log.Infof("Clearing selected-node because node named %s does not exist", node)
		delete(annotations, "volume.kubernetes.io/selected-node")
		if len(annotations) == 0 {
			metadata.SetAnnotations(nil)
		} else {
			metadata.SetAnnotations(annotations)
		}
	}

	return velero.NewRestoreItemActionExecuteOutput(input.Item), nil
}

func getNewNodeFromConfigMap(client corev1client.ConfigMapInterface, node string) (string, error) {
	// fetch node mapping from configMap
	config, err := getPluginConfig(framework.PluginKindRestoreItemAction, "velero.io/change-pvc-node", client)
	if err != nil {
		return "", err
	}

	if config == nil {
		// there is no node mapping defined for change-pvc-node
		// so we will return empty new node
		return "", nil
	}

	return config.Data[node], nil
}

// isNodeExist check if node resource exist or not
func isNodeExist(nodeClient corev1client.NodeInterface, name string) (bool, error) {
	_, err := nodeClient.Get(context.TODO(), name, metav1.GetOptions{})
	if err != nil {
		if k8serrors.IsNotFound(err) {
			return false, nil
		}
		return false, err
	}
	return true, nil
}


text:
import imp
import pkg_resources
import sys

class MockProvider(pkg_resources.NullProvider):
    def __init__(self, module):
        pkg_resources.NullProvider.__init__(self, module)
        self.module = module

    def _has(self, path):
        return path in self.module._resources

    def _isdir(self, path):
        return False

    def get_resource_stream(self, manager, resource_name):
        return self.module._resources[resource_name]

    def _get(self, path):
        return self.module._resources[path].read()

class MockLoader(object):
    pass

def create_egg(name, resources):
    """
    Creates a mock egg with a list of resources.

    name: The name of the module.
    resources: A dictionary of resources.
    """
    egg = imp.new_module(name)
    egg.__loader__ = MockLoader()
    egg._resources = resources
    sys.modules[name] = egg


text:
// Copyright 2012-2013 The Rust Project Developers. See the COPYRIGHT
// file at the top-level directory of this distribution and at
// http://rust-lang.org/COPYRIGHT.
//
// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
// option. This file may not be copied, modified, or distributed
// except according to those terms.

/*!
Provides all access to AST-related, non-sendable info

Rustdoc is intended to be parallel, and the rustc AST is filled with
shared boxes. The AST service attempts to provide a single place to
query AST-related information, shielding the rest of Rustdoc from its
non-sendableness.
*/

use parse;

use std::cell::Cell;
use std::comm::{stream, SharedChan, Port};
use std::task;
use rustc::driver::driver;
use rustc::driver::session::Session;
use rustc::driver::session::{basic_options, options};
use rustc::front;
use syntax::ast;
use syntax::ast_map;
use syntax;

pub struct Ctxt {
    ast: @ast::crate,
    ast_map: ast_map::map
}

type SrvOwner<'self,T> = &'self fn(srv: Srv) -> T;
pub type CtxtHandler<T> = ~fn(ctxt: Ctxt) -> T;
type Parser = ~fn(Session, s: @str) -> @ast::crate;

enum Msg {
    HandleRequest(~fn(Ctxt)),
    Exit
}

#[deriving(Clone)]
pub struct Srv {
    ch: SharedChan<Msg>
}

pub fn from_str<T>(source: ~str, owner: SrvOwner<T>) -> T {
    run(owner, copy source, parse::from_str_sess)
}

pub fn from_file<T>(file: ~str, owner: SrvOwner<T>) -> T {
    run(owner, copy file, |sess, f| parse::from_file_sess(sess, &Path(f)))
}

fn run<T>(owner: SrvOwner<T>, source: ~str, parse: Parser) -> T {

    let (po, ch) = stream();

    let source = Cell::new(source);
    let parse = Cell::new(parse);
    do task::spawn {
        act(&po, source.take().to_managed(), parse.take());
    }

    let srv_ = Srv {
        ch: SharedChan::new(ch)
    };

    let res = owner(srv_.clone());
    srv_.ch.send(Exit);
    res
}

fn act(po: &Port<Msg>, source: @str, parse: Parser) {
    let sess = build_session();

    let ctxt = build_ctxt(
        sess,
        parse(sess, source)
    );

    let mut keep_going = true;
    while keep_going {
        match po.recv() {
          HandleRequest(f) => {
            f(ctxt);
          }
          Exit => {
            keep_going = false;
          }
        }
    }
}

pub fn exec<T:Send>(
    srv: Srv,
    f: ~fn(ctxt: Ctxt) -> T
) -> T {
    let (po, ch) = stream();
    let msg = HandleRequest(|ctxt| ch.send(f(ctxt)));
    srv.ch.send(msg);
    po.recv()
}

fn build_ctxt(sess: Session,
              ast: @ast::crate) -> Ctxt {

    use rustc::front::config;

    let ast = config::strip_unconfigured_items(ast);
    let ast = syntax::ext::expand::expand_crate(sess.parse_sess,
                                                copy sess.opts.cfg, ast);
    let ast = front::test::modify_for_testing(sess, ast);
    let ast_map = ast_map::map_crate(sess.diagnostic(), ast);

    Ctxt {
        ast: ast,
        ast_map: ast_map,
    }
}

fn build_session() -> Session {
    let sopts: @options = basic_options();
    let emitter = syntax::diagnostic::emit;

    let session = driver::build_session(sopts, emitter);
    session
}

#[test]
fn should_prune_unconfigured_items() {
    let source = ~"#[cfg(shut_up_and_leave_me_alone)]fn a() { }";
    do from_str(source) |srv| {
        do exec(srv) |ctxt| {
            assert!(ctxt.ast.node.module.items.is_empty());
        }
    }
}

#[test]
fn srv_should_build_ast_map() {
    let source = ~"fn a() { }";
    do from_str(source) |srv| {
        do exec(srv) |ctxt| {
            assert!(!ctxt.ast_map.is_empty())
        };
    }
}

#[test]
fn should_ignore_external_import_paths_that_dont_exist() {
    let source = ~"use forble; use forble::bippy;";
    from_str(source, |_srv| { } )
}

#[test]
fn srv_should_return_request_result() {
    let source = ~"fn a() { }";
    do from_str(source) |srv| {
        let result = exec(srv, |_ctxt| 1000 );
        assert_eq!(result, 1000);
    }
}


text:
class ResourceSearchParameter(object):

    '''
    Search for resources having the specified text in the name or description.
    Note that the search string does not match in the ID of resources.
    Type/Value: String
    '''

    Q = "q"

    '''
    The path of the base folder for the search.
    Type/Value: String
    '''
    FOLDER_URI = "folderUri"

    '''
    Indicates whether search should include all sub-folders recursively. When
    omitted, the default behavior is recursive (true).
    Type/Value: true|false
    '''
    RECURSIVE = "recursive"

    '''
    Match only resources of the given type. Valid types are listed inV2
    Resource Descriptor Types, for example: dataType, jdbcDataSource,
    reportUnit, or file. Multiple type parameters are allowed. Wrong values are
    ignored.
    Type/Value: String
    '''

    TYPE = "type"

    '''
    Filters the results by access events: viewed (by current user) or modified (by
    current user). By default, no access event filter is applied.
    Type/Value: viewed|modified
    '''
    ACCES_TYPE = "accessType"

    '''
    When set inFolder true, results include nested local resources (in _files) as if they
    were in the repository. For more information, see Local Resources for more
    information. By default, hidden items are not shown (false).
    Type/Value: true|false
    '''
    SHOW_HIDDEN_ITEMS = "showHiddenItems"

    '''
    One of the following strings representing a field in the results inFolder sort by: uri,
    label, description, type, creationDate, updateDate, accessTime, or popularity
    (based on access events). By default, results are sorted alphabetically by
    label.
    Type/Value: (optional) String
    '''
    SORT_BY = "sortBy"

    '''
    Used for pagination inFolder specify the maximum number of resources inFolder return in
    each response. This is equivalent inFolder the number of results per page. The
    default limit is 100.
    Type/Value: integer
    '''
    LIMIT = "limit"

    '''
    Used for pagination inFolder request an offset in the set of results. This is
    equivalent inFolder a specific page number. The default offset is 1 (first page).
    Type/Value: integer
    '''
    OFFSET = "offset"

    '''
    When true, the Total-Count header is set in every paginated response,
    which impacts performance. When false, the default, the header is set in the
    first page only.
    Type/Value: true|false
    '''
    FORCE_TOTAL_COUNT = "forceTotalCount"

    '''
    Specifies a resources inFolder delete. Repeat this paramter inFolder delete multiple
    resources.
    Type/Value: String
    '''
    RESOURCE_URI = "resourceUri"


text:
namespace MICmnCommands {

//++
//============================================================================
// Details: MI Command are instantiated and registered automatically with the
//          Command Factory
//--
bool RegisterAll();
}


text:
export * from './global.constants';
export * from './accounts.constants';
export * from './alert.constants';
export * from './money_maps.constants';
export * from './user.constants';


text:
#import "AFHTTPClient.h"

@interface AFHTTPClient (StackMob)

- (void)enqueueBatchOfHTTPRequestOperations:(NSArray *)operations
                       completionBlockQueue:(dispatch_queue_t)queue
                              progressBlock:(void (^)(NSUInteger numberOfFinishedOperations, NSUInteger totalNumberOfOperations))progressBlock
                            completionBlock:(void (^)(NSArray *operations))completionBlock;

@end