text:
package com.hubspot.jinjava.lib.exptest;

import com.hubspot.jinjava.doc.annotations.JinjavaDoc;
import com.hubspot.jinjava.doc.annotations.JinjavaParam;
import com.hubspot.jinjava.doc.annotations.JinjavaSnippet;
import com.hubspot.jinjava.interpret.InterpretException;
import com.hubspot.jinjava.interpret.JinjavaInterpreter;

@JinjavaDoc(value = "Check if a variable is divisible by a number",
    params = {
        @JinjavaParam(value = "num", type = "number", desc = "The number to check whether a number is divisble by")
    },
    snippets = {
        @JinjavaSnippet(
            code = "{% if variable is divisbleby 5 %}\n" +
                "   <!--code to render if variable can be divided by 5-->\n" +
                "{% else %}\n" +
                "   <!--code to render if variable cannot be divided by 5-->\n" +
                "{% endif %}")
    })
public class IsDivisibleByExpTest implements ExpTest {

  @Override
  public String getName() {
    return "divisibleby";
  }

  @Override
  public boolean evaluate(Object var, JinjavaInterpreter interpreter, Object... args) {
    if (var == null) {
      return false;
    }
    if (!Number.class.isAssignableFrom(var.getClass())) {
      return false;
    }

    if (args.length == 0 || args[0] == null || !Number.class.isAssignableFrom(args[0].getClass())) {
      throw new InterpretException(getName() + " test requires a numeric argument");
    }

    return ((Number) var).intValue() % ((Number) args[0]).intValue() == 0;
  }

}


text:
        <meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
        <title>W30868_text</title>
        <link rel="stylesheet" type="text/css" href="style.css" />

                «

    <p class="styleSans32.0000<enum PANGO_WEIGHT_NORMAL of type PangoWeight><enum PANGO_STYLE_NORMAL of type PangoStyle>">DIVIDE
éMcoumy

    <p class="styleSans10.0000<enum PANGO_WEIGHT_NORMAL of type PangoWeight><enum PANGO_STYLE_NORMAL of type PangoStyle>">September 15, 2014

    <p class="styleSans9.0000<enum PANGO_WEIGHT_NORMAL of type PangoWeight><enum PANGO_STYLE_NORMAL of type PangoStyle>">NORTH PLAINS ENERGY ATTN: Aaron Olson

    <p class="styleSans9.0000<enum PANGO_WEIGHT_NORMAL of type PangoWeight><enum PANGO_STYLE_NORMAL of type PangoStyle>">SUBJECT: Request for 911 Address

    <p class="styleSans11.0000<enum PANGO_WEIGHT_NORMAL of type PangoWeight><enum PANGO_STYLE_NORMAL of type PangoStyle>">This is to confirm that I have received your request for 911 addresses for the following well sites:
STATE 160-100-21—16-1H (previously requested under name Stewart 160-100-21-16H)

    <p class="styleSans9.0000<enum PANGO_WEIGHT_NORMAL of type PangoWeight><enum PANGO_STYLE_NORMAL of type PangoStyle>">SE1/4

    <p class="styleSans11.0000<enum PANGO_WEIGHT_NORMAL of type PangoWeight><enum PANGO_STYLE_NORMAL of type PangoStyle>">At the present time. I am not assigning a 911 address to the well listed above. The law states that you must request an address but it does not require that we assign one.
The North Dakota Department of Emergency Services and the 911 Association have appointed a work group to determine the best means of tracking oii and gas well sites. The NDIC has well specific information to inciude the NDIC file number and Lat/Long coordinates

    <p class="styleSans15.0000<enum PANGO_WEIGHT_NORMAL of type PangoWeight><enum PANGO_STYLE_NORMAL of type PangoStyle>">Sincerely,
J", A "4%-

    <p class="styleSans12000<enum PANGO_WEIGHT_NORMAL of type PangoWeight><enum PANGO_STYLE_NORMAL of type PangoStyle>">

    <p class="styleSans10.0000<enum PANGO_WEIGHT_NORMAL of type PangoWeight><enum PANGO_STYLE_NORMAL of type PangoStyle>">yW7H( U/V UrL/
Jan Jacobson Deputy Clerk Divide County Emergency Manager/911 Coordinator

    <p class="styleSans12000<enum PANGO_WEIGHT_NORMAL of type PangoWeight><enum PANGO_STYLE_NORMAL of type PangoStyle>">

    <p class="styleSans12000<enum PANGO_WEIGHT_NORMAL of type PangoWeight><enum PANGO_STYLE_NORMAL of type PangoStyle>">

    <p class="styleSans8.0000<enum PANGO_WEIGHT_NORMAL of type PangoWeight><enum PANGO_STYLE_NORMAL of type PangoStyle>">SEC: 21

    <p class="styleSans12000<enum PANGO_WEIGHT_NORMAL of type PangoWeight><enum PANGO_STYLE_NORMAL of type PangoStyle>">

    <p class="styleSans9.0000<enum PANGO_WEIGHT_NORMAL of type PangoWeight><enum PANGO_STYLE_NORMAL of type PangoStyle>">TOWNSHIP

    <p class="styleSans8.0000<enum PANGO_WEIGHT_NORMAL of type PangoWeight><enum PANGO_STYLE_NORMAL of type PangoStyle>">160N

    <p class="styleSans12000<enum PANGO_WEIGHT_NORMAL of type PangoWeight><enum PANGO_STYLE_NORMAL of type PangoStyle>">

    <p class="styleSans8.0000<enum PANGO_WEIGHT_NORMAL of type PangoWeight><enum PANGO_STYLE_NORMAL of type PangoStyle>">RANGE:

    <p class="styleSans8.0000<enum PANGO_WEIGHT_NORMAL of type PangoWeight><enum PANGO_STYLE_NORMAL of type PangoStyle>">100W

redpajama_set_name: RedPajamaGithub


text:
using namespace std;
using namespace triagens::basics;
using namespace triagens::arango;
using namespace triagens::rest;

////////////////////////////////////////////////////////////////////////////////
/// @brief slot for a "collection"
////////////////////////////////////////////////////////////////////////////////

static int const SLOT_COLLECTION = 2;

////////////////////////////////////////////////////////////////////////////////
/// @brief free a coordinator collection
////////////////////////////////////////////////////////////////////////////////

void FreeCoordinatorCollection (TRI_vocbase_col_t* collection) {
  TRI_DestroyReadWriteLock(&collection->_lock);
  TRI_Free(TRI_UNKNOWN_MEM_ZONE, collection);
}

////////////////////////////////////////////////////////////////////////////////
/// @brief releases a collection
////////////////////////////////////////////////////////////////////////////////

void ReleaseCollection (TRI_vocbase_col_t const* collection) {
  TRI_ReleaseCollectionVocBase(collection->_vocbase, const_cast<TRI_vocbase_col_t*>(collection));
}

////////////////////////////////////////////////////////////////////////////////
/// @brief convert a collection info into a TRI_vocbase_col_t
////////////////////////////////////////////////////////////////////////////////

TRI_vocbase_col_t* CoordinatorCollection (TRI_vocbase_t* vocbase,
                                          CollectionInfo const& ci) {
  TRI_vocbase_col_t* c = static_cast<TRI_vocbase_col_t*>(TRI_Allocate(TRI_UNKNOWN_MEM_ZONE, sizeof(TRI_vocbase_col_t), false));

  if (c == nullptr) {
    return nullptr;
  }

  c->_isLocal    = false;
  c->_vocbase    = vocbase;
  c->_type       = ci.type();
  c->_cid        = ci.id();
  c->_planId     = ci.id();
  c->_status     = ci.status();
  c->_collection = 0;

  std::string const name = ci.name();

  memset(c->_name, 0, TRI_COL_NAME_LENGTH + 1);
  memcpy(c->_name, name.c_str(), name.size());
  memset(c->_path, 0, TRI_COL_PATH_LENGTH + 1);

  memset(c->_dbName, 0, TRI_COL_NAME_LENGTH + 1);
  memcpy(c->_dbName, vocbase->_name, strlen(vocbase->_name));

  c->_canDrop   = true;
  c->_canUnload = true;
  c->_canRename = true;

  if (TRI_IsSystemNameCollection(c->_name)) {
    // a few system collections have special behavior
    if (TRI_EqualString(c->_name, TRI_COL_NAME_USERS) ||
        TRI_IsPrefixString(c->_name, TRI_COL_NAME_STATISTICS)) {
      // these collections cannot be dropped or renamed
      c->_canDrop   = false;
      c->_canRename = false;
    }
  }

  TRI_InitReadWriteLock(&c->_lock);

  return c;
}

///////////////////////////////////////////////////////////////////////////////
/// @brief check if a name belongs to a collection
////////////////////////////////////////////////////////////////////////////////

bool EqualCollection (CollectionNameResolver const* resolver,
                      string const& collectionName,
                      TRI_vocbase_col_t const* collection) {
  if (collectionName == StringUtils::itoa(collection->_cid)) {
    return true;
  }

  if (collectionName == string(collection->_name)) {
    return true;
  }

  if (ServerState::instance()->isCoordinator()) {
    if (collectionName == resolver->getCollectionNameCluster(collection->_cid)) {
      return true;
    }
    return false;
  }

  if (collectionName == resolver->getCollectionName(collection->_cid)) {
    return true;
  }

  return false;
}

////////////////////////////////////////////////////////////////////////////////
/// @brief create a v8 collection id value from the internal collection id
////////////////////////////////////////////////////////////////////////////////

static inline v8::Handle<v8::Value> V8CollectionId (TRI_voc_cid_t cid) {
  char buffer[21];
  size_t len = TRI_StringUInt64InPlace((uint64_t) cid, (char*) &buffer);

  return v8::String::New((const char*) buffer, (int) len);
}

////////////////////////////////////////////////////////////////////////////////
/// @brief weak reference callback for collections
////////////////////////////////////////////////////////////////////////////////

static void WeakCollectionCallback (v8::Isolate* isolate,
                                    v8::Persistent<v8::Value> object,
                                    void* parameter) {
  TRI_v8_global_t* v8g = static_cast<TRI_v8_global_t*>(v8::Isolate::GetCurrent()->GetData());
  TRI_vocbase_col_t* collection = static_cast<TRI_vocbase_col_t*>(parameter);

  v8g->_hasDeadObjects = true;

  v8::HandleScope scope; // do not remove, will fail otherwise!!

  // decrease the reference-counter for the database
  TRI_ReleaseVocBase(collection->_vocbase);

  // find the persistent handle
  v8::Persistent<v8::Value> persistent = v8g->JSCollections[collection];
  v8g->JSCollections.erase(collection);

  if (! collection->_isLocal) {
    FreeCoordinatorCollection(collection);
  }

  // dispose and clear the persistent handle
  persistent.Dispose(isolate);
  persistent.Clear();
}

/////////////////////////////////////////////////////////////////////////////////
/// @brief wraps a TRI_vocbase_col_t
////////////////////////////////////////////////////////////////////////////////

v8::Handle<v8::Object> WrapCollection (TRI_vocbase_col_t const* collection) {
  v8::HandleScope scope;

  TRI_v8_global_t* v8g = static_cast<TRI_v8_global_t*>(v8::Isolate::GetCurrent()->GetData());
  v8::Handle<v8::Object> result = v8g->VocbaseColTempl->NewInstance();

  if (! result.IsEmpty()) {
    v8::Isolate* isolate = v8::Isolate::GetCurrent();
    TRI_vocbase_col_t* c = const_cast<TRI_vocbase_col_t*>(collection);

    result->SetInternalField(SLOT_CLASS_TYPE, v8::Integer::New(WRP_VOCBASE_COL_TYPE));
    result->SetInternalField(SLOT_CLASS, v8::External::New(c));

    map< void*, v8::Persistent<v8::Value> >::iterator i = v8g->JSCollections.find(c);

    if (i == v8g->JSCollections.end()) {
      // increase the reference-counter for the database
      TRI_UseVocBase(collection->_vocbase);

      v8::Persistent<v8::Value> persistent = v8::Persistent<v8::Value>::New(isolate, v8::External::New(c));
      result->SetInternalField(SLOT_COLLECTION, persistent);

      v8g->JSCollections[c] = persistent;
      persistent.MakeWeak(isolate, c, WeakCollectionCallback);
    }
    else {
      result->SetInternalField(SLOT_COLLECTION, i->second);
    }

    result->Set(v8g->_IdKey, V8CollectionId(collection->_cid), v8::ReadOnly);
    result->Set(v8g->_DbNameKey, v8::String::New(collection->_dbName));
    result->Set(v8g->VersionKey, v8::Number::New((double) collection->_internalVersion), v8::DontEnum);
  }

  return scope.Close(result);
}


text:
<?php

if ($tmpl == 'index')
    $view->extend('MauticNotificationBundle:Notification:index.html.php');

if (count($items)):

?>

            <?php
            echo $view->render('MauticCoreBundle:Helper:tableheader.html.php', array(
                'checkall' => 'true'
            ));

            echo $view->render('MauticCoreBundle:Helper:tableheader.html.php', array(
                'sessionVar' => 'notification',
                'orderBy'    => 'e.name',
                'text'       => 'mautic.core.name',
                'class'      => 'col-notification-name',
                'default'    => true
            ));

            echo $view->render('MauticCoreBundle:Helper:tableheader.html.php', array(
                'sessionVar' => 'notification',
                'orderBy'    => 'c.title',
                'text'       => 'mautic.core.category',
                'class'      => 'visible-md visible-lg col-notification-category'
            ));
            ?>

            <?php echo $view['translator']->trans('mautic.notification.thead.stats'); ?>

            <?php
            echo $view->render('MauticCoreBundle:Helper:tableheader.html.php', array(
                'sessionVar' => 'notification',
                'orderBy'    => 'e.id',
                'text'       => 'mautic.core.id',
                'class'      => 'visible-md visible-lg col-notification-id'
            ));
            ?>

        <?php
        /** @var \Mautic\NotificationBundle\Entity\Notification $item */
        foreach ($items as $item):
            $type = $item->getNotificationType();
            ?>

                    <?php
                    $edit          = $view['security']->hasEntityAccess($permissions['notification:notifications:editown'], $permissions['notification:notifications:editother'], $item->getCreatedBy());
                    $customButtons = array(
                        array(
                            'attr' => array(
                                'data-toggle' => 'ajaxmodal',
                                'data-target' => '#MauticSharedModal',
                                'data-header' => $view['translator']->trans('mautic.notification.notification.header.preview'),
                                'data-footer' => 'false',
                                'href' => $view['router']->path('mautic_notification_action', array("objectId" => $item->getId(), "objectAction" => "preview")),
                            ),
                            'btnText'   => $view['translator']->trans('mautic.notification.preview'),
                            'iconClass' => 'fa fa-share'
                        )
                    );
                    echo $view->render('MauticCoreBundle:Helper:list_actions.html.php', array(
                        'item'            => $item,
                        'templateButtons' => array(
                            'delete'     => $view['security']->hasEntityAccess($permissions['notification:notifications:deleteown'], $permissions['notification:notifications:deleteother'], $item->getCreatedBy())
                        ),
                        'routeBase'       => 'notification',
                        'customButtons'   => $customButtons
                    ));
                    ?>

                        <?php if ($type == 'template'): ?>
                        <?php echo $view->render('MauticCoreBundle:Helper:publishstatus_icon.html.php',array('item' => $item, 'model' => 'notification')); ?>
                        <?php else: ?>

                        <?php endif; ?>
                        <a href="<?php echo $view['router']->path('mautic_notification_action', array("objectAction" => "preview", "objectId" => $item->getId())); ?>" data-toggle="ajaxmodal" data-target="#MauticSharedModal" data-footer="false" data-header="<?php echo $view['translator']->trans('mautic.notification.notification.header.preview')?>">
                            <?php echo $item->getName(); ?>
                            <?php if ($type == 'list'): ?>
                            <span data-toggle="tooltip" title="<?php echo $view['translator']->trans('mautic.notification.icon_tooltip.list_notification'); ?>">
                            <?php endif; ?>

                    <?php $category = $item->getCategory(); ?>
                    <?php $catName  = ($category) ? $category->getTitle() : $view['translator']->trans('mautic.core.form.uncategorized'); ?>
                    <?php $color    = ($category) ? '#' . $category->getColor() : 'inherit'; ?>
                    <span class="label label-default pa-4" style="border: 1px solid #d5d5d5; background: <?php echo $color; ?>;">  <?php echo $catName; ?>

                    <?php echo $view['translator']->trans('mautic.notification.stat.sentcount', array('%count%' => $item->getSentCount(true))); ?>

                <?php echo $item->getId(); ?>

        <?php endforeach; ?>

    <?php echo $view->render('MauticCoreBundle:Helper:pagination.html.php', array(
        'totalItems'      => $totalItems,
        'page'            => $page,
        'limit'           => $limit,
        'baseUrl'         => $view['router']->path('mautic_notification_index'),
        'sessionVar'      => 'notification'
    )); ?>

<?php else: ?>
    <?php echo $view->render('MauticCoreBundle:Helper:noresults.html.php'); ?>
<?php endif; ?>


text:
GitHub has a built in issues system. Which we want to use for many different things.
All issues should be marked with a label that corresponds to what they are about.
The different labels is covered in this file.

####Bug
Any bugs/glitches/errors that exists in this library.
A ticket including this should describe what they expected to occur, and what actually occurred.
Often that will be telling what input they gave to a method, what they would expect the output to be, and what the output actually was.
Any stacktraces which occured should also be posted. In general be as descriptive as possible.
If possible it should be told EXACTLY how to reproduce said circumstances.
They should also make sure that the bugs is actually in MujLib and not their own source code.

The assignee is the developer responsible for fixing the bug.

All fixes should be local and hopefully not affect anything else.
All places where the buggy souce code was used internally, should be checked.
In case they were mistakenly relying on the bug.
Tests that would have caught the bug should also be added, so that we won't run into the same issue again.

A bug should be closed when it is fixed, and there is made unit tests, which will catch any reintroductions of the bug.

####Discussion
Any discussions about almost anything.
If you are in doubt about something, and want peoples (more or less subjective) opinion.
You should make an issue with the discussion label.

Discussions should be for subjective matters. Whereas things that can be factually answered should be a question.

Examples include:
API design choices.

The assignee is the one person who should make a conclusion
based on the different opinions in the discussion.

A discussion should be closed when a decisison is taken.

####Duplicate
Any issue being discussions, bug reports, todos, questions or something else.
Which already has an issue regarding the same thing, should be marked with this label.

All duplicates should be closed instantaneously.

####Feature request
A request for a specific feature to be added to the library.
These should not occur often because all users of the library are developers, and should rather make a pull request.
But from time to time a feature request would make sense.

The assignee is the one developer responsible for implementing
the requested feature.

A feature request should be closed when it is either added to the library along with unit tests,
or if it is decided that it shouldn't be added.
Even if there is no plans to implement a feature request, it should often still be open so that
any developer interested in this project, could potentially implement it.

####Invalid
Any issue being discussions, bug reports, todos, questions or something else,
which is using an invalid format, should be marked with this label.
We currently don't have any strict format rules, so this will rarely be used.

All invalid formatted issues should be closed instantaneously.

####Question
Any questions which can be factually answered should have this label.
This is usually for newcomers who are in doubt about something.

If the answer can be subjective a discussion might be more appropriate.

The assginee is the person who should track the issues and also answer any follow up questions.

A question should be closed when there is no possible confusion about the answer.

####Todo
Todos are for tasks which should be done.
This is often tasks which no one is currently capable of doing,
or something that will take quite some time.

Todos should only be made by core project contributors.
Because it is only for tasks which should be done.
In other cases it will often be a feature request rather than a todo.

The assignee is the person who should do this task.

A todo should be closed when there it is not todo anymore, because it has been implemented,
or because it was decided that it isn't necessary.


text:
def main():
    import sys
    from Naked.commandline import Command
    from Naked.toolshed.state import StateObject

    c = Command(sys.argv[0], sys.argv[1:])
    if not c.command_suite_validates():
        from jampack.settings import usage as jampack_usage
        print(jampack_usage)
        sys.exit(1)
    if c.help():      # User requested jampack help information
        from jampack.settings import help as jampack_help
        print(jampack_help)
        sys.exit(0)
    elif c.usage():   # User requested jampack usage information
        from jampack.settings import usage as jampack_usage
        print(jampack_usage)
        sys.exit(0)
    elif c.version(): # User requested jampack version information
        from jampack.settings import app_name, major_version, minor_version, patch_version
        version_display_string = app_name + ' ' + major_version + '.' + minor_version + '.' + patch_version
        print(version_display_string)
        sys.exit(0)
    else:
        # just display usage information with this executable.  Users need to use jam or unjam
        from jampack.settings import usage as jampack_usage
        print(jampack_usage)
        sys.exit(0)

if __name__ == '__main__':
    main()


text:
SYNONYM

#### According to
Index Fungorum

#### Published in
null

#### Original name
Hepataria Raf.

### Remarks
null


text:
class GithubExtractor < Extractor::Base
  # @see Extractor::Base#first_name
  def first_name
    split_name.first
  end

  # @see Extractor::Base#last_name
  def last_name
    split_name.last
  end

  # @see Extractor::Base#email
  def email
    auth["info"]["email"]
  end

  # @see Extractor::Base#username
  def username
    auth["info"]["nickname"]
  end

  # @see Extractor::Base#image_url
  def image_url
    auth["info"]["image"]
  end

  # @see Extractor::Base#uid
  def uid
    auth["uid"]
  end

  # @see Extractor::Base#oauth_token
  def oauth_token
    auth["credentials"]["token"]
  end

  #
  # Return nil for +GithubExtractor+ because it does not return a public key
  #
  def public_key
    nil
  end
end


text:
#pragma once
#include <aws/macie2/Macie2_EXPORTS.h>
#include <aws/macie2/Macie2Request.h>
#include <aws/core/utils/memory/stl/AWSString.h>
#include <aws/macie2/model/MacieStatus.h>
#include <utility>

namespace Aws
{
namespace Macie2
{
namespace Model
{

  /**
   */
  class AWS_MACIE2_API UpdateMemberSessionRequest : public Macie2Request
  {
  public:
    UpdateMemberSessionRequest();

    // Service request name is the Operation name which will send this request out,
    // each operation should has unique request name, so that we can get operation's name from this request.
    // Note: this is not true for response, multiple operations may have the same response name,
    // so we can not get operation's name from response.
    inline virtual const char* GetServiceRequestName() const override { return "UpdateMemberSession"; }

    Aws::String SerializePayload() const override;

    /**
     *
The unique identifier for the Amazon Macie resource that the request applies
     * to.

     */
    inline const Aws::String& GetId() const{ return m_id; }

    /**
     *
The unique identifier for the Amazon Macie resource that the request applies
     * to.

     */
    inline bool IdHasBeenSet() const { return m_idHasBeenSet; }

    /**
     *
The unique identifier for the Amazon Macie resource that the request applies
     * to.

     */
    inline void SetId(const Aws::String& value) { m_idHasBeenSet = true; m_id = value; }

    /**
     *
The unique identifier for the Amazon Macie resource that the request applies
     * to.

     */
    inline void SetId(Aws::String&& value) { m_idHasBeenSet = true; m_id = std::move(value); }

    /**
     *
The unique identifier for the Amazon Macie resource that the request applies
     * to.

     */
    inline void SetId(const char* value) { m_idHasBeenSet = true; m_id.assign(value); }

    /**
     *
The unique identifier for the Amazon Macie resource that the request applies
     * to.

     */
    inline UpdateMemberSessionRequest& WithId(const Aws::String& value) { SetId(value); return *this;}

    /**
     *
The unique identifier for the Amazon Macie resource that the request applies
     * to.

     */
    inline UpdateMemberSessionRequest& WithId(Aws::String&& value) { SetId(std::move(value)); return *this;}

    /**
     *
The unique identifier for the Amazon Macie resource that the request applies
     * to.

     */
    inline UpdateMemberSessionRequest& WithId(const char* value) { SetId(value); return *this;}

    /**
     *
Specifies the new status for the account. Valid values are: ENABLED, resume
     * all Amazon Macie activities for the account; and, PAUSED, suspend all Macie
     * activities for the account.

     */
    inline const MacieStatus& GetStatus() const{ return m_status; }

    /**
     *
Specifies the new status for the account. Valid values are: ENABLED, resume
     * all Amazon Macie activities for the account; and, PAUSED, suspend all Macie
     * activities for the account.

     */
    inline bool StatusHasBeenSet() const { return m_statusHasBeenSet; }

    /**
     *
Specifies the new status for the account. Valid values are: ENABLED, resume
     * all Amazon Macie activities for the account; and, PAUSED, suspend all Macie
     * activities for the account.

     */
    inline void SetStatus(const MacieStatus& value) { m_statusHasBeenSet = true; m_status = value; }

    /**
     *
Specifies the new status for the account. Valid values are: ENABLED, resume
     * all Amazon Macie activities for the account; and, PAUSED, suspend all Macie
     * activities for the account.

     */
    inline void SetStatus(MacieStatus&& value) { m_statusHasBeenSet = true; m_status = std::move(value); }

    /**
     *
Specifies the new status for the account. Valid values are: ENABLED, resume
     * all Amazon Macie activities for the account; and, PAUSED, suspend all Macie
     * activities for the account.

     */
    inline UpdateMemberSessionRequest& WithStatus(const MacieStatus& value) { SetStatus(value); return *this;}

    /**
     *
Specifies the new status for the account. Valid values are: ENABLED, resume
     * all Amazon Macie activities for the account; and, PAUSED, suspend all Macie
     * activities for the account.

     */
    inline UpdateMemberSessionRequest& WithStatus(MacieStatus&& value) { SetStatus(std::move(value)); return *this;}

  private:

    Aws::String m_id;
    bool m_idHasBeenSet = false;

    MacieStatus m_status;
    bool m_statusHasBeenSet = false;
  };

} // namespace Model
} // namespace Macie2
} // namespace Aws


text:
package org.kuali.kfs.coa.document.validation.impl;

import org.apache.commons.lang.StringUtils;
import org.kuali.kfs.coa.businessobject.Account;
import org.kuali.kfs.coa.businessobject.IndirectCostRecoveryExclusionAccount;
import org.kuali.rice.kns.document.MaintenanceDocument;
import org.kuali.rice.krad.util.ObjectUtils;

/**
 * PreRules checks for the {@link IndirectCostRecoveryExclusionAccount} that needs to occur while still in the Struts processing.
 * This checks for continuation accounts
 */
public class IndirectCostRecoveryExclusionAccountPreRules extends MaintenancePreRulesBase {

    protected IndirectCostRecoveryExclusionAccount indirectCostRecoveryExclusionAccount;

    public IndirectCostRecoveryExclusionAccountPreRules() {

    }

    /**
     * This sets up the convenience objects and calls
     * {@link IndirectCostRecoveryExclusionAccountPreRules#checkForContinuationAccounts()}
     *
     * @see org.kuali.kfs.coa.document.validation.impl.MaintenancePreRulesBase#doCustomPreRules(org.kuali.rice.kns.document.MaintenanceDocument)
     */
    protected boolean doCustomPreRules(MaintenanceDocument document) {
        setupConvenienceObjects(document);
        checkForContinuationAccounts(); // run this first to avoid side effects

        LOG.debug("done with continuation account, proceeeding with remaining pre rules");

        return true;
    }

    /**
     * This method checks for continuation accounts and presents the user with a question regarding their use on this account.
     */
    protected void checkForContinuationAccounts() {
        LOG.debug("entering checkForContinuationAccounts()");

        if (StringUtils.isNotBlank(indirectCostRecoveryExclusionAccount.getAccountNumber())) {
            Account account = checkForContinuationAccount("Account Number", indirectCostRecoveryExclusionAccount.getChartOfAccountsCode(), indirectCostRecoveryExclusionAccount.getAccountNumber(), "");
            if (ObjectUtils.isNotNull(account)) { // override old user inputs
                indirectCostRecoveryExclusionAccount.setAccountNumber(account.getAccountNumber());
                indirectCostRecoveryExclusionAccount.setChartOfAccountsCode(account.getChartOfAccountsCode());
            }
        }
    }

    /**
     * This method sets the convenience objects like newAccount and oldAccount, so you have short and easy handles to the new and
     * old objects contained in the maintenance document. It also calls the BusinessObjectBase.refresh(), which will attempt to load
     * all sub-objects from the DB by their primary keys, if available.
     *
     * @param document - the maintenanceDocument being evaluated
     */
    protected void setupConvenienceObjects(MaintenanceDocument document) {

        // setup newAccount convenience objects, make sure all possible sub-objects are populated
        indirectCostRecoveryExclusionAccount = (IndirectCostRecoveryExclusionAccount) document.getNewMaintainableObject().getBusinessObject();
    }
}


text:
import ChromaPy32 as Chroma  # Import the Chroma Module
from time import sleep

Keypad = Chroma.Keypad()  # Initialize a new Keypad Instance

RED = (255, 0, 0)  # Initialize a new color by RGB (RED,GREEN,BLUE)

Keypad.setbyRow(2, RED)  # sets the whole third row of the Keyboad-Grid to red

Keypad.applyGrid()  # applies the Keypad-Grid to the connected Keypad
sleep(5)


text:
{{dialogOptions.headerText | translate}}

{{dialogOptions.bodyText | translate}}

 0">

            {{ item | translate }}

    <button class="btn btn-default" data-ng-click="dialogOptions.ok();">{{dialogOptions.closeButtonText | translate}}</button>


text:
package edu.ntnu.idi.goldfish;

import ch.qos.logback.classic.Level;
import ch.qos.logback.classic.Logger;
import com.google.common.collect.BiMap;
import com.google.common.collect.HashBiMap;
import edu.ntnu.idi.goldfish.configurations.Config;
import edu.ntnu.idi.goldfish.configurations.Lynx;
import edu.ntnu.idi.goldfish.mahout.DBModel;
import edu.ntnu.idi.goldfish.preprocessors.Preprocessor;
import edu.ntnu.idi.goldfish.preprocessors.PreprocessorStat;
import org.apache.commons.lang3.exception.ExceptionUtils;
import org.apache.mahout.cf.taste.common.NoSuchUserException;
import org.apache.mahout.cf.taste.model.DataModel;
import org.apache.mahout.cf.taste.recommender.RecommendedItem;
import org.apache.mahout.cf.taste.recommender.Recommender;
import org.codehaus.jettison.json.JSONArray;
import org.codehaus.jettison.json.JSONException;
import org.codehaus.jettison.json.JSONObject;
import org.restlet.*;
import org.restlet.data.MediaType;
import org.restlet.data.Parameter;
import org.restlet.data.Protocol;
import org.restlet.data.Status;
import org.restlet.routing.Router;
import org.restlet.routing.Template;
import org.slf4j.LoggerFactory;

import java.util.Date;
import java.util.List;

public class RecommenderAPI extends Application {

    public int counter = 0;
    public Date lastUpdate;
    public Recommender recommender;
    public BiMap<String, Long> userMap;
    public BiMap<String, Long> itemMap;

    private String hostname;
    private int port;
    private String username;
    private String password;
    private String database;
    private String collection;
    static Logger log;

    public static void main(String[] args) throws Exception {
        log = (Logger) LoggerFactory.getLogger(Logger.ROOT_LOGGER_NAME);
        log.setLevel(Level.INFO);

        Component component = new Component();
        component.getDefaultHost().attach("", new RecommenderAPI());
        Server server = component.getServers().add(Protocol.HTTP, 8182);
        server.getContext().getParameters().add("useForwardedForHeader", "true");
        component.start();
    }

    public static String getJSONError(Exception e) {
        try {
            JSONObject out = new JSONObject();
            out.put("stacktrace", ExceptionUtils.getStackTrace(e));
            out.put("error", e.getClass().getSimpleName());
            out.put("message", e.getMessage());
            return out.toString();

        } catch (JSONException e1) {
            e1.printStackTrace();
            return getJSONError(e1);
        }
    }

    public Restlet createInboundRoot() {
        Router router = new Router(getContext());
        router.setDefaultMatchingMode(Template.MODE_STARTS_WITH);

        // default route
        router.attachDefault(new Restlet() {
            public void handle(Request request, Response response) {
                System.err.println("Invalid request: "+request.toString());
                response.setStatus(Status.CLIENT_ERROR_BAD_REQUEST);
                response.setEntity(getJSONError(new Exception("allowed paths are /recommend/{userid} and /notify")), MediaType.APPLICATION_JSON);
            }
        });

        router.attach("/favico", new Restlet() {
            @Override
            public void handle(Request request, Response response) {
                response.setEntity("null", MediaType.TEXT_PLAIN);
            }
        });

        // request for recommendations
        router.attach("/recommend/{userid}", new Restlet() {
            public void handle(Request request, Response response) {

                JSONObject output = new JSONObject();

                try {
                    // parse userid and make sure it exists
                    String rawUserid = (String) request.getAttributes().get("userid");
                    if (!userMap.containsKey(rawUserid)) {
                        throw new NoSuchUserException(String.format("User %s does not exist", rawUserid));
                    }
                    long userID = userMap.get(rawUserid);

                    // parse optional ?limit={limit}
                    Parameter limitParam = request.getResourceRef().getQueryAsForm().getFirst("limit");
                    int limit = limitParam != null && !limitParam.getValue().isEmpty() ? Integer.parseInt(limitParam.getValue()) : 10;

                    // get list of recommendations
                    List<RecommendedItem> recommend = recommender.recommend(userID, limit);

                    JSONArray items = new JSONArray();
                    // iterate over recomendation items
                    for (RecommendedItem item : recommend) {
                        // convert Long itemID to respective String ID
                        String itemID = String.valueOf(itemMap.inverse().get(item.getItemID()));
                        // serialize to JSON

                        JSONObject itemObject = new JSONObject();
                        itemObject.put("itemid", itemID);
                        itemObject.put("rating", String.format("%.2f", item.getValue()));
                        items.put(itemObject);
                    }

                    output.put("data", items);

                    response.setEntity(output.toString(), MediaType.APPLICATION_JSON);
                }
                catch (Exception e) {

                    // would have constructed a proper JSON object here, but that might throw an exception
                    // so we do it manually

                    String out = getJSONError(e);
                    System.out.println(out);

                    response.setStatus(Status.SERVER_ERROR_INTERNAL);
                    response.setEntity(out, MediaType.APPLICATION_JSON);
                }
            }
        });

        // update notification
        router.attach("/notify", new Restlet() {
            public void handle(Request request, Response response) {
                try {

                    // get number of minutes since last rebuild
                    long minuteDelta = (new Date().getTime() - lastUpdate.getTime()) / (1000 * 60);

                    boolean doRebuild = counter > 10 && minuteDelta > 10;

                    JSONObject output = new JSONObject();
                    output.put("rebuild", Boolean.toString(doRebuild));
                    output.put("lastrebuild", lastUpdate.getTime()/1000); // unix timestamp (convert ms to sec)
                    output.put("updates", counter);

                    response.setEntity(output.toString(), MediaType.APPLICATION_JSON);

                    if (doRebuild) {
                        rebuild();
                    }

                    // increment notification updates
                    counter ++;
                }
                catch(Exception e) {

                    // would have constructed a proper JSON object here, but that might throw an exception
                    // so we do it manually

                    String out = getJSONError(e);
                    System.out.println(out);

                    response.setStatus(Status.SERVER_ERROR_INTERNAL);
                    response.setEntity(out, MediaType.APPLICATION_JSON);
                }
            }
        });

        return router;
    }

    public RecommenderAPI() throws Exception {

        try {

            // load configuration options from environment
            hostname = System.getenv("SMARTMEDIA_HOSTNAME");
            port = Integer.parseInt(System.getenv("SMARTMEDIA_PORT"));
            username = System.getenv("SMARTMEDIA_USERNAME");
            password = System.getenv("SMARTMEDIA_PASSWORD");
            database = System.getenv("SMARTMEDIA_DATABASE");
            collection = System.getenv("SMARTMEDIA_COLLECTION");

            // build recommendation model before starting
            rebuild();
        }
        // catch any error and print stack trace
        catch(Exception e) {
            e.printStackTrace();
        }
    }

    /**
     * This method will rebuild the recommendation model
     * @throws Exception
     */
    public void rebuild() throws Exception {
        System.out.println("Rebuilding...");

        /**
         * The userIDs and itemIDs are represented as strings in mongo (i.e 5320767388b38d00075f7b91)
         * We create two biMaps where we store the mappings between these strings and our internal Long values
         */

        BiMap<String, Long> newUserMap = HashBiMap.create();
        BiMap<String, Long> newitemMap = HashBiMap.create();

        // start timing of rebuild
        StopWatch.start("totalRebuild");

        // load dataset from database into DataModel
        StopWatch.start("getModel");
        DataModel model = new DBModel(hostname, port, username, password, database, collection, newUserMap, newitemMap);

        log.info(String.format("%s (%d users, %d items)", StopWatch.str("getModel"), model.getNumUsers(), model.getNumItems()));

        // set configuration parameters and preprocessor
        Config config = new Lynx()
            .set("model", model)
            .set("minTimeOnPage", 25000)
            .set("correlationLimit", 0.3)
            .set("rating", 4)
            .set("predictionMethod", PreprocessorStat.PredictionMethod.ClosestNeighbor);

        // preprocess dataModel
        StopWatch.start("preprocess");
        Preprocessor preprocessor = new PreprocessorStat();
        model = preprocessor.preprocess(config);
        log.info(String.format("%s (%d users, %d items)", StopWatch.str("preprocess"), model.getNumUsers(), model.getNumItems()));

        // build Recommendation model
        StopWatch.start("buildRecommender");
        Recommender newRecommender = ((Lynx) config).getBuilder().buildRecommender(model);
        log.info(StopWatch.str("buildRecommender"));

        // swap in new models
        recommender = newRecommender;
        userMap = newUserMap;
        itemMap = newitemMap;

        // reset rebuild cycle
        counter = 0;
        lastUpdate = new Date();

        log.info(StopWatch.str("totalRebuild"));
    }
}


text:
#include <vector>
#include "tensorflow/core/framework/allocator.h"
#include "tensorflow/core/framework/fake_input.h"
#include "tensorflow/core/framework/node_def_builder.h"
#include "tensorflow/core/framework/op_kernel.h"
#include "tensorflow/core/framework/tensor.h"
#include "tensorflow/core/framework/tensor_testutil.h"
#include "tensorflow/core/framework/types.h"
#include "tensorflow/core/kernels/ops_testutil.h"
#include "tensorflow/core/kernels/ops_util.h"
#include "tensorflow/core/lib/core/status_test_util.h"
#include "tensorflow/core/platform/test.h"

namespace tensorflow {
class FusedBatchNormOpTest : public OpsTestBase {};

TEST_F(FusedBatchNormOpTest, Training) {
  TF_EXPECT_OK(NodeDefBuilder("batch_norm_op", "FusedBatchNorm")
                   .Input(FakeInput(DT_FLOAT))
                   .Input(FakeInput(DT_FLOAT))
                   .Input(FakeInput(DT_FLOAT))
                   .Input(FakeInput(DT_FLOAT))
                   .Input(FakeInput(DT_FLOAT))
                   .Attr("epsilon", 0.001)
                   .Attr("is_training", true)
                   .Finalize(node_def()));
  TF_EXPECT_OK(InitOp());
  AddInputFromArray<float>(TensorShape({1, 1, 6, 2}),
                           {5, 5, 7, 7, 9, 9, 11, 11, 13, 13, 15, 15});
  AddInputFromArray<float>(TensorShape({2}), {4.0, 4.0});
  AddInputFromArray<float>(TensorShape({2}), {2.0, 2.0});
  AddInputFromArray<float>(TensorShape({0}), {});
  AddInputFromArray<float>(TensorShape({0}), {});

  TF_ASSERT_OK(RunOpKernel());

  Tensor expected(allocator(), DT_FLOAT, TensorShape({1, 1, 6, 2}));
  test::FillValues<float>(&expected, {-3.86, -3.86, -1.51, -1.51, 0.83, 0.83,
                                      3.17, 3.17, 5.51, 5.51, 7.86, 7.86});
  test::ExpectTensorNear<float>(expected, *GetOutput(0), 0.01);

  Tensor expected_mean(allocator(), DT_FLOAT, TensorShape({2}));
  test::FillValues<float>(&expected_mean, {10, 10});
  test::ExpectTensorNear<float>(expected_mean, *GetOutput(1), 0.01);

  Tensor expected_variance(allocator(), DT_FLOAT, TensorShape({2}));
  test::FillValues<float>(&expected_variance, {14.00, 14.00});
  test::ExpectTensorNear<float>(expected_variance, *GetOutput(2), 0.01);
}

TEST_F(FusedBatchNormOpTest, Inference) {
  TF_EXPECT_OK(NodeDefBuilder("batch_norm_op", "FusedBatchNorm")
                   .Input(FakeInput(DT_FLOAT))
                   .Input(FakeInput(DT_FLOAT))
                   .Input(FakeInput(DT_FLOAT))
                   .Input(FakeInput(DT_FLOAT))
                   .Input(FakeInput(DT_FLOAT))
                   .Attr("epsilon", 0.001)
                   .Attr("is_training", false)
                   .Finalize(node_def()));
  TF_EXPECT_OK(InitOp());
  AddInputFromArray<float>(TensorShape({1, 1, 6, 2}),
                           {5, 5, 7, 7, 9, 9, 11, 11, 13, 13, 15, 15});
  AddInputFromArray<float>(TensorShape({2}), {4.0, 4.0});
  AddInputFromArray<float>(TensorShape({2}), {2.0, 2.0});
  AddInputFromArray<float>(TensorShape({2}), {10, 10});
  AddInputFromArray<float>(TensorShape({2}), {11.67f, 11.67f});

  TF_ASSERT_OK(RunOpKernel());

  Tensor expected(allocator(), DT_FLOAT, TensorShape({1, 1, 6, 2}));
  test::FillValues<float>(&expected, {-3.86, -3.86, -1.51, -1.51, 0.83, 0.83,
                                      3.17, 3.17, 5.51, 5.51, 7.86, 7.86});
  test::ExpectTensorNear<float>(expected, *GetOutput(0), 0.01);
}

class FusedBatchNormGradOpTest : public OpsTestBase {};

TEST_F(FusedBatchNormGradOpTest, Simple) {
  TF_EXPECT_OK(NodeDefBuilder("batch_norm_grad_op", "FusedBatchNormGrad")
                   .Input(FakeInput(DT_FLOAT))
                   .Input(FakeInput(DT_FLOAT))
                   .Input(FakeInput(DT_FLOAT))
                   .Input(FakeInput(DT_FLOAT))
                   .Input(FakeInput(DT_FLOAT))
                   .Attr("epsilon", 0.001)
                   .Finalize(node_def()));
  TF_EXPECT_OK(InitOp());
  AddInputFromArray<float>(TensorShape({1, 1, 6, 2}),
                           {2, 2, 9, 9, -4, -4, 5, 5, 8, 8, 7, 7});
  AddInputFromArray<float>(TensorShape({1, 1, 6, 2}),
                           {1, 1, 7, 7, 4, 4, -3, -3, -11, -11, 13, 13});
  AddInputFromArray<float>(TensorShape({2}), {4, 4});
  AddInputFromArray<float>(TensorShape({2}), {1.833f, 1.833f});
  AddInputFromArray<float>(TensorShape({2}), {57.472f, 57.472f});

  TF_ASSERT_OK(RunOpKernel());

  Tensor expected_x(allocator(), DT_FLOAT, TensorShape({1, 1, 6, 2}));
  test::FillValues<float>(&expected_x, {-1.34, -1.34, 2.47, 2.47, -4.44, -4.44,
                                        0.17, 0.17, 1.60, 1.60, 1.53, 1.53});
  test::ExpectTensorNear<float>(expected_x, *GetOutput(0), 0.01);

  Tensor expected_scale(allocator(), DT_FLOAT, TensorShape({2}));
  test::FillValues<float>(&expected_scale, {-1.6488, -1.6488});
  test::ExpectTensorNear<float>(expected_scale, *GetOutput(1), 0.01);

  Tensor expected_offset(allocator(), DT_FLOAT, TensorShape({2}));
  test::FillValues<float>(&expected_offset, {27, 27});
  test::ExpectTensorNear<float>(expected_offset, *GetOutput(2), 0.01);
}
}  // namespace tensorflow


text:
package com.ibatis.sqlmap.engine.mapping.statement;

import com.ibatis.common.util.PaginatedList;
import com.ibatis.sqlmap.client.SqlMapExecutor;

import java.sql.SQLException;
import java.util.*;

/**
 * @deprecated All paginated list features have been deprecated
 */
public class PaginatedDataList implements PaginatedList {

  private SqlMapExecutor sqlMapExecutor;
  private String statementName;
  private Object parameterObject;

  private int pageSize;
  private int index;

  private List prevPageList;
  private List currentPageList;
  private List nextPageList;

  public PaginatedDataList(SqlMapExecutor sqlMapExecutor, String statementName, Object parameterObject, int pageSize)
      throws SQLException {
    this.sqlMapExecutor = sqlMapExecutor;
    this.statementName = statementName;
    this.parameterObject = parameterObject;
    this.pageSize = pageSize;
    this.index = 0;
    pageTo(0);
  }

  private void pageForward() {
    try {
      prevPageList = currentPageList;
      currentPageList = nextPageList;
      nextPageList = getList(index + 1, pageSize);
    } catch (SQLException e) {
      throw new RuntimeException("Unexpected error while repaginating paged list.  Cause: " + e, e);
    }
  }

  private void pageBack() {
    try {
      nextPageList = currentPageList;
      currentPageList = prevPageList;
      if (index > 0) {
        prevPageList = getList(index - 1, pageSize);
      } else {
        prevPageList = new ArrayList();
      }
    } catch (SQLException e) {
      throw new RuntimeException("Unexpected error while repaginating paged list.  Cause: " + e, e);
    }
  }

  private void safePageTo(int idx) {
    try {
      pageTo(idx);
    } catch (SQLException e) {
      throw new RuntimeException("Unexpected error while repaginating paged list.  Cause: " + e, e);
    }
  }

  public void pageTo(int idx) throws SQLException {
    index = idx;

    List list;

    if (idx < 1) {
      list = getList(idx, pageSize * 2);
    } else {
      list = getList(idx - 1, pageSize * 3);
    }

    if (list.size() < 1) {
      prevPageList = new ArrayList(0);
      currentPageList = new ArrayList(0);
      nextPageList = new ArrayList(0);
    } else {
      if (idx < 1) {
        prevPageList = new ArrayList(0);
        if (list.size() <= pageSize) {
          currentPageList = list.subList(0, list.size());
          nextPageList = new ArrayList(0);
        } else {
          currentPageList = list.subList(0, pageSize);
          nextPageList = list.subList(pageSize, list.size());
        }
      } else {
        if (list.size() <= pageSize) {
          prevPageList = list.subList(0, list.size());
          currentPageList = new ArrayList(0);
          nextPageList = new ArrayList(0);
        } else if (list.size() <= pageSize * 2) {
          prevPageList = list.subList(0, pageSize);
          currentPageList = list.subList(pageSize, list.size());
          nextPageList = new ArrayList(0);
        } else {
          prevPageList = list.subList(0, pageSize);
          currentPageList = list.subList(pageSize, pageSize * 2);
          nextPageList = list.subList(pageSize * 2, list.size());
        }
      }
    }

  }

  private List getList(int idx, int localPageSize) throws SQLException {
    return sqlMapExecutor.queryForList(statementName, parameterObject, (idx) * pageSize, localPageSize);
  }

  public boolean nextPage() {
    if (isNextPageAvailable()) {
      index++;
      pageForward();
      return true;
    } else {
      return false;
    }
  }

  public boolean previousPage() {
    if (isPreviousPageAvailable()) {
      index--;
      pageBack();
      return true;
    } else {
      return false;
    }
  }

  public void gotoPage(int pageNumber) {
    safePageTo(pageNumber);
  }

  public int getPageSize() {
    return pageSize;
  }

  public boolean isFirstPage() {
    return index == 0;
  }

  public boolean isMiddlePage() {
    return !(isFirstPage() || isLastPage());
  }

  public boolean isLastPage() {
    return nextPageList.size() < 1;
  }

  public boolean isNextPageAvailable() {
    return nextPageList.size() > 0;
  }

  public boolean isPreviousPageAvailable() {
    return prevPageList.size() > 0;
  }

  public int size() {
    return currentPageList.size();
  }

  public boolean isEmpty() {
    return currentPageList.isEmpty();
  }

  public boolean contains(Object o) {
    return currentPageList.contains(o);
  }

  public Iterator iterator() {
    return currentPageList.iterator();
  }

  public Object[] toArray() {
    return currentPageList.toArray();
  }

  public Object[] toArray(Object a[]) {
    return currentPageList.toArray(a);
  }

  public boolean containsAll(Collection c) {
    return currentPageList.containsAll(c);
  }

  public Object get(int index) {
    return currentPageList.get(index);
  }

  public int indexOf(Object o) {
    return currentPageList.indexOf(o);
  }

  public int lastIndexOf(Object o) {
    return currentPageList.lastIndexOf(o);
  }

  public ListIterator listIterator() {
    return currentPageList.listIterator();
  }

  public ListIterator listIterator(int index) {
    return currentPageList.listIterator(index);
  }

  public List subList(int fromIndex, int toIndex) {
    return currentPageList.subList(fromIndex, toIndex);
  }

  public boolean add(Object o) {
    return currentPageList.add(o);
  }

  public boolean remove(Object o) {
    return currentPageList.remove(o);
  }

  public boolean addAll(Collection c) {
    return currentPageList.addAll(c);
  }

  public boolean addAll(int index, Collection c) {
    return currentPageList.addAll(index, c);
  }

  public boolean removeAll(Collection c) {
    return currentPageList.removeAll(c);
  }

  public boolean retainAll(Collection c) {
    return currentPageList.retainAll(c);
  }

  public void clear() {
    currentPageList.clear();
  }

  public Object set(int index, Object element) {
    return currentPageList.set(index, element);
  }

  public void add(int index, Object element) {
    currentPageList.add(index, element);
  }

  public Object remove(int index) {
    return currentPageList.remove(index);
  }

  public int getPageIndex() {
    return index;
  }

}


text:
<?php

/**
 * @param array<string,string> $a
 * @param array<string,stdClass> $b
 * @return array<string,int>
 */
function array_map_multiple_test(array $a, array $b) {
    // Should warn about wrong params and return type. TODO: Could optionally use less severe warning here if static vs non-static is guaranteed not to have performance impact.
    return array_map(function(stdClass $x, string $y) : array {
        return [$x, $y];
    }, $a, $b);
}
array_map_multiple_test(['x' => 'y'], ['x' => new stdClass()]);


text:
#include "packet_loss_test.h"
#include <cassert>

VP8PacketLossTest::VP8PacketLossTest()
:
PacketLossTest("VP8PacketLossTest", "Encode, remove lost packets, decode")
{
}

VP8PacketLossTest::VP8PacketLossTest(std::string name, std::string description)
:
PacketLossTest(name, description)
{
}

VP8PacketLossTest::VP8PacketLossTest(double lossRate,
                                     bool useNack,
                                     int rttFrames)
:
PacketLossTest("VP8PacketLossTest", "Encode, remove lost packets, decode",
               lossRate, useNack, rttFrames)
{
}

int VP8PacketLossTest::ByteLoss(int size, unsigned char* /* pkg */, int bytesToLose)
{
    int retLength = size - bytesToLose;
    if (retLength < 4)
    {
        retLength = 4;
    }
    return retLength;
}

WebRtc_Word32
VP8PacketLossTest::ReceivedDecodedReferenceFrame(const WebRtc_UWord64 pictureId)
{
    _pictureIdRPSI = pictureId;
    _hasReceivedRPSI = true;
    return 0;
}

webrtc::CodecSpecificInfo*
VP8PacketLossTest::CreateEncoderSpecificInfo() const
{
    webrtc::CodecSpecificInfo* vp8CodecSpecificInfo =
      new webrtc::CodecSpecificInfo();
    vp8CodecSpecificInfo->codecType = webrtc::kVideoCodecVP8;
    vp8CodecSpecificInfo->codecSpecific.VP8.hasReceivedRPSI = _hasReceivedRPSI;
    vp8CodecSpecificInfo->codecSpecific.VP8.pictureIdRPSI = _pictureIdRPSI;
    vp8CodecSpecificInfo->codecSpecific.VP8.hasReceivedSLI = _hasReceivedSLI;
    vp8CodecSpecificInfo->codecSpecific.VP8.pictureIdSLI = _pictureIdSLI;

    _hasReceivedSLI = false;
    _hasReceivedRPSI = false;

    return vp8CodecSpecificInfo;
}

bool VP8PacketLossTest::PacketLoss(double lossRate, int numLosses) {
  if (numLosses)
    return true;
  return RandUniform() < lossRate;
}


text:
package com.aerolitec.SMXL.tools.serverConnexion;

import android.os.AsyncTask;
import android.util.Log;
import com.aerolitec.SMXL.tools.UtilityMethodsv2;

import org.apache.http.HttpResponse;
import org.apache.http.client.HttpClient;
import org.apache.http.client.methods.HttpPost;
import org.apache.http.entity.mime.HttpMultipartMode;
import org.apache.http.entity.mime.MultipartEntityBuilder;
import org.apache.http.entity.mime.content.FileBody;
import org.apache.http.impl.client.DefaultHttpClient;

import java.io.File;
import java.io.InputStream;

/**
 * Created by Nelson on 05/08/2015.
 */
public class PostAvatarProfileHttpAsyncTask extends AsyncTask<Integer, Void, String> {

    public static final String SERVER_ADDRESS_IMAGE_TO_USER_PART_1 = "http://api.smxl-app.com/joins/";
    public static final String SERVER_ADDRESS_IMAGE_TO_USER_PART_1_DEV = "http://smxl-api-dev-mhubsvde5h.elasticbeanstalk.com/joins/";

    public static final String SERVER_ADDRESS_IMAGE_TO_USER_PART_2 = "/images/profiles.html";

    private String filePath;
    public PostAvatarProfileHttpAsyncTask(String filePath) {
        this.filePath = filePath;
    }

    @Override
    protected String doInBackground(Integer... params) {
        Integer profileId = params[0];
        return POST(SERVER_ADDRESS_IMAGE_TO_USER_PART_1_DEV + profileId + SERVER_ADDRESS_IMAGE_TO_USER_PART_2);
    }

    @Override
    protected void onPostExecute(String result) {
        super.onPostExecute(result);
        Log.d("resultValue PostAvatar", result);
        switch(result) {
            case "Did not work!":
                break;
            default:
                break;
        }

    }

    protected String POST(String url) {
        InputStream inputStream = null;
        String result = "";
        try {

            HttpClient httpclient = new DefaultHttpClient();
            HttpPost httpPost = new HttpPost(url);

            MultipartEntityBuilder builder = MultipartEntityBuilder.create();
            builder.setMode(HttpMultipartMode.BROWSER_COMPATIBLE);
            FileBody fileBody = new FileBody(new File(filePath));
            builder.addPart("avatar", fileBody);

            httpPost.setEntity(builder.build());

            HttpResponse httpResponse = httpclient.execute(httpPost);
            inputStream = httpResponse.getEntity().getContent();
            if(inputStream != null){
                result = UtilityMethodsv2.convertInputStreamToString(inputStream);
            }
            else{
                result = "Did not work!";
            }

        } catch (Exception e) {
            e.printStackTrace();
            Log.d("InputStream", e.getLocalizedMessage());
        }
        Log.d("Result POSTAvatar", result);
        return result;
    }
}


text:
package eu.eit.fifteenpuzzle.idastar;

public class NoSolutionException extends Exception {

	private static final long serialVersionUID = -3754685796566861612L;

	public NoSolutionException() {
		super("The provided configuration cannot be solved!");
	}

	public NoSolutionException(String message) {
		super(message);
	}

}


text:
using System;
using System.Collections.Generic;
using System.Linq;
using System.Reflection;
using Orleans.Runtime;

namespace Derivco.Orniscient.Proxy
{
    public static class AssemblyExtensions
    {
        /// <summary>
        /// Only load the assemblies that we can load.
        /// </summary>
        /// <param name="assembly"></param>
        /// <returns></returns>
        public static IEnumerable<Type> GetLoadableTypes(this Assembly assembly,Logger logger)
        {
            try
            {
                return assembly.GetTypes();
            }
            catch (ReflectionTypeLoadException e)
            {
                logger.Warn(1,$"Could not load all types for assembly : {assembly.FullName}",e);
                return e.Types.Where(t => t != null);
            }
        }
    }
}


text:
default['developer_mode'] = false  # we want secure passwords by default
########################################################################

# Set to some text value if you want templated config files
# to contain a custom banner at the top of the written file
default['openstack']['block-storage']['custom_template_banner'] = '
# This file autogenerated by Chef
# Do not edit, changes will be overwritten
'

default['openstack']['block-storage']['verbose'] = 'False'
default['openstack']['block-storage']['debug'] = 'False'

# Specify policy.json remote file to import
default['openstack']['block-storage']['policyfile_url'] = nil

# Default lock_path
default['openstack']['block-storage']['lock_path'] = '/var/lock/cinder'
# Default notification_driver and control exchange
default['openstack']['block-storage']['notification_driver'] = 'cinder.openstack.common.notifier.rpc_notifier'
default['openstack']['block-storage']['control_exchange'] = 'cinder'
# Availability zone/region for the OpenStack Block-Storage service
default['openstack']['block-storage']['region'] = node['openstack']['region']
default['openstack']['block-storage']['scheduler_role'] = 'os-block-storage-scheduler'

# Template strings to be used to generate resource names
default['openstack']['block-storage']['volume_name_template'] = 'volume-%s'
default['openstack']['block-storage']['snapshot_name_template'] = 'snapshot-%s'

# The name of the Chef role that knows about the message queue server
# that Cinder uses
default['openstack']['block-storage']['rabbit_server_chef_role'] = 'os-ops-messaging'

# This is the name of the Chef role that will install the Keystone Service API
default['openstack']['block-storage']['keystone_service_chef_role'] = 'keystone'

# Keystone PKI signing directory. Only written to the filter:authtoken section
# of the api-paste.ini when node['openstack']['auth']['strategy'] == 'pki'
default['openstack']['block-storage']['api']['auth']['cache_dir'] = '/var/cache/cinder/api'

default['openstack']['block-storage']['api']['auth']['version'] = node['openstack']['api']['auth']['version']

# Maximum allocatable gigabytes
# Should equal total backend storage, default is 10TB
default['openstack']['block-storage']['max_gigabytes'] = '10000'

# Storage availability zone
# Default is nova
default['openstack']['block-storage']['storage_availability_zone'] = 'nova'

# Quota definitions
default['openstack']['block-storage']['quota_volumes'] = '10'
default['openstack']['block-storage']['quota_gigabytes'] = '1000'
default['openstack']['block-storage']['quota_driver'] = 'cinder.quota.DbQuotaDriver'

# Common rpc definitions
default['openstack']['block-storage']['rpc_thread_pool_size'] = 240
default['openstack']['block-storage']['rpc_conn_pool_size'] = 100
default['openstack']['block-storage']['rpc_response_timeout'] = 60
case node['openstack']['mq']['service_type']
when 'rabbitmq'
  default['openstack']['block_storage']['rpc_backend'] = 'cinder.openstack.common.rpc.impl_kombu'
when 'qpid'
  default['openstack']['block_storage']['rpc_backend'] = 'cinder.openstack.common.rpc.impl_qpid'
end

default['openstack']['block-storage']['service_tenant_name'] = 'service'
default['openstack']['block-storage']['service_user'] = 'cinder'
default['openstack']['block-storage']['service_role'] = 'admin'

# SAN Support
default['openstack']['block-storage']['san']['san_ip'] = '127.0.0.1'
default['openstack']['block-storage']['san']['san_login'] = 'admin'
default['openstack']['block-storage']['san']['san_private_key'] = '/v7000_rsa'
default['openstack']['block-storage']['san']['san_password'] = 'san_password'

# NFS support
default['openstack']['block-storage']['nfs']['nas_ip'] = '127.0.0.1'
default['openstack']['block-storage']['nfs']['nas_login'] = 'admin'
default['openstack']['block-storage']['nfs']['nas_ssh_port'] = '22'

# Netapp support
default['openstack']['block-storage']['netapp']['protocol'] = 'http'
default['openstack']['block-storage']['netapp']['dfm_hostname'] = nil
default['openstack']['block-storage']['netapp']['dfm_login'] = nil
default['openstack']['block-storage']['netapp']['dfm_password'] = nil
default['openstack']['block-storage']['netapp']['dfm_port'] = '8088'
default['openstack']['block-storage']['netapp']['dfm_web_port'] = '8080'
default['openstack']['block-storage']['netapp']['storage_service'] = 'storage_service'

# Netapp direct NFS
default['openstack']['block-storage']['netapp']['netapp_server_port'] = '80'
default['openstack']['block-storage']['netapp']['netapp_server_hostname'] = nil
default['openstack']['block-storage']['netapp']['netapp_server_password'] = nil
default['openstack']['block-storage']['netapp']['netapp_server_login'] = nil
default['openstack']['block-storage']['netapp']['export'] = nil
default['openstack']['block-storage']['nfs']['shares_config'] = '/etc/cinder/shares.conf'
default['openstack']['block-storage']['nfs']['mount_point_base'] = '/mnt/cinder-volumes'
default['openstack']['block-storage']['nfs']['nfs_disk_util'] = 'df'
default['openstack']['block-storage']['nfs']['nfs_sparsed_volumes'] = 'true'

# Storwize/SVC Support
default['openstack']['block-storage']['storwize']['san_ip'] = node['openstack']['block-storage']['san']['san_ip']
default['openstack']['block-storage']['storwize']['san_login'] = node['openstack']['block-storage']['san']['san_login']
default['openstack']['block-storage']['storwize']['san_private_key'] = node['openstack']['block-storage']['san']['san_private_key']
default['openstack']['block-storage']['storwize']['storwize_svc_volpool_name'] = 'volpool'
default['openstack']['block-storage']['storwize']['storwize_svc_vol_rsize'] = 2
default['openstack']['block-storage']['storwize']['storwize_svc_vol_warning'] = 0
default['openstack']['block-storage']['storwize']['storwize_svc_vol_autoexpand'] = true
default['openstack']['block-storage']['storwize']['storwize_svc_vol_grainsize'] = 256
default['openstack']['block-storage']['storwize']['storwize_svc_vol_compression'] = false
default['openstack']['block-storage']['storwize']['storwize_svc_vol_easytier'] = true
default['openstack']['block-storage']['storwize']['storwize_svc_flashcopy_timeout'] = 120
default['openstack']['block-storage']['storwize']['storwize_svc_vol_iogrp'] = 0
default['openstack']['block-storage']['storwize']['storwize_svc_connection_protocol'] = 'iSCSI'
default['openstack']['block-storage']['storwize']['storwize_svc_iscsi_chap_enabled'] = true
default['openstack']['block-storage']['storwize']['storwize_svc_multipath_enabled'] = false
default['openstack']['block-storage']['storwize']['storwize_svc_multihostmap_enabled'] = true

# SolidFire Support
default['openstack']['block-storage']['solidfire']['san_ip'] = node['openstack']['block-storage']['san']['san_ip']
default['openstack']['block-storage']['solidfire']['san_login'] = node['openstack']['block-storage']['san']['san_login']
default['openstack']['block-storage']['solidfire']['san_password'] = node['openstack']['block-storage']['san']['san_password']
default['openstack']['block-storage']['solidfire']['sf_emulate'] = 'False'
default['openstack']['block-storage']['solidfire']['iscsi_ip_prefix'] = nil

# EMC VMAX/VNX tSupport
# The EmcUserName user's password is stored in an encrypted databag and
# accessed with openstack-common cookbook library's "get_password" routeine. You
# are expected to create the user and pass in a wrapper cookbook.
default['openstack']['block-storage']['emc']['iscsi_target_prefix'] = 'iqn.1992-04.com.emc'
default['openstack']['block-storage']['emc']['cinder_emc_config_file'] = '/etc/cinder/cinder_emc_config.xml'
default['openstack']['block-storage']['emc']['StorageType'] = 0
default['openstack']['block-storage']['emc']['EcomServerIP'] = '127.0.0.1'
default['openstack']['block-storage']['emc']['EcomServerPort'] = '5988'
default['openstack']['block-storage']['emc']['EcomUserName'] = 'admin'
default['openstack']['block-storage']['emc']['MaskingView'] = nil

# VMware Support
default['openstack']['block-storage']['vmware']['secret_name'] = 'openstack_vmware_secret_name'
default['openstack']['block-storage']['vmware']['vmware_host_ip'] = ''
default['openstack']['block-storage']['vmware']['vmware_host_username'] = ''
default['openstack']['block-storage']['vmware']['vmware_wsdl_location'] = nil
default['openstack']['block-storage']['vmware']['vmware_api_retry_count'] = 10
default['openstack']['block-storage']['vmware']['vmware_task_poll_interval'] = 5
default['openstack']['block-storage']['vmware']['vmware_volume_folder'] = 'cinder-volumes'
default['openstack']['block-storage']['vmware']['vmware_image_transfer_timeout_secs'] = 7200
default['openstack']['block-storage']['vmware']['vmware_max_objects_retrieval'] = 100

# IBM GPFS Support
default['openstack']['block-storage']['gpfs']['gpfs_mount_point_base'] = node['openstack']['block-storage']['gpfs']['gpfs_mount_point_base']
default['openstack']['block-storage']['gpfs']['gpfs_images_dir'] = node['openstack']['block-storage']['gpfs']['gpfs_images_dir']
default['openstack']['block-storage']['gpfs']['gpfs_images_share_mode'] = 'copy_on_write'
default['openstack']['block-storage']['gpfs']['gpfs_sparse_volumes'] = true
default['openstack']['block-storage']['gpfs']['gpfs_max_clone_depth'] = 8
default['openstack']['block-storage']['gpfs']['gpfs_storage_pool'] = 'system'

# IBMNAS (SONAS, Storwize V7000 Unified) Support
# The attribute "nas_password" is stored in databag and
# accessed with openstack-common cookbook library's "get_password" routeine.
default['openstack']['block-storage']['ibmnas']['nas_ip'] = node['openstack']['block-storage']['nfs']['nas_ip']
default['openstack']['block-storage']['ibmnas']['nas_login'] = node['openstack']['block-storage']['nfs']['nas_login']
default['openstack']['block-storage']['ibmnas']['shares_config'] = '/etc/cinder/nfs_shares.conf'
default['openstack']['block-storage']['ibmnas']['mount_point_base'] = '/mnt/cinder-volumes'
default['openstack']['block-storage']['ibmnas']['nfs_sparsed_volumes'] = 'true'
default['openstack']['block-storage']['ibmnas']['nas_access_ip'] = nil
default['openstack']['block-storage']['ibmnas']['export'] = nil

# logging attribute
default['openstack']['block-storage']['syslog']['use'] = false
default['openstack']['block-storage']['syslog']['facility'] = 'LOG_LOCAL2'
default['openstack']['block-storage']['syslog']['config_facility'] = 'local2'

default['openstack']['block-storage']['api']['ratelimit'] = 'True'
default['openstack']['block-storage']['cron']['minute'] = '00'
default['openstack']['block-storage']['cron']['audit_logfile'] = '/var/log/cinder/audit.log'

default['openstack']['block-storage']['volume']['state_path'] = '/var/lib/cinder'
default['openstack']['block-storage']['volume']['volumes_dir'] = '/var/lib/cinder/volumes'
default['openstack']['block-storage']['volume']['driver'] = 'cinder.volume.drivers.lvm.LVMISCSIDriver'
default['openstack']['block-storage']['volume']['volume_group'] = 'cinder-volumes'
default['openstack']['block-storage']['volume']['volume_group_size'] = 40
default['openstack']['block-storage']['volume']['volume_clear_size'] = 10
default['openstack']['block-storage']['volume']['volume_clear'] = 'zero'
# volume disk can be loopfile or /dev/sdb
default['openstack']['block-storage']['volume']['disk'] = '/dev/sdb'
default['openstack']['block-storage']['volume']['create_volume_group'] = false
default['openstack']['block-storage']['volume']['iscsi_helper'] = 'tgtadm'
default['openstack']['block-storage']['volume']['iscsi_ip_address'] = node['ipaddress']
default['openstack']['block-storage']['volume']['iscsi_port'] = '3260'

# Ceph/RADOS options
default['openstack']['block-storage']['rbd_pool'] = 'rbd'
default['openstack']['block-storage']['rbd_user'] = 'cinder'
default['openstack']['block-storage']['rbd_secret_uuid'] = nil
# make this a valid uuid for when node['openstack']['developer_mode'] = true
default['openstack']['block-storage']['rbd_secret_name'] = '00000000-0000-0000-0000-000000000000'
default['openstack']['block-storage']['rbd_key_name'] = 'openstack_image_cephx_key'

# Misc option support
# Allow additional strings to be added to cinder.conf
# For example: ['# Comment', 'key=value']
default['openstack']['block-storage']['misc_cinder'] = []

case platform_family
when 'fedora', 'rhel' # :pragma-foodcritic: ~FC024 - won't fix this
  # operating system user and group names
  default['openstack']['block-storage']['user'] = 'cinder'
  default['openstack']['block-storage']['group'] = 'cinder'

  default['openstack']['block-storage']['platform'] = {
    'mysql_python_packages' => ['MySQL-python'],
    'db2_python_packages' => ['python-ibm-db', 'python-ibm-db-sa'],
    'postgresql_python_packages' => ['python-psycopg2'],
    'cinder_common_packages' => ['openstack-cinder'],
    'cinder_api_packages' => ['python-cinderclient'],
    'cinder_api_service' => 'openstack-cinder-api',
    'cinder_client_packages' => ['python-cinderclient'],
    'cinder_volume_packages' => [],
    'cinder_volume_service' => 'openstack-cinder-volume',
    'cinder_scheduler_packages' => [],
    'cinder_scheduler_service' => 'openstack-cinder-scheduler',
    'cinder_iscsitarget_packages' => ['scsi-target-utils'],
    'cinder_iscsitarget_service' => 'tgtd',
    'cinder_ceph_packages' => ['python-ceph', 'ceph-common'],
    'cinder_nfs_packages' => ['nfs-utils', 'nfs-utils-lib'],
    'cinder_emc_packages' => ['pywbem'],
    'package_overrides' => ''
  }
when 'suse'
  # operating system user and group names
  default['openstack']['block-storage']['user'] = 'cinder'
  default['openstack']['block-storage']['group'] = 'cinder'
  default['openstack']['block-storage']['platform'] = {
    'mysql_python_packages' => ['python-mysql'],
    'postgresql_python_packages' => ['python-psycopg2'],
    'cinder_common_packages' => ['openstack-cinder'],
    'cinder_api_packages' => ['openstack-cinder-api'],
    'cinder_api_service' => 'openstack-cinder-api',
    'cinder_client_packages' => ['python-cinderclient'],
    'cinder_scheduler_packages' => ['openstack-cinder-scheduler'],
    'cinder_scheduler_service' => 'openstack-cinder-scheduler',
    'cinder_volume_packages' => ['openstack-cinder-volume'],
    'cinder_volume_service' => 'openstack-cinder-volume',
    'cinder_ceph_packages' => ['python-ceph', 'ceph-common'],
    'cinder_iscsitarget_packages' => ['tgt'],
    'cinder_iscsitarget_service' => 'tgtd',
    'cinder_nfs_packages' => ['nfs-utils'],
    'cinder_emc_packages' => ['python-pywbem']
  }
when 'debian'
  # operating system user and group names
  default['openstack']['block-storage']['user'] = 'cinder'
  default['openstack']['block-storage']['group'] = 'cinder'
  default['openstack']['block-storage']['platform'] = {
    'mysql_python_packages' => ['python-mysqldb'],
    'postgresql_python_packages' => ['python-psycopg2'],
    'cinder_common_packages' => ['cinder-common'],
    'cinder_api_packages' => ['cinder-api', 'python-cinderclient'],
    'cinder_api_service' => 'cinder-api',
    'cinder_client_packages' => ['python-cinderclient'],
    'cinder_volume_packages' => ['cinder-volume'],
    'cinder_volume_service' => 'cinder-volume',
    'cinder_scheduler_packages' => ['cinder-scheduler'],
    'cinder_scheduler_service' => 'cinder-scheduler',
    'cinder_ceph_packages' => ['python-ceph', 'ceph-common'],
    'cinder_iscsitarget_packages' => ['tgt'],
    'cinder_iscsitarget_service' => 'tgt',
    'cinder_nfs_packages' => ['nfs-common'],
    'cinder_emc_packages' => ['python-pywbem'],
    'package_overrides' => "-o Dpkg::Options::='--force-confold' -o Dpkg::Options::='--force-confdef'"
  }
end


text:
"use strict"

const benchmark = require("benchmark");
const pckBrowser = require("pck-browser");
const pckNode = require("pck-node");

const DATA = {
  id: "123456789012345678901234",
  name: "Test Name",
  health: 100,
  jumping: true,
  position: { x: 10, y: 20 },
  attributes: { str: 100, agi: 50, int: 10 },
};

const PCK_BROWSER = pckBrowserEncode();
const PCK_NODE = pckNodeEncode();
const JSON_DATA = jsonEncode();

console.log(`PCK Buffer Size: ${PCK_BROWSER.length}`);
console.log(`JSON Buffer Size: ${JSON_DATA.length}`);

function browserWriteData(w, v) {
  pckBrowser.writeBitSet(w, v.jumping);
  pckBrowser.writeFixedUtf8(w, v.id, 24);
  pckBrowser.writeUtf8(w, v.name);
  pckBrowser.writeIVar(w, v.health);
  browserWritePosition(w, v.position);
  browserWriteAttributes(w, v.attributes);
}

function browserWritePosition(w, v) {
  pckBrowser.writeIVar(w, v.x);
  pckBrowser.writeIVar(w, v.y);
}

function browserWriteAttributes(w, v) {
  pckBrowser.writeI8(w, v.str);
  pckBrowser.writeI8(w, v.agi);
  pckBrowser.writeI8(w, v.int);
}

function browserReadData(b) {
  const bitSet1 = pckBrowser.readU8(b);
  const jumping = (bitSet1 & 1) !== 0;

  const id = pckBrowser.readFixedUtf8(b, 24);
  const name = pckBrowser.readUtf8(b);
  const health = pckBrowser.readIVar(b);
  const position = browserReadPosition(b);
  const attributes = browserReadAttributes(b);

  return { id, name, health, jumping, position, attributes };
}

function browserReadPosition(b) {
  return {
    x: pckBrowser.readIVar(b),
    y: pckBrowser.readIVar(b),
  };
}

function browserReadAttributes(b) {
  return {
    str: pckBrowser.readU8(b),
    agi: pckBrowser.readU8(b),
    int: pckBrowser.readU8(b),
  };
}

function nodeWriteData(w, v) {
  pckNode.writeBitSet(w, v.jumping);
  pckNode.writeFixedUtf8(w, v.id, 24);
  pckNode.writeUtf8(w, v.name);
  pckNode.writeIVar(w, v.health);
  nodeWritePosition(w, v.position);
  nodeWriteAttributes(w, v.attributes);
}

function nodeWritePosition(w, v) {
  pckNode.writeIVar(w, v.x);
  pckNode.writeIVar(w, v.y);
}

function nodeWriteAttributes(w, v) {
  pckNode.writeI8(w, v.str);
  pckNode.writeI8(w, v.agi);
  pckNode.writeI8(w, v.int);
}

function nodeReadData(b) {
  const bitSet1 = pckNode.readU8(b);
  const jumping = (bitSet1 & 1) !== 0;

  const id = pckNode.readFixedUtf8(b, 24);
  const name = pckNode.readUtf8(b);
  const health = pckNode.readIVar(b);
  const position = nodeReadPosition(b);
  const attributes = nodeReadAttributes(b);

  return { id, name, health, jumping, position, attributes };
}

function nodeReadPosition(b) {
  return {
    x: pckNode.readIVar(b),
    y: pckNode.readIVar(b),
  };
}

function nodeReadAttributes(b) {
  return {
    str: pckNode.readU8(b),
    agi: pckNode.readU8(b),
    int: pckNode.readU8(b),
  };
}

function pckBrowserEncode() {
  const w = new pckBrowser.Writer();
  browserWriteData(w, DATA);
  const a = new Uint8Array(w.size);
  pckBrowser.serialize(w, a);
  return a;
}

function pckBrowserDecode() {
  return browserReadData({ u: PCK_BROWSER, o: 0 });
}

function pckNodeEncode() {
  const w = new pckNode.Writer();
  nodeWriteData(w, DATA);
  const a = Buffer.allocUnsafe(w.size);
  pckNode.serialize(w, a);
  return a;
}

function pckNodeDecode() {
  return nodeReadData({ u: PCK_NODE, o: 0 });
}

function jsonEncode() {
  return Buffer.from(JSON.stringify(DATA));
}

function jsonDecode() {
  return JSON.parse(JSON_DATA.toString());
}

new benchmark.Suite()
  .add("pck:browser:encode", () => { pckBrowserEncode(); })
  .add("pck:browser:decode", () => { pckBrowserDecode(); })
  .add("pck:node:encode", () => { pckNodeEncode(); })
  .add("pck:node:decode", () => { pckNodeDecode(); })
  .add("json:encode", () => { jsonEncode(); })
  .add("json:decode", () => { jsonDecode(); })
  .on("cycle", (e) => { console.log(String(e.target)); })
  .run();


text:
<?xml version="1.0" encoding="UTF-8"?>
<extension id="uniqueuploadfield" status="released" xmlns="http://symphony-cms.com/schemas/extension/1.0">
	<name>Unique Upload Field</name>
	<description>Create unique filenames automatically.</description>
	<repo type="github">https://github.com/michael-e/uniqueuploadfield</repo>
	<url type="discuss">http://symphony-cms.com/discuss/thread/684/</url>
	<types>
		<type>Field Types</type>
	</types>
	<authors>
		<author>
			<name github="michael-e" symphony="michael-e">Michael Eichelsdoerfer</name>
			<website>http://www.michael-eichelsdoerfer.de</website>
		</author>
	</authors>
	<releases>
		<release version="1.7" date="2012-05-14" min="2.3.x">
			<![CDATA[- Symphony 2.3.x compatibilty]]>
		</release>
		<release version="1.6" date="2012-05-14" min="2.0.6" max="2.2.x">
			<![CDATA[- Added 'clean filename' functionality; final release for Symphony 2.2.x]]>
		</release>
		<release version="1.5" date="2011-12-17" min="2.0.6" max="2.2.x">
			<![CDATA[- Added extension.meta.xml file]]>
		</release>
		<release version="1.4.2" date="2011-08-19" min="2.0.6" max="2.2.x">
			<![CDATA[- Explicitly set CHARSET and COLLATION when creating the table.]]>
		</release>
		<release version="1.4.1" date="2011-06-02" min="2.0.6">
			<![CDATA[- Fix for REGEXP so it does not break paths stored in `$filename`.]]>
		</release>
		<release version="1.4" date="2011-06-01" min="2.0.6">
			<![CDATA[- Replaced date() by uniqid(), making filenames even more unique.]]>
		</release>
		<release version="1.3" date="2011-02-10" min="2.0.6">
			<![CDATA[- Symphony 2.2 compatibility]]>
		</release>
		<release version="1.2" date="2010-10-12" min="2.0.6">
			<![CDATA[- MySQL5.5 compatibility]]>
		</release>
		<release version="1.1" date="2010-08-11" min="2.0.6">
			<![CDATA[- Added updater function to modify entry tables (as required by Symphony > 2.0.8RC3)]]>
		</release>
		<release version="1.0" date="2009-05-06" min="2.0.6">
			<![CDATA[- Added git control]]>
		</release>
	</releases>
</extension>


text:
<html>
  <head>
    <link rel="stylesheet" type="text/css" href="../vendor/jasmine/lib/jasmine-2.0.0/jasmine.css"></link>
    <script type="text/javascript" src="../privly-applications/vendor/jquery.min.js"></script>
  </head>
  <body>
    <!-- Jasmine Library -->
    <script type="text/javascript" src="../vendor/jasmine/lib/jasmine-2.0.0/jasmine.js"></script>
    <script type="text/javascript" src="../vendor/jasmine/lib/jasmine-2.0.0/jasmine-html.js"></script>
    <script type="text/javascript" src="../vendor/jasmine/lib/jasmine-2.0.0/boot.js"></script>
    <script type="text/javascript" src="../vendor/jasmine/reporters/terminal_reporter.js"></script>
    <!-- Tests scripts -->
    <script type="text/javascript" src="./globals.js"></script>
    <script type="text/javascript" src="./add_reporters.js"></script>
    <script type="text/javascript" src="./first_run.js"></script>
    <script type="text/javascript" src="./privly_ui.js"></script>
    <script type="text/javascript" src="./posting_process.js"></script>
  </body>
</html>


text:
package xyz.brassgoggledcoders.boilerplate.manual.gui;

import java.io.IOException;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;

import org.lwjgl.input.Keyboard;
import org.lwjgl.input.Mouse;
import org.lwjgl.opengl.GL11;

import net.minecraft.client.Minecraft;
import net.minecraft.client.gui.FontRenderer;
import net.minecraft.client.gui.GuiButton;
import net.minecraft.client.gui.GuiScreen;
import net.minecraft.client.gui.GuiTextField;
import net.minecraft.client.gui.ScaledResolution;
import net.minecraft.client.renderer.GlStateManager;
import net.minecraft.item.ItemStack;
import net.minecraft.util.text.TextFormatting;
import xyz.brassgoggledcoders.boilerplate.manual.IManualPage;
import xyz.brassgoggledcoders.boilerplate.manual.ManualInstance;
import xyz.brassgoggledcoders.boilerplate.manual.ManualInstance.ManualEntry;
import xyz.brassgoggledcoders.boilerplate.manual.ManualUtils;

public class GuiManual extends GuiScreen {
	int xSize = 186;
	int ySize = 198;
	int guiLeft;
	int guiTop;
	int manualTick = 0;
	List<GuiButton> pageButtons = new ArrayList();

	public static String selectedCategory;
	public static String selectedEntry;
	public static ArrayList<String> previousSelectedEntry = new ArrayList();
	public static int page;
	public static GuiManual activeManual;

	ManualInstance manual;
	String texture;
	String[] headers = new String[0];
	boolean buttonHeld = false;
	int[] lastClick;
	int[] lastDrag;
	GuiTextField searchField;
	int hasSuggestions = -1;
	String[] suggestionHeaders = new String[0];
	int prevGuiScale = -1;

	public GuiManual(ManualInstance manual, String texture) {
		super();
		this.manual = manual;
		this.texture = texture;

		prevGuiScale = Minecraft.getMinecraft().gameSettings.guiScale;
		if(prevGuiScale != 0 && prevGuiScale != 2 && manual.allowGuiRescale())
			Minecraft.getMinecraft().gameSettings.guiScale = 2;
		activeManual = this;
	}

	@Override
	public boolean doesGuiPauseGame() {
		return false;
	}

	@Override
	public void initGui() {
		if(Minecraft.getMinecraft().gameSettings.guiScale == 1) {
			Minecraft.getMinecraft().gameSettings.guiScale = 2;
			ScaledResolution res = new ScaledResolution(this.mc);
			this.width = res.getScaledWidth();
			this.height = res.getScaledHeight();
			Minecraft.getMinecraft().gameSettings.guiScale = 1;
		}
		this.manual.openManual();

		guiLeft = (this.width - this.xSize) / 2;
		guiTop = (this.height - this.ySize) / 2;
		boolean textField = false;

		this.buttonList.clear();
		this.pageButtons.clear();
		headers = new String[0];
		suggestionHeaders = new String[0];
		hasSuggestions = -1;
		if(manual.getEntry(selectedEntry) != null) {
			ManualEntry entry = manual.getEntry(selectedEntry);
			IManualPage mPage = (page < 0 || page >= entry.getPages().length) ? null : entry.getPages()[page];
			if(mPage != null)
				mPage.initPage(this, guiLeft + 32, guiTop + 28, pageButtons);
			buttonList.addAll(pageButtons);
		}
		else if(manual.getSortedCategoryList() == null || manual.getSortedCategoryList().length <= 1) {
			ArrayList<String> lHeaders = new ArrayList<String>();
			for(ManualEntry e : manual.manualContents.values())
				if(manual.showEntryInList(e))
					lHeaders.add(e.getName());
			headers = lHeaders.toArray(new String[lHeaders.size()]);
			this.buttonList.add(new GuiClickableList(this, 0, guiLeft + 40, guiTop + 20, 100, 168, 1f, 1, headers));
			textField = true;
		}
		else if(manual.manualContents.containsKey(selectedCategory)) {
			ArrayList<String> lHeaders = new ArrayList<String>();
			for(ManualEntry e : manual.manualContents.get(selectedCategory))
				if(manual.showEntryInList(e))
					lHeaders.add(e.getName());
			headers = lHeaders.toArray(new String[lHeaders.size()]);
			this.buttonList.add(new GuiClickableList(this, 0, guiLeft + 40, guiTop + 20, 100, 168, 1f, 1, headers));
			textField = true;
		}
		else {
			ArrayList<String> lHeaders = new ArrayList<String>();
			for(String cat : manual.getSortedCategoryList())
				if(manual.showCategoryInList(cat))
					lHeaders.add(cat);
			headers = lHeaders.toArray(new String[lHeaders.size()]);
			this.buttonList.add(new GuiClickableList(this, 0, guiLeft + 40, guiTop + 20, 100, 168, 1f, 0, headers));
			textField = true;
		}
		if(manual.manualContents.containsKey(selectedCategory) || manual.getEntry(selectedEntry) != null)
			this.buttonList.add(new GuiButtonManualNavigation(this, 1, guiLeft + 24, guiTop + 10, 10, 10, 0));

		if(textField) {
			Keyboard.enableRepeatEvents(true);
			searchField = new GuiTextField(99, this.fontRendererObj, guiLeft + 166, guiTop + 78, 120, 12);
			searchField.setTextColor(-1);
			searchField.setDisabledTextColour(-1);
			searchField.setEnableBackgroundDrawing(false);
			searchField.setMaxStringLength(17);
			searchField.setFocused(true);
			searchField.setCanLoseFocus(false);
		}
		else if(searchField != null)
			searchField = null;
	}

	@Override
	public void drawScreen(int mx, int my, float f) {
		manualTick++;
		GL11.glColor4f(1.0F, 1.0F, 1.0F, 1.0F);
		boolean uni = manual.fontRenderer.getUnicodeFlag();
		manual.fontRenderer.setUnicodeFlag(true);
		manual.entryRenderPre();

		ManualUtils.bindTexture(texture);
		this.drawTexturedModalRect(guiLeft, guiTop, 0, 0, xSize, ySize);
		if(this.searchField != null) {
			int l = searchField.getText() != null ? searchField.getText().length() * 6 : 0;
			if(l > 20)
				this.drawTexturedModalRect(guiLeft + 166, guiTop + 74, 136 + (120 - l), 238, l, 18);
			if(this.hasSuggestions != -1 && this.hasSuggestions < this.buttonList.size()) {
				this.drawTexturedModalRect(guiLeft + 174, guiTop + 100, 214, 212, 16, 26);
				int h = ((GuiClickableList) this.buttonList.get(hasSuggestions)).getFontHeight()
						* Math.min(((GuiClickableList) this.buttonList.get(hasSuggestions)).perPage,
								((GuiClickableList) this.buttonList.get(hasSuggestions)).entries.length);
				int w = 76;
				this.drawTexturedModalRect(guiLeft + 174, guiTop + 116, 230, 212, 16, 16);// Top Left
				this.drawTexturedModalRect(guiLeft + 174, guiTop + 132 + h, 230, 228, 16, 10);// Bottom Left
				this.drawTexturedModalRect(guiLeft + 190 + w, guiTop + 116, 246, 212, 10, 16);// Top Right
				this.drawTexturedModalRect(guiLeft + 190 + w, guiTop + 132 + h, 246, 228, 10, 10);// Bottom Right
				for(int hh = 0; hh < h; hh++) {
					this.drawTexturedModalRect(guiLeft + 174, guiTop + 132 + hh, 230, 228, 16, 1);
					for(int ww = 0; ww < w; ww++)
						this.drawTexturedModalRect(guiLeft + 190 + ww, guiTop + 132 + hh, 246, 228, 1, 1);
					this.drawTexturedModalRect(guiLeft + 190 + w, guiTop + 132 + hh, 246, 228, 10, 1);
				}
				for(int ww = 0; ww < w; ww++) {
					this.drawTexturedModalRect(guiLeft + 190 + ww, guiTop + 116, 246, 212, 1, 16);
					this.drawTexturedModalRect(guiLeft + 190 + ww, guiTop + 132 + h, 246, 228, 1, 10);

				}
			}
		}

		if(manual.getEntry(selectedEntry) != null) {
			ManualEntry entry = manual.getEntry(selectedEntry);
			mx -= guiLeft;
			my -= guiTop;
			boolean b0 = mx > 32 && mx < 32 + 17 && my > 179 && my < 179 + 10;
			boolean b1 = mx > 135 && mx < 135 + 17 && my > 179 && my < 179 + 10;

			GL11.glEnable(GL11.GL_BLEND);
			if(page > 0)
				this.drawTexturedModalRect(guiLeft + 32, guiTop + 179, 0, 216 + (b0 ? 20 : 0), 16, 10);
			if(page < entry.getPages().length - 1)
				this.drawTexturedModalRect(guiLeft + 136, guiTop + 179, 0, 226 + (b1 ? 20 : 0), 16, 10);

			manual.titleRenderPre();
			// Title
			this.drawCenteredStringScaled(manual.fontRenderer,
					TextFormatting.BOLD + manual.formatEntryName(entry.getName()), guiLeft + xSize / 2, guiTop + 14,
					manual.getTitleColour(), 1, true);
			this.drawCenteredStringScaled(manual.fontRenderer, manual.formatEntrySubtext(entry.getName()),
					guiLeft + xSize / 2, guiTop + 22, manual.getSubTitleColour(), 1, true);
			// Page Number
			this.drawCenteredStringScaled(manual.fontRenderer, TextFormatting.BOLD.toString() + (page + 1),
					guiLeft + xSize / 2, guiTop + 183, manual.getPagenumberColour(), 1, false);
			manual.titleRenderPost();

			GL11.glColor3f(1, 1, 1);
			IManualPage mPage = (page < 0 || page >= entry.getPages().length) ? null : entry.getPages()[page];
			if(mPage != null)
				mPage.renderPage(this, guiLeft + 32, guiTop + 28, mx + guiLeft, my + guiTop);

			mx += guiLeft;
			my += guiTop;
		}
		else {
			String title = manual.manualContents.containsKey(selectedCategory)
					? manual.formatCategoryName(selectedCategory) : manual.getManualName();
			manual.titleRenderPre();
			this.drawCenteredStringScaled(manual.fontRenderer, TextFormatting.BOLD + title, guiLeft + xSize / 2,
					guiTop + 12, manual.getTitleColour(), 1, true);
			manual.titleRenderPost();
		}
		if(this.searchField != null) {
			manual.fontRenderer.setUnicodeFlag(true);
			this.searchField.drawTextBox();
			if(this.hasSuggestions != -1 && this.hasSuggestions < this.buttonList.size())
				manual.fontRenderer.drawString("It looks like you meant:", guiLeft + 180, guiTop + 128,
						manual.getTextColour(), false);
		}
		manual.fontRenderer.setUnicodeFlag(uni);
		super.drawScreen(mx, my, f);
		GlStateManager.enableBlend();
		manual.entryRenderPost();
	}

	@Override
	public void onGuiClosed() {
		this.manual.closeManual();
		super.onGuiClosed();
		if(prevGuiScale != -1 && manual.allowGuiRescale())
			Minecraft.getMinecraft().gameSettings.guiScale = prevGuiScale;
	}

	@Override
	public void actionPerformed(GuiButton button) {
		if(buttonHeld)
			return;
		if(button.id == 0) {
			int sel = ((GuiClickableList) button).selectedOption;
			if(sel >= 0 && sel < headers.length) {
				if(((GuiClickableList) button).translationType == 0)
					selectedCategory = headers[sel];
				else {
					previousSelectedEntry.clear();
					selectedEntry = headers[sel];
				}
			}
			((GuiClickableList) button).selectedOption = -1;
			this.initGui();
		}
		else if(button.id == 11) {
			int sel = ((GuiClickableList) button).selectedOption;
			if(sel >= 0 && sel < suggestionHeaders.length)
				selectedEntry = suggestionHeaders[sel];
			((GuiClickableList) button).selectedOption = -1;
			this.initGui();
		}
		else if(button.id == 1) {
			if(selectedEntry != null) {
				if(previousSelectedEntry.size() > 0) {
					selectedEntry = previousSelectedEntry.get(0);
					previousSelectedEntry.remove(0);
				}
				else
					selectedEntry = null;
			}
			else if(selectedCategory != null)
				selectedCategory = null;
			page = 0;
			this.initGui();
		}
		else if(pageButtons.contains(button) && manual.getEntry(selectedEntry) != null) {
			ManualEntry entry = manual.getEntry(selectedEntry);
			IManualPage mPage = (page < 0 || page >= entry.getPages().length) ? null : entry.getPages()[page];
			if(mPage != null)
				mPage.buttonPressed(this, button);
		}
		buttonHeld = true;
	}

	public void drawCenteredStringScaled(FontRenderer fr, String s, int x, int y, int colour, float scale,
			boolean shadow) {
		int xx = (int) Math.floor(x / scale - (fr.getStringWidth(s) / 2));
		int yy = (int) Math.floor(y / scale - (fr.FONT_HEIGHT / 2));
		if(scale != 1)
			GL11.glScalef(scale, scale, scale);
		fr.drawString(s, xx, yy, colour, shadow);
		if(scale != 1)
			GL11.glScalef(1 / scale, 1 / scale, 1 / scale);
	}

	@Override
	public void drawGradientRect(int x1, int y1, int x2, int y2, int colour1, int colour2) {
		super.drawGradientRect(x1, y1, x2, y2, colour1, colour2);
		GL11.glEnable(GL11.GL_BLEND);
	}

	@Override
	public void renderToolTip(ItemStack stack, int x, int y) {
		super.renderToolTip(stack, x, y);
	}

	@Override
	public void drawHoveringText(List text, int x, int y, FontRenderer font) {
		manual.tooltipRenderPre();
		super.drawHoveringText(text, x, y, font);
		manual.tooltipRenderPost();
	}

	@Override
	public void handleMouseInput() throws IOException {
		super.handleMouseInput();
		int wheel = Mouse.getEventDWheel();
		if(wheel != 0 && manual.getEntry(selectedEntry) != null) {
			ManualEntry entry = manual.getEntry(selectedEntry);
			if(wheel > 0 && page > 0) {
				page--;
				this.initGui();
			}
			else if(wheel < 0 && page < entry.getPages().length - 1) {
				page++;
				this.initGui();
			}
		}
	}

	@Override
	public void mouseClicked(int mx, int my, int button) throws IOException {
		super.mouseClicked(mx, my, button);
		if(button == 0 && manual.getEntry(selectedEntry) != null) {
			ManualEntry entry = manual.getEntry(selectedEntry);
			mx -= guiLeft;
			my -= guiTop;
			if(page > 0 && mx > 32 && mx < 32 + 17 && my > 179 && my < 179 + 10) {
				page--;
				this.initGui();
			}
			if(page < entry.getPages().length - 1 && mx > 135 && mx < 135 + 17 && my > 179 && my < 179 + 10) {
				page++;
				this.initGui();
			}

		}
		else if(button == 1) {
			if(searchField != null && searchField.getText() != null && !searchField.getText().isEmpty())
				searchField.setText("");
			else if(selectedEntry != null) {
				if(previousSelectedEntry.size() > 0) {
					selectedEntry = previousSelectedEntry.get(0);
					previousSelectedEntry.remove(0);
				}
				else
					selectedEntry = null;
			}
			else if(selectedCategory != null)
				selectedCategory = null;
			page = 0;
			this.initGui();
		}
		lastClick = new int[] {mx, my};
		if(this.searchField != null)
			this.searchField.mouseClicked(mx, my, button);
	}

	@Override
	protected void mouseReleased(int mx, int my, int action) {
		super.mouseReleased(mx, my, action);
		if(buttonHeld && (action == 0 || action == 1))
			buttonHeld = false;
		lastClick = null;
		lastDrag = null;
	}

	@Override
	protected void mouseClickMove(int mx, int my, int button, long time) {
		if(lastClick != null && manual.getEntry(selectedEntry) != null
				&& page < manual.getEntry(selectedEntry).getPages().length) {
			ManualEntry entry = manual.getEntry(selectedEntry);
			if(lastDrag == null)
				lastDrag = new int[] {mx - guiLeft, my - guiTop};
			entry.getPages()[page].mouseDragged(guiLeft + 32, guiTop + 28, lastClick[0], lastClick[1], mx - guiLeft,
					my - guiTop, lastDrag[0], lastDrag[1], button);
			lastDrag = new int[] {mx - guiLeft, my - guiTop};
		}
	}

	@Override
	protected void keyTyped(char c, int i) throws IOException {
		if(this.searchField != null && this.searchField.textboxKeyTyped(c, i)) {
			String search = searchField.getText();
			if(search == null || search.trim().isEmpty()) {
				hasSuggestions = -1;
				this.initGui();
			}
			else {
				search = search.toLowerCase();
				ArrayList<String> lHeaders = new ArrayList<String>();
				HashMap<String, String> lSpellcheck = new HashMap<String, String>();
				for(ManualEntry e : manual.manualContents.values()) {
					if(manual.showEntryInList(e)) {
						if(manual.formatEntryName(e.getName()).toLowerCase().contains(search))
							lHeaders.add(e.getName());
						else
							lSpellcheck.put(manual.formatEntryName(e.getName()), e.getName());
					}
				}
				ArrayList<String> lCorrections = ManualUtils.getPrimitiveSpellingCorrections(search,
						lSpellcheck.keySet().toArray(new String[lSpellcheck.keySet().size()]), 4);
				for(String key : lSpellcheck.keySet())
					if(!lCorrections.contains(key)) {
						ManualEntry e = manual.getEntry(lSpellcheck.get(key));
						for(IManualPage page : e.getPages())
							if(page.listForSearch(search)) {
								lHeaders.add(e.getName());
								break;
							}
					}

				headers = lHeaders.toArray(new String[lHeaders.size()]);
				this.buttonList.set(0,
						new GuiClickableList(this, 0, guiLeft + 40, guiTop + 20, 100, 148, 1f, 1, headers));
				if(!lCorrections.isEmpty()) {
					GuiClickableList suggestions = new GuiClickableList(this, 11, guiLeft + 180, guiTop + 138, 100, 80,
							1f, -1, lCorrections.toArray(new String[0]));
					if(hasSuggestions != -1)
						this.buttonList.set(hasSuggestions, suggestions);
					else {
						hasSuggestions = this.buttonList.size();
						this.buttonList.add(suggestions);
					}
					this.suggestionHeaders = new String[lCorrections.size()];
					for(int j = 0; j < this.suggestionHeaders.length; j++)
						this.suggestionHeaders[j] = lSpellcheck.get(lCorrections.get(j));
				}
				else if(hasSuggestions != -1) {
					this.buttonList.remove(hasSuggestions);
					hasSuggestions = -1;
				}
			}
		}
		else {
			super.keyTyped(c, i);
		}
	}

}


text:
using AllReady.Models;
using MediatR;

namespace AllReady.Areas.Admin.Features.Shared
{
    public class CheckValidPostcodeQuery : IAsyncRequest<bool>
    {
        public PostalCodeGeo Postcode { get; set; }
    }
}


text: Spiking on adding an 834 file type parser to Hippo.