text:
<?php

namespace Julien\Bundle\ArtistBundle\Controller;

use Symfony\Component\HttpFoundation\Request;
use Symfony\Bundle\FrameworkBundle\Controller\Controller;
use Sensio\Bundle\FrameworkExtraBundle\Configuration\Method;
use Sensio\Bundle\FrameworkExtraBundle\Configuration\Route;
use Sensio\Bundle\FrameworkExtraBundle\Configuration\Template;
use Julien\Bundle\ArtistBundle\Entity\Exponent;
use Julien\Bundle\ArtistBundle\Form\ExponentType;

/**
 * Exponent controller.
 *
 * @Route("/exponent")
 */
class ExponentController extends Controller
{

    /**
     * Lists all Exponent entities.
     *
     * @Route("/", name="exponent")
     * @Method("GET")
     * @Template()
     */
    public function indexAction()
    {
        $em = $this->getDoctrine()->getManager();

        $entities = $em->getRepository('JulienArtistBundle:Exponent')->findAll();

        return array(
            'entities' => $entities,
        );
    }
    /**
     * Creates a new Exponent entity.
     *
     * @Route("/", name="exponent_create")
     * @Method("POST")
     * @Template("JulienArtistBundle:Exponent:new.html.twig")
     */
    public function createAction(Request $request)
    {
        $entity = new Exponent();
        $form = $this->createCreateForm($entity);
        $form->handleRequest($request);

        if ($form->isValid()) {
            $em = $this->getDoctrine()->getManager();
            $em->persist($entity);
            $em->flush();

            return $this->redirect($this->generateUrl('exponent_show', array('id' => $entity->getId())));
        }

        return array(
            'entity' => $entity,
            'form'   => $form->createView(),
        );
    }

    /**
     * Creates a form to create a Exponent entity.
     *
     * @param Exponent $entity The entity
     *
     * @return \Symfony\Component\Form\Form The form
     */
    private function createCreateForm(Exponent $entity)
    {
        $form = $this->createForm(new ExponentType(), $entity, array(
            'action' => $this->generateUrl('exponent_create'),
            'method' => 'POST',
        ));

        $form->add('submit', 'submit', array('label' => 'Create'));

        return $form;
    }

    /**
     * Displays a form to create a new Exponent entity.
     *
     * @Route("/new", name="exponent_new")
     * @Method("GET")
     * @Template()
     */
    public function newAction()
    {
        $entity = new Exponent();
        $form   = $this->createCreateForm($entity);

        return array(
            'entity' => $entity,
            'form'   => $form->createView(),
        );
    }

    /**
     * Finds and displays a Exponent entity.
     *
     * @Route("/{id}", name="exponent_show")
     * @Method("GET")
     * @Template()
     */
    public function showAction($id)
    {
        $em = $this->getDoctrine()->getManager();

        $entity = $em->getRepository('JulienArtistBundle:Exponent')->find($id);

        if (!$entity) {
            throw $this->createNotFoundException('Unable to find Exponent entity.');
        }

        $deleteForm = $this->createDeleteForm($id);

        return array(
            'entity'      => $entity,
            'delete_form' => $deleteForm->createView(),
        );
    }

    /**
     * Displays a form to edit an existing Exponent entity.
     *
     * @Route("/{id}/edit", name="exponent_edit")
     * @Method("GET")
     * @Template()
     */
    public function editAction($id)
    {
        $em = $this->getDoctrine()->getManager();

        $entity = $em->getRepository('JulienArtistBundle:Exponent')->find($id);

        if (!$entity) {
            throw $this->createNotFoundException('Unable to find Exponent entity.');
        }

        $editForm = $this->createEditForm($entity);
        $deleteForm = $this->createDeleteForm($id);

        return array(
            'entity'      => $entity,
            'edit_form'   => $editForm->createView(),
            'delete_form' => $deleteForm->createView(),
        );
    }

    /**
    * Creates a form to edit a Exponent entity.
    *
    * @param Exponent $entity The entity
    *
    * @return \Symfony\Component\Form\Form The form
    */
    private function createEditForm(Exponent $entity)
    {
        $form = $this->createForm(new ExponentType(), $entity, array(
            'action' => $this->generateUrl('exponent_update', array('id' => $entity->getId())),
            'method' => 'PUT',
        ));

        $form->add('submit', 'submit', array('label' => 'Update'));

        return $form;
    }
    /**
     * Edits an existing Exponent entity.
     *
     * @Route("/{id}", name="exponent_update")
     * @Method("PUT")
     * @Template("JulienArtistBundle:Exponent:edit.html.twig")
     */
    public function updateAction(Request $request, $id)
    {
        $em = $this->getDoctrine()->getManager();

        $entity = $em->getRepository('JulienArtistBundle:Exponent')->find($id);

        if (!$entity) {
            throw $this->createNotFoundException('Unable to find Exponent entity.');
        }

        $deleteForm = $this->createDeleteForm($id);
        $editForm = $this->createEditForm($entity);
        $editForm->handleRequest($request);

        if ($editForm->isValid()) {
            $em->flush();

            return $this->redirect($this->generateUrl('exponent_edit', array('id' => $id)));
        }

        return array(
            'entity'      => $entity,
            'edit_form'   => $editForm->createView(),
            'delete_form' => $deleteForm->createView(),
        );
    }
    /**
     * Deletes a Exponent entity.
     *
     * @Route("/{id}", name="exponent_delete")
     * @Method("DELETE")
     */
    public function deleteAction(Request $request, $id)
    {
        $form = $this->createDeleteForm($id);
        $form->handleRequest($request);

        if ($form->isValid()) {
            $em = $this->getDoctrine()->getManager();
            $entity = $em->getRepository('JulienArtistBundle:Exponent')->find($id);

            if (!$entity) {
                throw $this->createNotFoundException('Unable to find Exponent entity.');
            }

            $em->remove($entity);
            $em->flush();
        }

        return $this->redirect($this->generateUrl('exponent'));
    }

    /**
     * Creates a form to delete a Exponent entity by id.
     *
     * @param mixed $id The entity id
     *
     * @return \Symfony\Component\Form\Form The form
     */
    private function createDeleteForm($id)
    {
        return $this->createFormBuilder()
            ->setAction($this->generateUrl('exponent_delete', array('id' => $id)))
            ->setMethod('DELETE')
            ->add('submit', 'submit', array('label' => 'Delete'))
            ->getForm()
        ;
    }
}


text:
@interface SpectacleScreenDetection (SpectacleScreenDetectionPrivate)

+ (NSScreen *)screenContainingRect:(CGRect)rect;

#pragma mark -

+ (CGFloat)percentageOfRect:(CGRect)rect withinFrameOfScreen:(CGRect)frameOfScreen;

#pragma mark -

+ (NSScreen *)nextOrPreviousScreenToFrameOfScreen:(CGRect)frameOfScreen inDirectionOfAction:(SpectacleWindowAction)action;

@end

#pragma mark -

@implementation SpectacleScreenDetection

+ (NSScreen *)screenWithAction:(SpectacleWindowAction)action andRect:(CGRect)rect
{
    NSScreen *result = [self screenContainingRect:rect];

    if(MovingToNextOrPreviousDisplay(action)) {
        result = [self nextOrPreviousScreenToFrameOfScreen:NSRectToCGRect([result frame]) inDirectionOfAction:action];
    }

    return result;
}

@end

#pragma mark -

@implementation SpectacleScreenDetection (SpectacleScreenDetectionPrivate)

+ (NSScreen *)screenContainingRect:(CGRect)rect
{
    CGFloat largestPercentageOfRectWithinFrameOfScreen = 0.0f;
    NSScreen *result = [NSScreen mainScreen];

    for(NSScreen *currentScreen in [NSScreen screens]) {
        CGRect currentFrameOfScreen = NSRectToCGRect([currentScreen frame]);
        CGRect flippedRect = rect;
        CGFloat percentageOfRectWithinCurrentFrameOfScreen = 0.0f;

        flippedRect.origin.y = FlipVerticalOriginOfRectInRect(flippedRect, currentFrameOfScreen);

        if(CGRectContainsRect(currentFrameOfScreen, flippedRect)) {
            result = currentScreen;

            break;
        }

        percentageOfRectWithinCurrentFrameOfScreen = [self percentageOfRect:flippedRect withinFrameOfScreen:currentFrameOfScreen];

        if(percentageOfRectWithinCurrentFrameOfScreen > largestPercentageOfRectWithinFrameOfScreen) {
            largestPercentageOfRectWithinFrameOfScreen = percentageOfRectWithinCurrentFrameOfScreen;

            result = currentScreen;
        }
    }

    return result;
}

#pragma mark -

+ (CGFloat)percentageOfRect:(CGRect)rect withinFrameOfScreen:(CGRect)frameOfScreen
{
    CGRect intersectionOfRectAndFrameOfScreen = CGRectIntersection(rect, frameOfScreen);
    CGFloat result = 0.0f;

    if(!CGRectIsNull(intersectionOfRectAndFrameOfScreen)) {
        result = AreaOfRect(intersectionOfRectAndFrameOfScreen) / AreaOfRect(rect);
    }

    return result;
}

#pragma mark -

+ (NSScreen *)nextOrPreviousScreenToFrameOfScreen:(CGRect)frameOfScreen inDirectionOfAction:(SpectacleWindowAction)action
{
    NSArray *screens = [NSScreen screens];
    NSScreen *result = nil;

    if([screens count] <= 1) {
        return result;
    }

    for(NSInteger i = 0; i < [screens count]; i++) {
        NSScreen *currentScreen = screens[i];
        CGRect currentFrameOfScreen = NSRectToCGRect([currentScreen frame]);
        NSInteger nextOrPreviousIndex = i;

        if(!CGRectEqualToRect(currentFrameOfScreen, frameOfScreen)) {
            continue;
        }

        if(action == SpectacleWindowActionNextDisplay) {
            nextOrPreviousIndex++;
        } else if(action == SpectacleWindowActionPreviousDisplay) {
            nextOrPreviousIndex--;
        }

        if(nextOrPreviousIndex < 0) {
            nextOrPreviousIndex = [screens count] - 1;
        } else if(nextOrPreviousIndex >= [screens count]) {
            nextOrPreviousIndex = 0;
        }

        result = screens[nextOrPreviousIndex];

        break;
    }

    return result;
}

@end

redpajama_set_name: RedPajamaGithub


text:
[![NPM version](http://img.shields.io/npm/v/stylelint-config-rtablada.svg)](https://www.npmjs.org/package/stylelint-config-rtablada) [![Travis Build Status](https://img.shields.io/travis/rtablada/stylelint-config-rtablada/master.svg?label=unix%20build)](https://travis-ci.org/rtablada/stylelint-config-rtablada)

> SuitCSS shareable config for stylelint.

My CSS style guide is very similar to the [SuitCSS's code style](https://github.com/suitcss/suit/blob/master/doc/STYLE.md)
with one change in that I find that CSS rules should be grouped logically instead of alphabetically.

## Installation

```console
$ npm install stylelint-config-rtablada
```

## Usage

Set your stylelint config to:

```json
{
  "extends": "stylelint-config-rtablada"
}
```

### Extending the config

Simply add a `"rules"` key to your config and add your overrides there.

For example, to change the `indentation` to tabs and turn off the `number-leading-zero` rule:

```json
{
  "extends": "stylelint-config-rtablada",
  "rules": {
    "indentation": [2, "tab"],
    "number-leading-zero": 0
  }
}
```

## [Changelog](CHANGELOG.md)

## [License](LICENSE)


text:
set -euo pipefail

if [[ `uname` == Darwin ]]; then
  export LDFLAGS="-Wl,-rpath,$PREFIX/lib $LDFLAGS"
fi

if [[ `uname` == Darwin ]]; then
./autogen.sh
fi

./configure --prefix="$PREFIX" --with-libsodium
make -j${CPU_COUNT}
make check
make install

# Generate CMake files, so downstream packages can use `find_package(ZeroMQ)`,
# which is normally only available when libzmq is itself installed with CMake

CMAKE_DIR="$PREFIX/lib/cmake/ZeroMQ"
mkdir -p "$CMAKE_DIR"

cat << EOF > "$CMAKE_DIR/ZeroMQConfig.cmake"
set(PN ZeroMQ)
set(_CONDA_PREFIX "$PREFIX")
set(\${PN}_INCLUDE_DIR "\${_CONDA_PREFIX}/include")
set(\${PN}_LIBRARY "\${_CONDA_PREFIX}/lib/libzmq${SHLIB_EXT}")
set(\${PN}_STATIC_LIBRARY "\${_CONDA_PREFIX}/lib/libzmq.a")
unset(_CONDA_PREFIX)

set(\${PN}_FOUND TRUE)

# add libzmq-4.2.3 cmake targets

# only define targets once
# this file can be loaded multiple times
if (TARGET libzmq)
  return()
endif()

add_library(libzmq SHARED IMPORTED)
set_property(TARGET libzmq PROPERTY INTERFACE_INCLUDE_DIRECTORIES "\${\${PN}_INCLUDE_DIR}")
set_property(TARGET libzmq PROPERTY IMPORTED_LOCATION "\${\${PN}_LIBRARY}")

add_library(libzmq-static STATIC IMPORTED "\${\${PN}_INCLUDE_DIR}")
set_property(TARGET libzmq-static PROPERTY INTERFACE_INCLUDE_DIRECTORIES "\${\${PN}_INCLUDE_DIR}")
set_property(TARGET libzmq-static PROPERTY IMPORTED_LOCATION "\${\${PN}_STATIC_LIBRARY}")

EOF

cat << EOF > "$CMAKE_DIR/ZeroMQConfigVersion.cmake"
set(PACKAGE_VERSION "$PKG_VERSION")

# Check whether the requested PACKAGE_FIND_VERSION is compatible
if("\${PACKAGE_VERSION}" VERSION_LESS "\${PACKAGE_FIND_VERSION}")
  set(PACKAGE_VERSION_COMPATIBLE FALSE)
else()
  set(PACKAGE_VERSION_COMPATIBLE TRUE)
  if ("\${PACKAGE_VERSION}" VERSION_EQUAL "\${PACKAGE_FIND_VERSION}")
    set(PACKAGE_VERSION_EXACT TRUE)
  endif()
endif()
EOF


text:
<?php

abstract class IPF_ORM_Access implements ArrayAccess
{
    public function setArray(array $array)
    {
        foreach ($array as $k => $v) {
            $this->set($k, $v);
        }

        return $this;
    }

    public function __set($name, $value)
    {
        $this->set($name, $value);
    }

    public function __get($name)
    {
        return $this->get($name);
    }

    public function __isset($name)
    {
        return $this->contains($name);
    }

    public function __unset($name)
    {
        return $this->remove($name);
    }

    public function offsetExists($offset)
    {
        return $this->contains($offset);
    }

    public function offsetGet($offset)
    {
        return $this->get($offset);
    }

    public function offsetSet($offset, $value)
    {
        if ( ! isset($offset)) {
            $this->add($value);
        } else {
            $this->set($offset, $value);
        }
    }

    public function offsetUnset($offset)
    {
        return $this->remove($offset);
    }

    public function remove($offset)
    {
        throw new IPF_ORM_Exception('Remove is not supported for ' . get_class($this));
    }

    public function get($offset)
    {
        throw new IPF_ORM_Exception('Get is not supported for ' . get_class($this));
    }

    public function set($offset, $value)
    {
        throw new IPF_ORM_Exception('Set is not supported for ' . get_class($this));
    }

    public function contains($offset)
    {
        throw new IPF_ORM_Exception('Contains is not supported for ' . get_class($this));
    }

    public function add($value)
    {
        throw new IPF_ORM_Exception('Add is not supported for ' . get_class($this));
    }
}


text:
package com.sosnoski.ws.library.jibx2wsdl;

public class AddDuplicateException extends Exception
{
    private AddDuplicateData m_data;

    public AddDuplicateException() {}

    public AddDuplicateException(Book book) {
        m_data = new AddDuplicateData(book);
    }

    public void setData(AddDuplicateData data) {
        m_data = data;
    }

    public AddDuplicateData getData() {
        return m_data;
    }
}


text:
/*
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
package com.facebook.presto;

import com.facebook.presto.connector.ConnectorId;
import com.facebook.presto.metadata.SessionPropertyManager;
import com.facebook.presto.spi.ConnectorSession;
import com.facebook.presto.spi.PrestoException;
import com.facebook.presto.spi.security.ConnectorIdentity;
import com.facebook.presto.spi.type.TimeZoneKey;
import com.google.common.collect.ImmutableMap;

import java.util.Locale;
import java.util.Map;

import static com.facebook.presto.spi.StandardErrorCode.INVALID_SESSION_PROPERTY;
import static com.google.common.base.MoreObjects.toStringHelper;
import static java.lang.String.format;
import static java.util.Objects.requireNonNull;

public class FullConnectorSession
        implements ConnectorSession
{
    private final String queryId;
    private final ConnectorIdentity identity;
    private final TimeZoneKey timeZoneKey;
    private final Locale locale;
    private final long startTime;
    private final Map<String, String> properties;
    private final ConnectorId connectorId;
    private final String catalog;
    private final SessionPropertyManager sessionPropertyManager;
    private final boolean isLegacyTimestamp;

    public FullConnectorSession(
            String queryId,
            ConnectorIdentity identity,
            TimeZoneKey timeZoneKey,
            Locale locale,
            long startTime,
            boolean isLegacyTimestamp)
    {
        this.queryId = requireNonNull(queryId, "queryId is null");
        this.identity = requireNonNull(identity, "identity is null");
        this.timeZoneKey = requireNonNull(timeZoneKey, "timeZoneKey is null");
        this.locale = requireNonNull(locale, "locale is null");
        this.startTime = startTime;

        this.properties = null;
        this.connectorId = null;
        this.catalog = null;
        this.sessionPropertyManager = null;
        this.isLegacyTimestamp = isLegacyTimestamp;
    }

    public FullConnectorSession(
            String queryId,
            ConnectorIdentity identity,
            TimeZoneKey timeZoneKey,
            Locale locale,
            long startTime,
            Map<String, String> properties,
            ConnectorId connectorId,
            String catalog,
            SessionPropertyManager sessionPropertyManager,
            boolean isLegacyTimestamp)
    {
        this.queryId = requireNonNull(queryId, "queryId is null");
        this.identity = requireNonNull(identity, "identity is null");
        this.timeZoneKey = requireNonNull(timeZoneKey, "timeZoneKey is null");
        this.locale = requireNonNull(locale, "locale is null");
        this.startTime = startTime;

        this.properties = ImmutableMap.copyOf(requireNonNull(properties, "properties is null"));
        this.connectorId = requireNonNull(connectorId, "connectorId is null");
        this.catalog = requireNonNull(catalog, "catalog is null");
        this.sessionPropertyManager = requireNonNull(sessionPropertyManager, "sessionPropertyManager is null");
        this.isLegacyTimestamp = isLegacyTimestamp;
    }

    @Override
    public String getQueryId()
    {
        return queryId;
    }

    @Override
    public ConnectorIdentity getIdentity()
    {
        return identity;
    }

    @Override
    public TimeZoneKey getTimeZoneKey()
    {
        return timeZoneKey;
    }

    @Override
    public Locale getLocale()
    {
        return locale;
    }

    @Override
    public long getStartTime()
    {
        return startTime;
    }

    @Override
    public boolean isLegacyTimestamp()
    {
        return isLegacyTimestamp;
    }

    @Override
    public <T> T getProperty(String propertyName, Class<T> type)
    {
        if (properties == null) {
            throw new PrestoException(INVALID_SESSION_PROPERTY, format("Unknown session property: %s.%s", catalog, propertyName));
        }

        return sessionPropertyManager.decodeCatalogPropertyValue(connectorId, catalog, propertyName, properties.get(propertyName), type);
    }

    @Override
    public String toString()
    {
        return toStringHelper(this)
                .omitNullValues()
                .add("queryId", queryId)
                .add("user", getUser())
                .add("timeZoneKey", timeZoneKey)
                .add("locale", locale)
                .add("startTime", startTime)
                .add("properties", properties)
                .toString();
    }
}


text:
<form id="form" method="post">
    Sélection du package: <select class="target" name="packageIdRequested">
<?php
    foreach($packages as $package)
    {
        echo '<option ' . ($package->getId() == $packageIdRequested ? 'selected' : '') . ' value="' . $package->getId() . '">' . $package->getName('fr') . '</option>';
    }
?>
    </select>
</form>

<?php
    echo '

';
?>

<?php
    function setSelected($data, $compareTo)
    {
        if ($data == $compareTo)
            return "selected='selected'";
        return '';
    }

    echo '
Archives zip
';

    // Upload new archive
    $form = new Form('', 'post');

    $form->add('hidden', 'idPackage');

    $form->add('file', 'zipFile')
          ->isInParagraph(false);

    $form->add('submit', 'Envoyer')
         ->isInParagraph(false);

    echo $form->toString();

    echo '
';

    echo '

Tableau d\'édition des archives d\'images

	        Nom
	        Action

';

    // Display uploaded archives
	for($i=0; $i<count($archives); ++$i)
	{
        if($archives[$i]->getIdPackage() != $packageIdRequested)
            continue;

        $idArchive = $archives[$i]->getId();

        $sizeName = strlen($archives[$i]->getFilename());

        echo '
';
        echo "
getId()}'
                      data-entry-name='ArchivesOfPackages'
                      data-field-name='Filename'
                      data-form-type='text'
                      data-form-size='{$sizeName}'>{$archives[$i]->getFilename()}
	";
		echo "	";
        echo '
';
    }
    echo '
';

    echo '

';

    echo '
Documents
';

    // Upload new document
    $form = new Form('', 'post');

    $form->add('file', 'PDFFile')
         ->isInParagraph(false);

    $form->add('hidden', 'idPackage');

    $form->add('submit', 'Envoyer')
         ->isInParagraph(false);

    echo $form->toString();

    echo '
';

    echo '

Tableau d\'édition des documents

	        Nom
	        Action

';

    // Display uploaded documents
	for($i=0; $i<count($documents); ++$i)
	{
        if($documents[$i]->getIdPackage() != $packageIdRequested)
            continue;

        $idDocument = $documents[$i]->getId();

	        $sizeName = strlen($documents[$i]->getFilename());

        echo '
';
        echo "
{$documents[$i]->getFilename()}
	";
		echo "	";
        echo '
';
    }
    echo '
';
    echo '
';

?>


text:
START_ATF_NAMESPACE
    struct _personal_amine_make_storage_clzo
    {
        unsigned int dwAvatorSerial;
    };
END_ATF_NAMESPACE


text:
import datetime
from south.db import db
from south.v2 import SchemaMigration
from django.db import models

class Migration(SchemaMigration):

    def forwards(self, orm):
        # Adding field 'Project.category'
        db.add_column(u'partz_project', 'category',
                      self.gf('django.db.models.fields.CharField')(max_length=250, null=True, blank=True),
                      keep_default=False)

    def backwards(self, orm):
        # Deleting field 'Project.category'
        db.delete_column(u'partz_project', 'category')

    models = {
        u'partz.datedmodel': {
            'Meta': {'object_name': 'DatedModel'},
            'birth_date': ('django.db.models.fields.DateTimeField', [], {'auto_now_add': 'True', 'blank': 'True'}),
            u'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
            'mod_date': ('django.db.models.fields.DateTimeField', [], {'auto_now': 'True', 'blank': 'True'})
        },
        u'partz.media': {
            'Meta': {'object_name': 'Media', '_ormbases': [u'partz.DatedModel']},
            u'datedmodel_ptr': ('django.db.models.fields.related.OneToOneField', [], {'to': u"orm['partz.DatedModel']", 'unique': 'True', 'primary_key': 'True'}),
            'description': ('django.db.models.fields.TextField', [], {'null': 'True', 'blank': 'True'}),
            'image': ('django.db.models.fields.files.ImageField', [], {'max_length': '100'}),
            'project': ('django.db.models.fields.related.ForeignKey', [], {'to': u"orm['partz.Project']"})
        },
        u'partz.note': {
            'Meta': {'object_name': 'Note', '_ormbases': [u'partz.DatedModel']},
            'content': ('django.db.models.fields.TextField', [], {}),
            u'datedmodel_ptr': ('django.db.models.fields.related.OneToOneField', [], {'to': u"orm['partz.DatedModel']", 'unique': 'True', 'primary_key': 'True'}),
            'project': ('django.db.models.fields.related.ForeignKey', [], {'to': u"orm['partz.Project']"})
        },
        u'partz.project': {
            'Meta': {'object_name': 'Project', '_ormbases': [u'partz.DatedModel']},
            'category': ('django.db.models.fields.CharField', [], {'max_length': '250', 'null': 'True', 'blank': 'True'}),
            u'datedmodel_ptr': ('django.db.models.fields.related.OneToOneField', [], {'to': u"orm['partz.DatedModel']", 'unique': 'True', 'primary_key': 'True'}),
            'description': ('django.db.models.fields.TextField', [], {'null': 'True', 'blank': 'True'}),
            'name': ('django.db.models.fields.CharField', [], {'max_length': '5000'}),
            'slug': ('django.db.models.fields.SlugField', [], {'max_length': '50'})
        }
    }

    complete_apps = ['partz']


text:
describe('DS#findAll', function () {
  it('should query the server for a collection', function () {
    var _this = this;
    Post.findAll();

    assert.deepEqual(JSON.stringify(Post.getAll()), JSON.stringify([]), 'The posts should not be in the store yet');

    setTimeout(function () {
      assert.equal(1, _this.requests.length);
      assert.equal(_this.requests[0].url, 'http://test.js-data.io/posts');
      assert.equal(_this.requests[0].method, 'GET');
      _this.requests[0].respond(200, {'Content-Type': 'application/json'}, DSUtils.toJson([p1, p2, p3, p4]));
    }, 100);

    // Should have no effect because there is already a pending query
    return Post.findAll().then(function (data) {
      assert.deepEqual(JSON.stringify(data), JSON.stringify([p1, p2, p3, p4]));

      assert.deepEqual(JSON.stringify(Post.getAll()), JSON.stringify([p1, p2, p3, p4]), 'The posts are now in the store');
      assert.isNumber(Post.lastModified(5));
      assert.isNumber(Post.lastSaved(5));
      Post.find(p1.id); // should not trigger another XHR

      // Should not make a request because the request was already completed
      return Post.findAll();
    }).then(function (data) {
      assert.deepEqual(JSON.stringify(data), JSON.stringify([p1, p2, p3, p4]));

      setTimeout(function () {
        assert.equal(2, _this.requests.length);
        assert.equal(_this.requests[1].url, 'http://test.js-data.io/posts');
        assert.equal(_this.requests[1].method, 'GET');
        _this.requests[1].respond(200, {'Content-Type': 'application/json'}, DSUtils.toJson([p1, p2, p3, p4]));
      }, 100);

      // Should make a request because bypassCache is set to true
      return Post.findAll(null, {bypassCache: true});
    }).then(function (data) {
      assert.deepEqual(JSON.stringify(data), JSON.stringify([p1, p2, p3, p4]));
      assert.equal(lifecycle.beforeInject.callCount, 2, 'beforeInject should have been called');
      assert.equal(lifecycle.afterInject.callCount, 2, 'afterInject should have been called');
      assert.equal(lifecycle.serialize.callCount, 0, 'serialize should have been called');
      assert.equal(lifecycle.deserialize.callCount, 2, 'deserialize should have been called');
    });
  });
  it('should query the server for a collection when expired', function () {
    var _this = this;
    Post.findAll();

    assert.deepEqual(JSON.stringify(Post.getAll()), JSON.stringify([]), 'The posts should not be in the store yet');

    setTimeout(function () {
      assert.equal(1, _this.requests.length);
      assert.equal(_this.requests[0].url, 'http://test.js-data.io/posts');
      assert.equal(_this.requests[0].method, 'GET');
      _this.requests[0].respond(200, {'Content-Type': 'application/json'}, DSUtils.toJson([p1, p2, p3, p4]));
    }, 100);

    // Should have no effect because there is already a pending query
    return Post.findAll(null, { maxAge: -1 }).then(function (data) {
      assert.deepEqual(JSON.stringify(data), JSON.stringify([p1, p2, p3, p4]));

      assert.deepEqual(JSON.stringify(Post.getAll()), JSON.stringify([p1, p2, p3, p4]), 'The posts are now in the store');
      assert.isNumber(Post.lastModified(5));
      assert.isNumber(Post.lastSaved(5));
      Post.find(p1.id); // should not trigger another XHR

      assert.equal(1, _this.requests.length);

      setTimeout(function () {
        assert.equal(2, _this.requests.length);
        assert.equal(_this.requests[1].url, 'http://test.js-data.io/posts');
        assert.equal(_this.requests[1].method, 'GET');
        _this.requests[1].respond(200, {'Content-Type': 'application/json'}, DSUtils.toJson([p1, p2, p3, p4]));
      }, 100);

      // Should make a request because the request was already completed but is expired
      return Post.findAll(null, { maxAge: -1 });
    }).then(function (data) {
      assert.deepEqual(JSON.stringify(data), JSON.stringify([p1, p2, p3, p4]));
      assert.equal(2, _this.requests.length);

      // Should not make a request because the request was already completed and maxAge is null (not expired)
      return Post.findAll(null, { maxAge: null });
    }).then(function (data) {
      assert.deepEqual(JSON.stringify(data), JSON.stringify([p1, p2, p3, p4]));
      assert.equal(2, _this.requests.length);

      // Should not make a request because the request was already completed and maxAge = 0 (not expired)
      return Post.findAll(null, { maxAge: 0 });
    }).then(function (data) {
      assert.deepEqual(JSON.stringify(data), JSON.stringify([p1, p2, p3, p4]));
      assert.equal(2, _this.requests.length);

      assert.equal(lifecycle.beforeInject.callCount, 2, 'beforeInject should have been called');
      assert.equal(lifecycle.afterInject.callCount, 2, 'afterInject should have been called');
      assert.equal(lifecycle.serialize.callCount, 0, 'serialize should have been called');
      assert.equal(lifecycle.deserialize.callCount, 2, 'deserialize should have been called');
    });
  });
  it('should fail when no "idAttribute" is present on an item in the response', function () {
    var _this = this;

    setTimeout(function () {
      assert.equal(1, _this.requests.length);
      assert.equal(_this.requests[0].url, 'http://test.js-data.io/posts');
      assert.equal(_this.requests[0].method, 'GET');
      _this.requests[0].respond(200, {'Content-Type': 'application/json'}, DSUtils.toJson([
        {author: 'John', age: 30},
        {author: 'Sally', age: 31}
      ]));
    }, 100);

    return Post.findAll().then(function () {
      throw new Error('Should not have succeeded!');
    }, function (err) {
      assert(err.message, 'post.inject: "attrs" must contain the property specified by "idAttribute"!');
      assert.deepEqual(JSON.stringify(Post.getAll()), JSON.stringify([]), 'The posts should not be in the store');
      assert.equal(lifecycle.beforeInject.callCount, 1, 'beforeInject should have been called once');
      assert.equal(lifecycle.afterInject.callCount, 0, 'afterInject should not have been called');
    });
  });
  it('should query the server for a collection but not store the data if cacheResponse is false', function () {
    var _this = this;

    setTimeout(function () {
      assert.equal(1, _this.requests.length);
      assert.equal(_this.requests[0].url, 'http://test.js-data.io/posts');
      assert.equal(_this.requests[0].method, 'GET');
      _this.requests[0].respond(200, {'Content-Type': 'application/json'}, DSUtils.toJson([p1, p2, p3, p4]));
    }, 100);

    return Post.findAll(null, {cacheResponse: false}).then(function (data) {
      assert.deepEqual(JSON.stringify(data), JSON.stringify([p1, p2, p3, p4]));

      assert.deepEqual(JSON.stringify(Post.getAll()), JSON.stringify([]), 'The posts should not have been injected into the store');

      assert.equal(lifecycle.beforeInject.callCount, 0, 'beforeInject should have been called');
      assert.equal(lifecycle.afterInject.callCount, 0, 'afterInject should have been called');
      assert.equal(lifecycle.serialize.callCount, 0, 'serialize should have been called');
      assert.equal(lifecycle.deserialize.callCount, 1, 'deserialize should have been called');
    });
  });
  it('should correctly propagate errors', function () {
    var _this = this;

    setTimeout(function () {
      assert.equal(1, _this.requests.length);
      assert.equal(_this.requests[0].url, 'http://test.js-data.io/posts');
      assert.equal(_this.requests[0].method, 'GET');
      _this.requests[0].respond(404, {'Content-Type': 'text/plain'}, 'Not Found');
    }, 100);

    return Post.findAll().then(function () {
      throw new Error('Should not have succeeded!');
    }).catch(function (err) {
      assert.equal(err.data, 'Not Found');
    });
  });
  it('"params" argument is optional', function () {
    var _this = this;

    setTimeout(function () {
      assert.equal(1, _this.requests.length);
      assert.equal(_this.requests[0].url, 'http://test.js-data.io/posts');
      assert.equal(_this.requests[0].method, 'GET');
      _this.requests[0].respond(200, {'Content-Type': 'application/json'}, DSUtils.toJson([p1, p2, p3, p4]));
    }, 100);

    return Post.findAll().then(function (data) {
      assert.deepEqual(JSON.stringify(data), JSON.stringify([p1, p2, p3, p4]));
      assert.deepEqual(JSON.stringify(Post.getAll()), JSON.stringify([p1, p2, p3, p4]), 'The posts are now in the store');

      assert.equal(lifecycle.beforeInject.callCount, 1, 'beforeInject should have been called');
      assert.equal(lifecycle.afterInject.callCount, 1, 'afterInject should have been called');
      assert.equal(lifecycle.serialize.callCount, 0, 'serialize should have been called');
      assert.equal(lifecycle.deserialize.callCount, 1, 'deserialize should have been called');
    });
  });
  it('"params"', function () {
    var _this = this;

    var params = {
      where: {
        author: 'Adam'
      }
    };

    setTimeout(function () {
      assert.equal(1, _this.requests.length);
      assert.equal(_this.requests[0].url, 'http://test.js-data.io/posts?where=%7B%22author%22:%22Adam%22%7D');
      assert.equal(_this.requests[0].method, 'GET');
      _this.requests[0].respond(200, {'Content-Type': 'application/json'}, DSUtils.toJson([p4, p5]));
    }, 100);

    return Post.findAll(params).then(function (data) {
      assert.deepEqual(JSON.stringify(data), JSON.stringify([p4, p5]));
      assert.deepEqual(JSON.stringify(Post.filter(params)), JSON.stringify([p4, p5]), 'The posts are now in the store');
      assert.deepEqual(JSON.stringify(Post.filter({
        where: {
          id: {
            '>': 8
          }
        }
      })), JSON.stringify([p5]), 'The posts are now in the store');

      assert.equal(lifecycle.beforeInject.callCount, 1, 'beforeInject should have been called');
      assert.equal(lifecycle.afterInject.callCount, 1, 'afterInject should have been called');
      assert.equal(lifecycle.serialize.callCount, 0, 'serialize should have been called');
      assert.equal(lifecycle.deserialize.callCount, 1, 'deserialize should have been called');
    });
  });
  it('should return already injected items', function () {
    var _this = this;
    var u1 = {
      id: 1,
      name: 'John'
    };
    var u2 = {
      id: 2,
      name: 'Sally'
    };

    var Person = store.defineResource({
      name: 'person',
      endpoint: 'users',
      methods: {
        fullName: function () {
          return this.first + ' ' + this.last;
        }
      }
    });

    setTimeout(function () {
      assert.equal(1, _this.requests.length);
      assert.equal(_this.requests[0].url, 'http://test.js-data.io/users');
      assert.equal(_this.requests[0].method, 'GET');
      _this.requests[0].respond(200, {'Content-Type': 'application/json'}, DSUtils.toJson([u1, u2]));
    }, 100);

    return Person.findAll().then(function (data) {
      assert.deepEqual(JSON.stringify(data), JSON.stringify([
        Person.createInstance(u1),
        Person.createInstance(u2)
      ]));
      DSUtils.forEach(data, function (person) {
        assert.isTrue(Person.is(person), 'should be an instance of User');
      });
      assert.deepEqual(JSON.stringify(Person.getAll()), JSON.stringify([
        Person.createInstance(u1),
        Person.createInstance(u2)
      ]), 'The users are now in the store');

      assert.equal(lifecycle.beforeInject.callCount, 1, 'beforeInject should have been called');
      assert.equal(lifecycle.afterInject.callCount, 1, 'afterInject should have been called');
      assert.equal(lifecycle.serialize.callCount, 0, 'serialize should have been called');
      assert.equal(lifecycle.deserialize.callCount, 1, 'deserialize should have been called');
    });
  });
  it('should handle nested resources', function () {
    var _this = this;
    var testComment = {
      id: 5,
      content: 'test',
      approvedBy: 4
    };
    var testComment2 = {
      id: 6,
      content: 'test',
      approvedBy: 4
    };

    setTimeout(function () {
      assert.equal(1, _this.requests.length);
      assert.equal(_this.requests[0].url, 'http://test.js-data.io/user/4/comment?content=test');
      assert.equal(_this.requests[0].method, 'GET');
      _this.requests[0].respond(200, {'Content-Type': 'application/json'}, DSUtils.toJson([testComment, testComment2]));
    }, 100);

    return Comment.findAll({
      content: 'test'
    }, {
      params: {
        approvedBy: 4
      }
    }).then(function (comments) {
      assert.deepEqual(JSON.stringify(comments), JSON.stringify([testComment, testComment2]));
      assert.deepEqual(JSON.stringify(comments), JSON.stringify(Comment.filter({
        content: 'test'
      })));
      Comment.ejectAll();

      setTimeout(function () {
        assert.equal(2, _this.requests.length);
        assert.equal(_this.requests[1].url, 'http://test.js-data.io/comment?content=test');
        assert.equal(_this.requests[1].method, 'GET');
        _this.requests[1].respond(200, {'Content-Type': 'application/json'}, DSUtils.toJson([testComment, testComment2]));
      }, 100);

      return Comment.findAll({
        content: 'test'
      }, {
        bypassCache: true
      });
    }).then(function (comments) {
      assert.deepEqual(JSON.stringify(comments), JSON.stringify([testComment, testComment2]));
      assert.deepEqual(JSON.stringify(comments), JSON.stringify(Comment.filter({
        content: 'test'
      })));
      Comment.ejectAll();

      setTimeout(function () {
        assert.equal(3, _this.requests.length);
        assert.equal(_this.requests[2].url, 'http://test.js-data.io/comment?content=test');
        assert.equal(_this.requests[2].method, 'GET');
        _this.requests[2].respond(200, {'Content-Type': 'application/json'}, DSUtils.toJson([testComment, testComment2]));
      }, 100);

      return Comment.findAll({
        content: 'test'
      }, {
        bypassCache: true,
        params: {
          approvedBy: false
        }
      });
    }).then(function (comments) {
      assert.deepEqual(JSON.stringify(comments), JSON.stringify([testComment, testComment2]));
      assert.deepEqual(JSON.stringify(comments), JSON.stringify(Comment.filter({
        content: 'test'
      })));
    });
  });
  it('should use the fallback strategy', function () {
    var _this = this;

    var Thing = store.defineResource({
      name: 'thing',
      strategy: 'fallback',
      fallbackAdapters: ['http', 'localstorage']
    });

    return store.adapters.localstorage.update(Thing, 1, {
      thing: 'stuff',
      id: 1
    }).then(function (thing) {
      setTimeout(function () {
        try {
          assert.equal(1, _this.requests.length);
          assert.equal(_this.requests[0].url, 'http://test.js-data.io/thing?thing=stuff');
          assert.equal(_this.requests[0].method, 'GET');
          _this.requests[0].respond(500, {'Content-Type': 'text/plain'}, '500 - Internal Server Error');
        } catch (err) {
          console.error(err.stack);
        }
      }, 100);

      return Thing.findAll({thing: 'stuff'});
    }).then(function (things) {
      assert.deepEqual(DSUtils.toJson([{
        thing: 'stuff',
        id: 1
      }]), DSUtils.toJson(things));
    });
  });
  it('should "useFilter" and not "useFilter"', function () {
    var _this = this;

    setTimeout(function () {
      assert.equal(1, _this.requests.length);
      assert.equal(_this.requests[0].url, 'http://test.js-data.io/posts');
      assert.equal(_this.requests[0].method, 'GET');
      _this.requests[0].respond(200, {'Content-Type': 'application/json'}, DSUtils.toJson([p1, p2, p3, p4]));
    }, 100);

    return Post.findAll().then(function (data) {
      assert.deepEqual(JSON.stringify(data), JSON.stringify([p1, p2, p3, p4]));

      Post.eject(p1.id);

      assert.deepEqual(JSON.stringify(store.store.post.queryData['{}']), JSON.stringify([p2, p3, p4]));

      return Post.findAll();
    }).then(function (data) {
      assert.isTrue(data === store.store.post.queryData['{}']);
      assert.deepEqual(JSON.stringify(data), JSON.stringify([p2, p3, p4]));

      return Post.findAll(null, {useFilter: true});
    }).then(function (data) {
      assert.isFalse(data === store.store.post.queryData);
      assert.deepEqual(JSON.stringify(data), JSON.stringify([p2, p3, p4]));
    });
  });

  it('"collections"', function () {
    var _this = this;

    var params = {
      where: {
        author: 'Adam'
      }
    };

    setTimeout(function () {
      assert.equal(1, _this.requests.length);
      assert.equal(_this.requests[0].url, 'http://test.js-data.io/posts?where=%7B%22author%22:%22Adam%22%7D');
      assert.equal(_this.requests[0].method, 'GET');
      _this.requests[0].respond(200, {'Content-Type': 'application/json'}, DSUtils.toJson([p4, p5]));
    }, 100);

    var posts = Post.createCollection([], params);

    assert.equal(posts.resourceName, 'post');

    return posts.fetch().then(function (data) {
      assert.deepEqual(JSON.stringify(data), JSON.stringify([p4, p5]));
      assert.deepEqual(JSON.stringify(posts), JSON.stringify([p4, p5]));
      assert.deepEqual(JSON.stringify(Post.filter(params)), JSON.stringify([p4, p5]), 'The posts are now in the store');
      assert.deepEqual(JSON.stringify(Post.filter({
        where: {
          id: {
            '>': 8
          }
        }
      })), JSON.stringify([p5]), 'The posts are now in the store');

      assert.equal(lifecycle.beforeInject.callCount, 1, 'beforeInject should have been called');
      assert.equal(lifecycle.afterInject.callCount, 1, 'afterInject should have been called');
      assert.equal(lifecycle.serialize.callCount, 0, 'serialize should have been called');
      assert.equal(lifecycle.deserialize.callCount, 1, 'deserialize should have been called');

      return posts.fetch();
    }).then(function (p) {
      assert.isTrue(posts === p);
      assert.deepEqual(JSON.stringify(p), JSON.stringify([p4, p5]));
      return posts.fetch(null, { useFilter: true });
    }).then(function (p) {
      assert.isTrue(posts === p);
      assert.deepEqual(JSON.stringify(p), JSON.stringify([p4, p5]));
    });
  });

  it('"collections2"', function () {
    var _this = this;

    var params = {
      where: {
        author: 'Adam'
      }
    };

    setTimeout(function () {
      assert.equal(1, _this.requests.length);
      assert.equal(_this.requests[0].url, 'http://test.js-data.io/posts?where=%7B%22author%22:%22Adam%22%7D');
      assert.equal(_this.requests[0].method, 'GET');
      _this.requests[0].respond(200, {'Content-Type': 'application/json'}, DSUtils.toJson([p4, p5, p6]));
    }, 100);

    var posts = Post.createCollection([p4, p5], params);
    assert.deepEqual(JSON.stringify(posts), JSON.stringify([p4, p5]));
    assert.equal(posts.resourceName, 'post');

    return posts.fetch().then(function (p) {
      assert.isTrue(posts === p);
      assert.equal(p.length, 3);
    });
  });
});


text:
class RemoveAutoScalingFields < ActiveRecord::Migration
  def change
  	remove_column :instances, :deadcount
  	remove_column :instances, :rebooted_times
  	remove_column :instances, :decommissioned
  	remove_column :instances, :converged_at
  end
end


text:
package com.stratio.streaming.service;

import java.util.HashMap;
import java.util.Map;
import java.util.Set;

import kafka.javaapi.producer.Producer;

import org.wso2.siddhi.core.event.Event;
import org.wso2.siddhi.core.query.output.callback.QueryCallback;

import com.stratio.streaming.callbacks.ActionControllerCallback;
import com.stratio.streaming.callbacks.StreamToActionBusCallback;
import com.stratio.streaming.commons.constants.StreamAction;
import com.stratio.streaming.commons.messages.StratioStreamingMessage;
import com.stratio.streaming.serializer.Serializer;

public class CallbackService {

    private final Producer<String, String> producer;
    private final Serializer<String, StratioStreamingMessage> kafkaToJavaSerializer;
    private final Serializer<StratioStreamingMessage, Event> javaToSiddhiSerializer;

    private final Map<String, ActionControllerCallback> referencedCallbacks;

    public CallbackService(Producer<String, String> producer,
            Serializer<String, StratioStreamingMessage> kafkaToJavaSerializer,
            Serializer<StratioStreamingMessage, Event> javaToSiddhiSerializer) {
        this.producer = producer;
        this.kafkaToJavaSerializer = kafkaToJavaSerializer;
        this.javaToSiddhiSerializer = javaToSiddhiSerializer;
        this.referencedCallbacks = new HashMap<>();
    }

    public QueryCallback add(String streamName, Set<StreamAction> actions) {

        ActionControllerCallback callback = referencedCallbacks.get(streamName);

        if (callback == null) {
            callback = new StreamToActionBusCallback(actions, streamName, producer, kafkaToJavaSerializer,
                    javaToSiddhiSerializer);
            referencedCallbacks.put(streamName, callback);
        }

        return callback;
    }

    public void remove(String streamName) {
        referencedCallbacks.remove(streamName);
    }
}


text:
using System;
using System.Runtime.Serialization;

namespace Orleans.Runtime
{
    /// <summary>
    /// Indicates a lifecycle was canceled, either by request or due to observer error.
    /// </summary>
    [Serializable]
    public class OrleansLifecycleCanceledException : OrleansException
    {
        internal OrleansLifecycleCanceledException(string message)
            : base(message)
        {
        }

        internal OrleansLifecycleCanceledException(string message,
            Exception innerException) : base(message, innerException)
        {
        }

        protected OrleansLifecycleCanceledException(SerializationInfo info, StreamingContext context)
            : base(info, context)
        { }
    }
}


text: <%= textMarkup %>


text: $_I(java.io,"Externalizable",java.io.Serializable);


text:
from django.conf.urls import include, url
from django.contrib import admin

from django.contrib.auth import views as auth_views

from falkor import views

urlpatterns = [
    url(r'^admin/', include(admin.site.urls)),
    url('', include('social.apps.django_app.urls', namespace='social')),
    url(r'^login$', views.login),
    url(r'^$', views.home),
    url(r'^(?P<user>[-\w]+)/(?P<workspace>[-\w]+)/terminal/$', views.terminal),
    url(r'^logout/$', views.logout),
    url('^django-login/$', auth_views.login, name='default-login'),
    url(r'^workspaces/$', views.workspaces),
]


text:
<!DOCTYPE html>

    <meta charset="utf-8">
    <meta http-equiv="X-UA-Compatible" content="IE=edge">
    <meta name="viewport" content="width=device-width, initial-scale=1">
    <title>Site Hospedo - Painel 1.0</title>
    <link rel="shortcut icon" href="assets/img/favicon/icone.ico" type="image/x-icon" />

    <link href="assets/css/min/main.min.css" rel="stylesheet">
    <link href="assets/css/min/font-awesome.min.css" rel="stylesheet">

Entre na sua conta

                <form action="">

                        <input type="text" class="form-control" id="email" placeholder="Email">

                        <input type="password" class="form-control" id="senha" placeholder="Senha">

                                <button type="submit" class="btn btn-md btn-roxo-full" id="enviar">Entrar no Painel </button>

                                Esqueceu sua senha?

                </form>


text:
SET @OLD_SQL_MODE=@@SQL_MODE, SQL_MODE='ANSI';

DROP DATABASE IF EXISTS `cloud_usage`;

CREATE DATABASE `cloud_usage`;

GRANT ALL ON cloud_usage.* to cloud@`localhost`;
GRANT ALL ON cloud_usage.* to cloud@`%`;

GRANT process ON *.* TO cloud@`localhost`;
GRANT process ON *.* TO cloud@`%`;

commit;


text:
import {StringMapWrapper} from '../facade/collection';
import {isPresent} from '../facade/lang';

import {FILL_STYLE_FLAG} from './animation_constants';
import {AUTO_STYLE} from './metadata';

export function prepareFinalAnimationStyles(
    previousStyles: {[key: string]: string | number}, newStyles: {[key: string]: string | number},
    nullValue: string = null): {[key: string]: string} {
  const finalStyles: {[key: string]: string} = {};

  Object.keys(newStyles).forEach(prop => {
    const value = newStyles[prop];
    finalStyles[prop] = value == AUTO_STYLE ? nullValue : value.toString();
  });

  Object.keys(previousStyles).forEach(prop => {
    if (!isPresent(finalStyles[prop])) {
      finalStyles[prop] = nullValue;
    }
  });

  return finalStyles;
}

export function balanceAnimationKeyframes(
    collectedStyles: {[key: string]: string | number},
    finalStateStyles: {[key: string]: string | number}, keyframes: any[]): any[] {
  const limit = keyframes.length - 1;
  const firstKeyframe = keyframes[0];

  // phase 1: copy all the styles from the first keyframe into the lookup map
  const flatenedFirstKeyframeStyles = flattenStyles(firstKeyframe.styles.styles);

  const extraFirstKeyframeStyles: {[key: string]: string} = {};
  let hasExtraFirstStyles = false;
  Object.keys(collectedStyles).forEach(prop => {
    const value = collectedStyles[prop] as string;
    // if the style is already defined in the first keyframe then
    // we do not replace it.
    if (!flatenedFirstKeyframeStyles[prop]) {
      flatenedFirstKeyframeStyles[prop] = value;
      extraFirstKeyframeStyles[prop] = value;
      hasExtraFirstStyles = true;
    }
  });

  const keyframeCollectedStyles = StringMapWrapper.merge({}, flatenedFirstKeyframeStyles);

  // phase 2: normalize the final keyframe
  const finalKeyframe = keyframes[limit];
  finalKeyframe.styles.styles.unshift(finalStateStyles);

  const flatenedFinalKeyframeStyles = flattenStyles(finalKeyframe.styles.styles);
  const extraFinalKeyframeStyles: {[key: string]: string} = {};
  let hasExtraFinalStyles = false;
  Object.keys(keyframeCollectedStyles).forEach(prop => {
    if (!isPresent(flatenedFinalKeyframeStyles[prop])) {
      extraFinalKeyframeStyles[prop] = AUTO_STYLE;
      hasExtraFinalStyles = true;
    }
  });

  if (hasExtraFinalStyles) {
    finalKeyframe.styles.styles.push(extraFinalKeyframeStyles);
  }

  Object.keys(flatenedFinalKeyframeStyles).forEach(prop => {
    if (!isPresent(flatenedFirstKeyframeStyles[prop])) {
      extraFirstKeyframeStyles[prop] = AUTO_STYLE;
      hasExtraFirstStyles = true;
    }
  });

  if (hasExtraFirstStyles) {
    firstKeyframe.styles.styles.push(extraFirstKeyframeStyles);
  }

  collectAndResolveStyles(collectedStyles, [finalStateStyles]);

  return keyframes;
}

export function clearStyles(styles: {[key: string]: string | number}): {[key: string]: string} {
  const finalStyles: {[key: string]: string} = {};
  Object.keys(styles).forEach(key => { finalStyles[key] = null; });
  return finalStyles;
}

export function collectAndResolveStyles(
    collection: {[key: string]: string | number}, styles: {[key: string]: string | number}[]) {
  return styles.map(entry => {
    const stylesObj: {[key: string]: string | number} = {};
    Object.keys(entry).forEach(prop => {
      let value = entry[prop];
      if (value == FILL_STYLE_FLAG) {
        value = collection[prop];
        if (!isPresent(value)) {
          value = AUTO_STYLE;
        }
      }
      collection[prop] = value;
      stylesObj[prop] = value;
    });
    return stylesObj;
  });
}

export function renderStyles(
    element: any, renderer: any, styles: {[key: string]: string | number}): void {
  Object.keys(styles).forEach(prop => { renderer.setElementStyle(element, prop, styles[prop]); });
}

export function flattenStyles(styles: {[key: string]: string | number}[]): {[key: string]: string} {
  const finalStyles: {[key: string]: string} = {};
  styles.forEach(entry => {
    Object.keys(entry).forEach(prop => { finalStyles[prop] = entry[prop] as string; });
  });
  return finalStyles;
}


text:
Spree::Order.class_eval do
  def self.build_from_api(user, params)
    order = create
    params[:line_items_attributes] ||= []
    unless params[:line_items_attributes].empty?
      params[:line_items_attributes].each_key do |k|
        order.add_variant(Spree::Variant.find(params[:line_items_attributes][k][:variant_id]), params[:line_items_attributes][k][:quantity])
      end
    end

    order
  end
end


text:
<?xml version='1.0' encoding='UTF-8'?>
<Document>
  <Header>
    <SchemaName>Location</SchemaName>
    <Identifier>location_geonames_2750227</Identifier>
    <DocumentState>public</DocumentState>
    <TimeStamp>1390753463760</TimeStamp>
    <SummaryFields>
      <Title>NL > North Brabant > Nieuwe Vaart</Title>
    </SummaryFields>
  </Header>
  <Body>
    <Location>
      <GeopoliticalHierarchy>NL,North Brabant,Nieuwe Vaart</GeopoliticalHierarchy>
      <LocationName>
        <Appelation>Nieuwe Vaart</Appelation>
        <LocationNameType>populated locality</LocationNameType>
        <Comments></Comments>
      </LocationName>
      <Coordinates>
        <Longitude>4.9833300000000005</Longitude>
        <Latitude>51.68333</Latitude>
      </Coordinates>
      <GeonamesURI>http://www.geonames.org/2750227</GeonamesURI>
      <WikipediaLink/>
      <DbpediaLink/>
    </Location>
  </Body>
</Document>


text:
/*
 ONOS GUI -- Onlp View Module
 */

(function () {
    'use strict';

    // injected references
    var $log, $scope, $location, tbs, fs, mast, wss, ns, prefs, is, ps;

    // internal state
    var nzFilter = true,
        showDelta = false,
        pStartY,
        pHeight,
        wSize;

    var keyBindings = {
    };

    var defaultOnlpPrefsState = {
    };

    var prefsState = {};

    function updatePrefsState(what, b) {
        prefsState[what] = b ? 1 : 0;
        prefs.setPrefs('onlp_prefs', prefsState);
    }

    function restoreConfigFromPrefs() {
        prefsState = prefs.asNumbers(
            prefs.getPrefs('onlp_prefs', defaultOnlpPrefsState)
        );

        $log.debug('ONLP - Prefs State:', prefsState);
    }

    angular.module('ovOnlp', [])
        .controller('OvOnlpCtrl', [
            '$log', '$scope', '$location',
            'TableBuilderService', 'FnService', 'MastService', 'WebSocketService',
            'NavService', 'PrefsService', 'IconService',
            'PanelService',

            function (_$log_, _$scope_, _$location_,
                      _tbs_, _fs_, _mast_, _wss_,
                      _ns_, _prefs_, _is_, _ps_) {
                var params;
                var tableApi;
                $log = _$log_;
                $scope = _$scope_;
                $location = _$location_;
                tbs = _tbs_;
                fs = _fs_;
                mast = _mast_;
                wss = _wss_;
                ns = _ns_;
                prefs = _prefs_;
                is = _is_;
                ps = _ps_;

                params = $location.search();

                $scope.deviceTip = 'Show device table';
                $scope.flowTip = 'Show flow view for this device';
                $scope.groupTip = 'Show group view for this device';
                $scope.meterTip = 'Show meter view for selected device';
                $scope.pipeconfTip = 'Show pipeconf view for selected device';

                if (params.hasOwnProperty('devId')) {
                    $scope.devId = params['devId'];
                }

                $scope.payloadParams = {
                    nzFilter: nzFilter,
                    showDelta: showDelta,
                };

                tableApi = tbs.buildTable({
                    scope: $scope,
                    tag: 'onlp',
                    query: params,
                });

                function filterToggleState() {
                    return {
                        nzFilter: nzFilter,
                        showDelta: showDelta,
                    };
                }

                $scope.nav = function (path) {
                    if ($scope.devId) {
                        ns.navTo(path, { devId: $scope.devId });
                    }
                };

                function getOperatorFromQuery(query) {

                    var operator = query.split(' '),
                        opFunc = null;

                    if (operator[0] === '>') {
                        opFunc = _.gt;
                    } else if (operator[0] === '>=') {
                        opFunc = _.gte;
                    } else if (operator[0] === '<') {
                        opFunc = _.lt;
                    } else if (operator[0] === '<=') {
                        opFunc = _.lte;
                    } else {
                        return {
                            operator: opFunc,
                            searchText: query,
                        };
                    }

                    return {
                        operator: opFunc,
                        searchText: operator[1],
                    };
                }

                $scope.customFilter = function (prop, val) {
                    if (!val) {
                        return;
                    }

                    var search = getOperatorFromQuery(val),
                        operator = search.operator,
                        searchText = search.searchText;

                    if (operator) {
                        return function (row) {
                            var queryBy = $scope.queryBy || '$';

                            if (queryBy !== '$') {
                                var rowValue = parseInt(row[$scope.queryBy].replace(/,/g, ''));
                                return operator(rowValue, parseInt(searchText)) ? row : null;
                            } else {
                                var keys = _.keysIn(row);

                                for (var i = 0, l = keys.length; i < l; i++) {
                                    var rowValue = parseInt(row[keys[i]].replace(/,/g, ''));
                                    if (operator(rowValue, parseInt(searchText))) {
                                        return row;
                                    }
                                }
                            }
                        };
                    } else {
                        var out = {};
                        out[$scope.queryBy || '$'] = $scope.query;
                        return out;
                    }
                };

                restoreConfigFromPrefs();

                $scope.$on('$destroy', function () {
                    dps.destroy();
                });

                $log.log('OvOnlpCtrl has been created');
            }]);
}());


text:
package io.crnk.gen.typescript.model;

import org.junit.Assert;
import org.junit.Test;

public class TSFunctionTest {

	@Test
	public void notAField() {
		TSFunction function = new TSFunction();
		Assert.assertFalse(function.isField());
	}

	@Test(expected = UnsupportedOperationException.class)
	public void cannotCastToField() {
		TSFunction function = new TSFunction();
		function.asField();
	}
}


text:
'use strict';

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports["default"] = serializeURL;

var _is = _interopRequireDefault(require("@valkyriestudios/utils/is"));

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }

//  Serialize a key-value pair object into a query string
//  e.g : {a:1,b:2} => 'a=1&b=2'
function serializeQueryParameters(params) {
  if (_is["default"].Object(params)) {
    return Object.keys(params).reduce(function (acc, key) {
      acc.push("".concat(encodeURIComponent(key), "=").concat(encodeURIComponent(params[key])));
      return acc;
    }, []).join('&');
  } else if (_is["default"].String(params)) {
    return params.trim();
  } else {
    throw new TypeError('Net:serializeURL expects params option to be either a string or an object');
  }
}

function serializeURL(url, options, NET_CONFIG) {
  //  Check for possibly configured querystring parameters
  var params = Object.prototype.hasOwnProperty.call(options, 'params') ? options.params : NET_CONFIG.params; //  Check for possibly configured base domain (e.g: https://www.google.com)

  var base = Object.prototype.hasOwnProperty.call(options, 'base') ? options.base : NET_CONFIG.base; //  Build base url

  var serialized_url = "".concat(base ? base : '').concat(url); //  Add possible query string parameters to url

  if (params) {
    serialized_url = "".concat(serialized_url.trim(), "?").concat(serializeQueryParameters(params));
  }

  return serialized_url;
}


text:
package Net::LDAP::Control::EntryChange;

use vars qw(@ISA $VERSION);
use Net::LDAP::Control;

@ISA = qw(Net::LDAP::Control);
$VERSION = "0.01";

use Net::LDAP::ASN qw(EntryChangeNotification);
use strict;

sub init {
  my($self) = @_;

  delete $self->{asn};

  unless (exists $self->{value}) {
    $self->{asn} = {
      changeTypes  => $self->{changeType} || '0',
      previousDN   => $self->{previousDN} || '',
      changeNumber => $self->{changeNumber} || '0',
    };
  }

  $self;
}

sub changeType {
  my $self = shift;
  $self->{asn} ||= $EntryChangeNotification->decode($self->{value});
  if (@_) {
    delete $self->{value};
    return $self->{asn}{changeType} = shift || 0;
  }
  $self->{asn}{changeType};
}

sub previousDN {
  my $self = shift;
  $self->{asn} ||= $EntryChangeNotification->decode($self->{value});
  if (@_) {
    delete $self->{value};
    return $self->{asn}{previousDN} = shift || '';
  }
  $self->{asn}{previousDN};
}

sub changeNumber {
  my $self = shift;
  $self->{asn} ||= $EntryChangeNotification->decode($self->{value});
  if (@_) {
    delete $self->{value};
    return $self->{asn}{changeNumber} = shift || 0;
  }
  $self->{asn}{changeNumber};
}

sub value {
  my $self = shift;

  exists $self->{value}
    ? $self->{value}
    : $self->{value} = $EntryChangeNotification->encode($self->{asn});
}

1;

__END__

=head1 NAME

Net::LDAP::Control::EntryChange - LDAPv3 Entry Change Notification control object

=head1 SYNOPSIS

 use Net::LDAP;
 use Net::LDAP::Control::PersistentSearch;
 use Net::LDAP::Constant qw(LDAP_CONTROL_ENTRYCHANGE);

 $ldap = Net::LDAP->new( "ldap.mydomain.eg" );

 $persist = Net::LDAP::Control::PersistentSearch->new( changeTypes => 15,
                                                       changesOnly => 1,
                                                       returnECs => 1 );

 $srch = $ldap->search( base     => "cn=People,dc=mydomain,dc=eg",
                        filter   => "(objectClass=person)",
                        callback => \&process_entry, # call for each entry
                        control  => [ $persist ] );

 die "error: ",$srch->code(),": ",$srch->error()  if ($srch->code());

 sub process_entry {
   my $message = shift;
   my $entry = shift;
   my ($control) = $message->control(LDAP_CONTROL_ENTRYCHANGE);

   print $control->changeType()."\t".$entry->dn()."\n";
 }

=head1 DESCRIPTION

C<Net::LDAP::Control::EntryChange> provides an interface for the creation
and manipulation of objects that represent the C<EntryChangeNotification>
control as described by draft-smith-psearch-ldap-01.txt.

=head1 CONSTRUCTOR ARGUMENTS

In addition to the constructor arguments described in
L<Net::LDAP::Control> the following are provided.

=over 4

=item changeType

An integer value telling the type of LDAP operation that the entry
has undergone.
It is one of the following values (which represent the LDAP
operations indicated next to them):

=over 4

=item 1 = add

=item 2 = delete

=item 4 = modify

=item 8 = modDN

=back

=item previousDN

When changeType is 8 (for modDN) this parameter tells the entry's DN
before the modDN operation.
In all other cases this value is not defined.

=item changeNumber

This is the change number according to <draft-good-ldap-changelog-03.txt>
assigned by a server for the change.  If a server supports an LDAP
Change Log it should include this field.

=back

Usually you do not need to create a C<Net::LDAP::Control::EntryChange>
control yourself because it is provided by the server in response to
an option with the C<Net::LDAP::Control::PersistentSearch> control.

=head1 METHODS

As with L<Net::LDAP::Control> each constructor argument
described above is also available as a method on the object which will
return the current value for the attribute if called without an argument,
and set a new value for the attribute if called with an argument.

=head1 SEE ALSO

L<Net::LDAP>,
L<Net::LDAP::Control>,
L<Net::LDAP::Control::PersistentSearch>

=head1 AUTHOR

Peter Marschall E<lt>peter@adpm.deE<gt>, based on Net::LDAP::Control::Page
from Graham Barr E<lt>gbarr@pobox.comE<gt> and the preparatory work
of Don Miller E<lt>donm@uidaho.eduE<gt>.

Please report any bugs, or post any suggestions, to the perl-ldap
mailing list E<lt>perl-ldap@perl.orgE<gt>

=head1 COPYRIGHT

Copyright (c) 2004 Peter Marschall. All rights reserved. This program is
free software; you can redistribute it and/or modify it under the same
terms as Perl itself.

=cut


text:
//
//  EAThemeManager.h
//  EAThemeSample
//
//  Created by Eiwodetianna on 16/5/17.
//  Copyright © 2016年 Eiwodetianna. All rights reserved.
//

#import <Foundation/Foundation.h>

/**
 *  主题改变的监听事件
 */
FOUNDATION_EXPORT NSString *const kEAChangeThemeNotification;

@interface EAThemeManager : NSObject

// 设置正常状态下的主题标示(ps:必须设置)
@property (nonatomic, copy) NSString *normalThemeIdentifier;

// 获取当前程序采用的主题的标示
@property (nonatomic,readonly,copy) NSString *currentThemeIdentifier;

+ (EAThemeManager *)shareManager;

/**
 *  展示某个主题
 *
 *  @param identifier 需要展示的主题的标示
 */
- (void)displayThemeContentsWithThemeIdentifier:(NSString *)identifier;

@end


text:
<?php

class AW_Blog_Block_Manage_Blog_Edit_Tab_Options extends Mage_Adminhtml_Block_Widget_Form
{
    protected function _prepareForm()
    {
        $form = new Varien_Data_Form();
        $this->setForm($form);
        $fieldset = $form->addFieldset('blog_form', array('legend' => Mage::helper('blog')->__('Meta Data')));

        $fieldset->addField(
            'meta_keywords',
            'editor',
            array(
                 'name'  => 'meta_keywords',
                 'label' => Mage::helper('blog')->__('Keywords'),
                 'title' => Mage::helper('blog')->__('Meta Keywords'),
                 'style' => 'width: 520px;',
            )
        );

        $fieldset->addField(
            'meta_description',
            'editor',
            array(
                 'name'  => 'meta_description',
                 'label' => Mage::helper('blog')->__('Description'),
                 'title' => Mage::helper('blog')->__('Meta Description'),
                 'style' => 'width: 520px;',
            )
        );

        $fieldset = $form->addFieldset(
            'blog_options', array('legend' => Mage::helper('blog')->__('Advanced Post Options'))
        );

        $fieldset->addField(
            'user',
            'text',
            array(
                 'label'              => Mage::helper('blog')->__('Poster'),
                 'name'               => 'user',
                 'style'              => 'width: 520px;',
                 'after_element_html' => ''
                     . Mage::helper('blog')->__('Leave blank to use current user name')
                     . '',
            )
        );

        $outputFormat = Mage::app()->getLocale()->getDateTimeFormat(Mage_Core_Model_Locale::FORMAT_TYPE_MEDIUM);

        $fieldset->addField(
            'created_time',
            'date',
            array(
                 'name'   => 'created_time',
                 'label'  => $this->__('Created on'),
                 'title'  => $this->__('Created on'),
                 'image'  => $this->getSkinUrl('images/grid-cal.gif'),
                 'format' => $outputFormat,
                 'time'   => true,
            )
        );

        if (Mage::getSingleton('adminhtml/session')->getBlogData()) {
            $form->setValues(Mage::getSingleton('adminhtml/session')->getBlogData());
            Mage::getSingleton('adminhtml/session')->setBlogData(null);
        } elseif ($data = Mage::registry('blog_data')) {
            $form->setValues(Mage::registry('blog_data')->getData());
            if ($data->getData('created_time')) {
                $form->getElement('created_time')->setValue(
                    Mage::app()->getLocale()->date(
                        $data->getData('created_time'), Varien_Date::DATETIME_INTERNAL_FORMAT
                    )
                );
            }
        }

        return parent::_prepareForm();
    }
}


text:
<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:tools="http://schemas.android.com/tools"
    android:layout_width="match_parent"
    android:layout_height="wrap_content"
    android:orientation="vertical">

    <LinearLayout
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:background="@android:color/white"
        android:orientation="vertical">

        <LinearLayout
            android:layout_width="match_parent"
            android:layout_height="wrap_content"
            android:layout_marginTop="16dp"
            android:paddingLeft="16dp"
            android:paddingRight="16dp"
            android:gravity="center_vertical"
            android:orientation="horizontal">

            <de.hdodenhof.circleimageview.CircleImageView
                android:id="@+id/topic_item_reply_img_avatar"
                android:layout_width="44dp"
                android:layout_height="44dp"
                android:src="@drawable/image_default" />

            <LinearLayout
                android:layout_width="wrap_content"
                android:layout_height="wrap_content"
                android:layout_marginStart="16dp"
                android:layout_marginLeft="16dp"
                android:orientation="vertical">

                <TextView
                    android:id="@+id/topic_item_reply_tv_login_name"
                    android:layout_width="match_parent"
                    android:layout_height="wrap_content"
                    android:textColor="@color/text_color_primary"
                    android:textSize="16sp"
                    tools:text="TakWolf" />

                <LinearLayout
                    android:layout_width="wrap_content"
                    android:layout_height="wrap_content"
                    android:layout_marginTop="4dp"
                    android:orientation="horizontal">

                    <TextView
                        android:id="@+id/topic_item_reply_tv_index"
                        android:layout_width="wrap_content"
                        android:layout_height="wrap_content"
                        android:textColor="@color/color_accent"
                        android:textSize="14sp"
                        android:singleLine="true"
                        tools:text="1楼" />

                    <TextView
                        android:layout_width="wrap_content"
                        android:layout_height="wrap_content"
                        android:layout_marginLeft="4dp"
                        android:layout_marginRight="4dp"
                        android:text="@string/$dot"
                        android:textColor="@color/text_color_secondary"
                        android:textSize="14sp"
                        android:singleLine="true" />

                    <TextView
                        android:id="@+id/topic_item_reply_tv_create_time"
                        android:layout_width="wrap_content"
                        android:layout_height="wrap_content"
                        android:textColor="@color/text_color_secondary"
                        android:textSize="14sp"
                        android:singleLine="true"
                        tools:text="1小时前" />

                </LinearLayout>

            </LinearLayout>

            <LinearLayout
                android:layout_width="match_parent"
                android:layout_height="wrap_content"
                android:gravity="end"
                android:orientation="horizontal">

                <TextView
                    android:id="@+id/topic_item_reply_btn_ups"
                    android:layout_width="wrap_content"
                    android:layout_height="wrap_content"
                    android:padding="8dp"
                    android:drawableStart="@drawable/main_nav_ic_good_grey_24dp"
                    android:drawableLeft="@drawable/main_nav_ic_good_grey_24dp"
                    android:drawablePadding="8dp"
                    android:textColor="@color/text_color_secondary"
                    android:textSize="14sp"
                    android:gravity="center"
                    android:background="@drawable/rect_btn_background"
                    tools:text="12" />

                <ImageView
                    android:id="@+id/topic_item_reply_btn_at"
                    android:layout_width="wrap_content"
                    android:layout_height="wrap_content"
                    android:padding="8dp"
                    android:src="@drawable/ic_reply_grey600_24dp"
                    android:scaleType="center"
                    android:background="@drawable/rect_btn_background" />

            </LinearLayout>

        </LinearLayout>

        <us.feras.mdv.MarkdownView
            android:id="@+id/topic_item_reply_web_content"
            android:layout_width="match_parent"
            android:layout_height="wrap_content"
            android:layout_marginTop="8dp"
            android:layout_marginBottom="16dp"
            android:layout_marginLeft="16dp"
            android:layout_marginRight="16dp" />

    </LinearLayout>

    <View style="@style/AppTheme.DeepLine"
        android:id="@+id/topic_item_reply_icon_deep_line" />

    <View style="@style/AppTheme.ShadowGap"
        android:id="@+id/topic_item_reply_icon_shadow_gap" />

</LinearLayout>


text:
package apply

import (
	"context"
	"encoding/json"
	"fmt"

	"k8s.io/utils/pointer"

	"kubevirt.io/client-go/kubecli"

	"github.com/openshift/library-go/pkg/operator/resource/resourcemerge"
	appsv1 "k8s.io/api/apps/v1"
	corev1 "k8s.io/api/core/v1"
	policyv1 "k8s.io/api/policy/v1"
	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
	"k8s.io/apimachinery/pkg/types"
	"k8s.io/apimachinery/pkg/util/intstr"

	v1 "kubevirt.io/api/core/v1"
	"kubevirt.io/client-go/log"

	"kubevirt.io/kubevirt/pkg/virt-operator/resource/generate/components"
	"kubevirt.io/kubevirt/pkg/virt-operator/util"
)

const (
	failedUpdateDaemonSetReason = "FailedUpdate"
)

var (
	daemonSetDefaultMaxUnavailable = intstr.FromInt(1)
	daemonSetFastMaxUnavailable    = intstr.FromString("10%")
)

type CanaryUpgradeStatus string

const (
	CanaryUpgradeStatusStarted                 CanaryUpgradeStatus = "started"
	CanaryUpgradeStatusUpgradingDaemonSet      CanaryUpgradeStatus = "upgrading daemonset"
	CanaryUpgradeStatusWaitingDaemonSetRollout CanaryUpgradeStatus = "waiting for daemonset rollout"
	CanaryUpgradeStatusSuccessful              CanaryUpgradeStatus = "successful"
	CanaryUpgradeStatusFailed                  CanaryUpgradeStatus = "failed"
)

func (r *Reconciler) syncDeployment(origDeployment *appsv1.Deployment) (*appsv1.Deployment, error) {
	kv := r.kv

	deployment := origDeployment.DeepCopy()

	apps := r.clientset.AppsV1()
	imageTag, imageRegistry, id := getTargetVersionRegistryID(kv)

	injectOperatorMetadata(kv, &deployment.ObjectMeta, imageTag, imageRegistry, id, true)
	injectOperatorMetadata(kv, &deployment.Spec.Template.ObjectMeta, imageTag, imageRegistry, id, false)
	injectPlacementMetadata(kv.Spec.Infra, &deployment.Spec.Template.Spec)

	if kv.Spec.Infra != nil && kv.Spec.Infra.Replicas != nil {
		replicas := int32(*kv.Spec.Infra.Replicas)
		if deployment.Spec.Replicas == nil || *deployment.Spec.Replicas != replicas {
			deployment.Spec.Replicas = &replicas
			r.recorder.Eventf(deployment, corev1.EventTypeWarning, "AdvancedFeatureUse", "applying custom number of infra replica. this is an advanced feature that prevents "+
				"auto-scaling for core kubevirt components. Please use with caution!")
		}
	} else if deployment.Name == components.VirtAPIName {
		replicas, err := getDesiredApiReplicas(r.clientset)
		if err != nil {
			log.Log.Object(deployment).Warningf(err.Error())
		} else {
			deployment.Spec.Replicas = pointer.Int32(replicas)
		}
	}

	obj, exists, _ := r.stores.DeploymentCache.Get(deployment)
	if !exists {
		r.expectations.Deployment.RaiseExpectations(r.kvKey, 1, 0)
		deployment, err := apps.Deployments(kv.Namespace).Create(context.Background(), deployment, metav1.CreateOptions{})
		if err != nil {
			r.expectations.Deployment.LowerExpectations(r.kvKey, 1, 0)
			return nil, fmt.Errorf("unable to create deployment %+v: %v", deployment, err)
		}

		SetGeneration(&kv.Status.Generations, deployment)

		return deployment, nil
	}

	cachedDeployment := obj.(*appsv1.Deployment)
	modified := resourcemerge.BoolPtr(false)
	existingCopy := cachedDeployment.DeepCopy()
	expectedGeneration := GetExpectedGeneration(deployment, kv.Status.Generations)

	resourcemerge.EnsureObjectMeta(modified, &existingCopy.ObjectMeta, deployment.ObjectMeta)

	// there was no change to metadata, the generation matched
	if !*modified &&
		*existingCopy.Spec.Replicas == *deployment.Spec.Replicas &&
		existingCopy.GetGeneration() == expectedGeneration {
		log.Log.V(4).Infof("deployment %v is up-to-date", deployment.GetName())
		return deployment, nil
	}

	newSpec, err := json.Marshal(deployment.Spec)
	if err != nil {
		return nil, err
	}

	ops, err := getPatchWithObjectMetaAndSpec([]string{
		fmt.Sprintf(testGenerationJSONPatchTemplate, cachedDeployment.ObjectMeta.Generation),
	}, &deployment.ObjectMeta, newSpec)
	if err != nil {
		return nil, err
	}

	deployment, err = apps.Deployments(kv.Namespace).Patch(context.Background(), deployment.Name, types.JSONPatchType, generatePatchBytes(ops), metav1.PatchOptions{})
	if err != nil {
		return nil, fmt.Errorf("unable to update deployment %+v: %v", deployment, err)
	}

	SetGeneration(&kv.Status.Generations, deployment)
	log.Log.V(2).Infof("deployment %v updated", deployment.GetName())

	return deployment, nil
}

func setMaxUnavailable(daemonSet *appsv1.DaemonSet, maxUnavailable intstr.IntOrString) {
	daemonSet.Spec.UpdateStrategy.RollingUpdate = &appsv1.RollingUpdateDaemonSet{
		MaxUnavailable: &maxUnavailable,
	}
}

func generateDaemonSetPatch(oldDs, newDs *appsv1.DaemonSet) ([]byte, error) {
	newSpec, err := json.Marshal(newDs.Spec)
	if err != nil {
		return nil, err
	}

	ops, err := getPatchWithObjectMetaAndSpec([]string{
		fmt.Sprintf(testGenerationJSONPatchTemplate, oldDs.ObjectMeta.Generation),
	}, &newDs.ObjectMeta, newSpec)
	if err != nil {
		return nil, err
	}
	return generatePatchBytes(ops), nil
}

func (r *Reconciler) patchDaemonSet(oldDs, newDs *appsv1.DaemonSet) (*appsv1.DaemonSet, error) {
	patch, err := generateDaemonSetPatch(oldDs, newDs)
	if err != nil {
		return nil, err
	}

	newDs, err = r.clientset.AppsV1().DaemonSets(r.kv.Namespace).Patch(
		context.Background(),
		newDs.Name,
		types.JSONPatchType,
		patch,
		metav1.PatchOptions{})
	if err != nil {
		return nil, fmt.Errorf("unable to update daemonset %+v: %v", oldDs, err)
	}
	return newDs, nil
}

func (r *Reconciler) getCanaryPods(daemonSet *appsv1.DaemonSet) []*corev1.Pod {
	canaryPods := []*corev1.Pod{}

	for _, obj := range r.stores.InfrastructurePodCache.List() {
		pod := obj.(*corev1.Pod)
		owner := metav1.GetControllerOf(pod)

		if owner != nil && owner.Name == daemonSet.Name && util.PodIsUpToDate(pod, r.kv) {
			canaryPods = append(canaryPods, pod)
		}
	}
	return canaryPods
}

func (r *Reconciler) howManyUpdatedAndReadyPods(daemonSet *appsv1.DaemonSet) int32 {
	var updatedReadyPods int32

	for _, obj := range r.stores.InfrastructurePodCache.List() {
		pod := obj.(*corev1.Pod)
		owner := metav1.GetControllerOf(pod)

		if owner != nil && owner.Name == daemonSet.Name && util.PodIsUpToDate(pod, r.kv) && util.PodIsReady(pod) {
			updatedReadyPods++
		}
	}
	return updatedReadyPods
}

func daemonHasDefaultRolloutStrategy(daemonSet *appsv1.DaemonSet) bool {
	return getMaxUnavailable(daemonSet) == daemonSetDefaultMaxUnavailable.IntValue()
}

func (r *Reconciler) processCanaryUpgrade(cachedDaemonSet, newDS *appsv1.DaemonSet, forceUpdate bool) (bool, error, CanaryUpgradeStatus) {
	var updatedAndReadyPods int32
	var status CanaryUpgradeStatus
	done := false

	isDaemonSetUpdated := util.DaemonSetIsUpToDate(r.kv, cachedDaemonSet) && !forceUpdate
	desiredReadyPods := cachedDaemonSet.Status.DesiredNumberScheduled
	if isDaemonSetUpdated {
		updatedAndReadyPods = r.howManyUpdatedAndReadyPods(cachedDaemonSet)
	}

	switch {
	case updatedAndReadyPods == 0:
		if !isDaemonSetUpdated {
			// start canary upgrade
			setMaxUnavailable(newDS, daemonSetDefaultMaxUnavailable)
			_, err := r.patchDaemonSet(cachedDaemonSet, newDS)
			if err != nil {
				return false, fmt.Errorf("unable to start canary upgrade for daemonset %+v: %v", newDS, err), CanaryUpgradeStatusFailed
			}
		} else {
			// check for a crashed canary pod
			canaryPods := r.getCanaryPods(cachedDaemonSet)
			for _, canary := range canaryPods {
				if canary != nil && util.PodIsCrashLooping(canary) {
					r.recorder.Eventf(cachedDaemonSet, corev1.EventTypeWarning, failedUpdateDaemonSetReason, "daemonSet %v rollout failed", cachedDaemonSet.Name)
					return false, fmt.Errorf("daemonSet %s rollout failed", cachedDaemonSet.Name), CanaryUpgradeStatusFailed
				}
			}
		}
		done, status = false, CanaryUpgradeStatusStarted
	case updatedAndReadyPods > 0 && updatedAndReadyPods < desiredReadyPods:
		if daemonHasDefaultRolloutStrategy(cachedDaemonSet) {
			// canary was ok, start real rollout
			setMaxUnavailable(newDS, daemonSetFastMaxUnavailable)
			// start rollout again
			_, err := r.patchDaemonSet(cachedDaemonSet, newDS)
			if err != nil {
				return false, fmt.Errorf("unable to update daemonset %+v: %v", newDS, err), CanaryUpgradeStatusFailed
			}
			log.Log.V(2).Infof("daemonSet %v updated", newDS.GetName())
			status = CanaryUpgradeStatusUpgradingDaemonSet
		} else {
			log.Log.V(4).Infof("waiting for all pods of daemonSet %v to be ready", newDS.GetName())
			status = CanaryUpgradeStatusWaitingDaemonSetRollout
		}
		done = false
	case updatedAndReadyPods > 0 && updatedAndReadyPods == desiredReadyPods:
		// rollout has completed and all virt-handlers are ready
		// revert maxUnavailable to default value
		setMaxUnavailable(newDS, daemonSetDefaultMaxUnavailable)
		newDS, err := r.patchDaemonSet(cachedDaemonSet, newDS)
		if err != nil {
			return false, err, CanaryUpgradeStatusFailed
		}
		SetGeneration(&r.kv.Status.Generations, newDS)
		log.Log.V(2).Infof("daemonSet %v is ready", newDS.GetName())
		done, status = true, CanaryUpgradeStatusSuccessful
	}
	return done, nil, status
}

func getMaxUnavailable(daemonSet *appsv1.DaemonSet) int {
	update := daemonSet.Spec.UpdateStrategy.RollingUpdate

	if update == nil {
		return 0
	}
	if update.MaxUnavailable != nil {
		return update.MaxUnavailable.IntValue()
	}
	return daemonSetDefaultMaxUnavailable.IntValue()
}

func (r *Reconciler) syncDaemonSet(daemonSet *appsv1.DaemonSet) (bool, error) {
	kv := r.kv

	daemonSet = daemonSet.DeepCopy()

	apps := r.clientset.AppsV1()
	imageTag, imageRegistry, id := getTargetVersionRegistryID(kv)

	injectOperatorMetadata(kv, &daemonSet.ObjectMeta, imageTag, imageRegistry, id, true)
	injectOperatorMetadata(kv, &daemonSet.Spec.Template.ObjectMeta, imageTag, imageRegistry, id, false)
	injectPlacementMetadata(kv.Spec.Workloads, &daemonSet.Spec.Template.Spec)

	if daemonSet.GetName() == "virt-handler" {
		setMaxDevices(r.kv, daemonSet)
	}

	var cachedDaemonSet *appsv1.DaemonSet
	obj, exists, _ := r.stores.DaemonSetCache.Get(daemonSet)

	if !exists {
		r.expectations.DaemonSet.RaiseExpectations(r.kvKey, 1, 0)
		daemonSet, err := apps.DaemonSets(kv.Namespace).Create(context.Background(), daemonSet, metav1.CreateOptions{})
		if err != nil {
			r.expectations.DaemonSet.LowerExpectations(r.kvKey, 1, 0)
			return false, fmt.Errorf("unable to create daemonset %+v: %v", daemonSet, err)
		}

		SetGeneration(&kv.Status.Generations, daemonSet)
		return true, nil
	}

	cachedDaemonSet = obj.(*appsv1.DaemonSet)
	modified := resourcemerge.BoolPtr(false)
	existingCopy := cachedDaemonSet.DeepCopy()
	expectedGeneration := GetExpectedGeneration(daemonSet, kv.Status.Generations)

	resourcemerge.EnsureObjectMeta(modified, &existingCopy.ObjectMeta, daemonSet.ObjectMeta)
	// there was no change to metadata, the generation was right
	if !*modified && existingCopy.GetGeneration() == expectedGeneration {
		log.Log.V(4).Infof("daemonset %v is up-to-date", daemonSet.GetName())
		return true, nil
	}

	// canary pod upgrade
	// first update virt-handler with maxUnavailable=1
	// patch daemonSet with new version
	// wait for a new virt-handler to be ready
	// set maxUnavailable=10%
	// start the rollout of the new virt-handler again
	// wait for all nodes to complete the rollout
	// set maxUnavailable back to 1
	done, err, _ := r.processCanaryUpgrade(cachedDaemonSet, daemonSet, *modified)
	return done, err
}

func setMaxDevices(kv *v1.KubeVirt, vh *appsv1.DaemonSet) {
	if kv.Spec.Configuration.VirtualMachineInstancesPerNode == nil {
		return
	}

	vh.Spec.Template.Spec.Containers[0].Command = append(vh.Spec.Template.Spec.Containers[0].Command,
		"--max-devices",
		fmt.Sprintf("%d", *kv.Spec.Configuration.VirtualMachineInstancesPerNode))
}

func (r *Reconciler) syncPodDisruptionBudgetForDeployment(deployment *appsv1.Deployment) error {
	kv := r.kv
	podDisruptionBudget := components.NewPodDisruptionBudgetForDeployment(deployment)

	imageTag, imageRegistry, id := getTargetVersionRegistryID(kv)
	injectOperatorMetadata(kv, &podDisruptionBudget.ObjectMeta, imageTag, imageRegistry, id, true)

	pdbClient := r.clientset.PolicyV1().PodDisruptionBudgets(deployment.Namespace)

	var cachedPodDisruptionBudget *policyv1.PodDisruptionBudget
	obj, exists, _ := r.stores.PodDisruptionBudgetCache.Get(podDisruptionBudget)

	if podDisruptionBudget.Spec.MinAvailable.IntValue() == 0 {
		var err error
		if exists {
			err = pdbClient.Delete(context.Background(), podDisruptionBudget.Name, metav1.DeleteOptions{})
		}
		return err
	}

	if !exists {
		r.expectations.PodDisruptionBudget.RaiseExpectations(r.kvKey, 1, 0)
		podDisruptionBudget, err := pdbClient.Create(context.Background(), podDisruptionBudget, metav1.CreateOptions{})
		if err != nil {
			r.expectations.PodDisruptionBudget.LowerExpectations(r.kvKey, 1, 0)
			return fmt.Errorf("unable to create poddisruptionbudget %+v: %v", podDisruptionBudget, err)
		}
		log.Log.V(2).Infof("poddisruptionbudget %v created", podDisruptionBudget.GetName())
		SetGeneration(&kv.Status.Generations, podDisruptionBudget)

		return nil
	}

	cachedPodDisruptionBudget = obj.(*policyv1.PodDisruptionBudget)
	modified := resourcemerge.BoolPtr(false)
	existingCopy := cachedPodDisruptionBudget.DeepCopy()
	expectedGeneration := GetExpectedGeneration(podDisruptionBudget, kv.Status.Generations)

	resourcemerge.EnsureObjectMeta(modified, &existingCopy.ObjectMeta, podDisruptionBudget.ObjectMeta)
	// there was no change to metadata or minAvailable, the generation was right
	if !*modified &&
		existingCopy.Spec.MinAvailable.IntValue() == podDisruptionBudget.Spec.MinAvailable.IntValue() &&
		existingCopy.ObjectMeta.Generation == expectedGeneration {
		log.Log.V(4).Infof("poddisruptionbudget %v is up-to-date", cachedPodDisruptionBudget.GetName())
		return nil
	}

	// Add Spec Patch
	newSpec, err := json.Marshal(podDisruptionBudget.Spec)
	if err != nil {
		return err
	}

	ops, err := getPatchWithObjectMetaAndSpec([]string{}, &podDisruptionBudget.ObjectMeta, newSpec)
	if err != nil {
		return err
	}

	podDisruptionBudget, err = pdbClient.Patch(context.Background(), podDisruptionBudget.Name, types.JSONPatchType, generatePatchBytes(ops), metav1.PatchOptions{})
	if err != nil {
		return fmt.Errorf("unable to patch/delete poddisruptionbudget %+v: %v", podDisruptionBudget, err)
	}

	SetGeneration(&kv.Status.Generations, podDisruptionBudget)
	log.Log.V(2).Infof("poddisruptionbudget %v patched", podDisruptionBudget.GetName())

	return nil
}

func getDesiredApiReplicas(clientset kubecli.KubevirtClient) (replicas int32, err error) {
	nodeList, err := clientset.CoreV1().Nodes().List(context.Background(), metav1.ListOptions{})
	if err != nil {
		return 0, fmt.Errorf("failed to get number of nodes to determine virt-api replicas: %v", err)
	}

	nodesCount := len(nodeList.Items)
	// This is a simple heuristic to achieve basic scalability so we could be running on large clusters.
	// From recent experiments we know that for a 100 nodes cluster, 9 virt-api replicas are enough.
	// This heuristic is not accurate. It could, and should, be replaced by something more sophisticated and refined
	// in the future.

	if nodesCount == 1 {
		return 1, nil
	}

	const minReplicas = 2

	replicas = int32(nodesCount) / 10
	if replicas < minReplicas {
		replicas = minReplicas
	}

	return replicas, nil
}


text:
/* first banner */
/* second banner */
define(function () { 'use strict';

	console.log( 1 + 1 );

});
/* first footer */
/* second footer */


text:
package org.knowm.xchange.ccex.dto.trade;

import com.fasterxml.jackson.annotation.JsonProperty;

public class CCEXUUIDResponse {

	private String uuid;

	public CCEXUUIDResponse(@JsonProperty("uuid") String uuid) {
		super();
		this.uuid = uuid;
	}

	public String getUuid() {
		return uuid;
	}

	public void setUuid(String uuid) {
		this.uuid = uuid;
	}

	@Override
	public String toString() {
		return "CCEXUUIDResponse [uuid=" + uuid + "]";
	}
}


text:
/* @flow */

'use strict';

var React           = require('react-native');
var _               = require('lodash');
var update          = React.addons.update;
var moment          = require('moment-timezone');
var globalStyles    = require('../lib/globalStyles');
var I18n            = require('../lib/I18n');
var log             = require('../lib/log').logForScope('component.event_upcoming_rsvp');

var {
  PixelRatio,
  StyleSheet,
  Text,
  View,
} = React;

class EventUpcomingRsvpComponent extends React.Component {

  constructor(props) {
    super(props);
    this.state = {};
  }

  render() {
    return (
      <View>
        <View style={styles.rsvpRow}>
          <Text style={[styles.rsvpType, styles.rsvpTypeGoing]}>
            {I18n.t('component.event_upcoming_rsvp.going')}
          </Text>
          <Text style={styles.rsvpTypeCount}>
            {this.props.event.yes_rsvp_count}
          </Text>
        </View>
        <View style={styles.rsvpRow}>
          <Text style={[styles.rsvpType, styles.rsvpTypeWaitingList]}>
            {I18n.t('component.event_upcoming_rsvp.waiting_list')}
          </Text>
          <Text style={styles.rsvpTypeCount}>
            {this.props.event.waitlist_count}
          </Text>
        </View>
        <View style={styles.rsvpRow}>
          <Text style={[styles.rsvpType, styles.rsvpTypeLimit]}>
            {I18n.t('component.event_upcoming_rsvp.available')}
          </Text>
          <Text style={styles.rsvpTypeCount}>
            {this.props.event.rsvp_limit - this.props.event.yes_rsvp_count}
          </Text>
        </View>
      </View>
    );
  }
}

EventUpcomingRsvpComponent.propTypes = {
  event: React.PropTypes.object.isRequired
};

var styles = StyleSheet.create({
  rsvpRow: {
    flexDirection: 'row',
  },
  rsvpType: {
    width: 110,
    fontSize: 10,
  },
  rsvpTypeCount: {
    fontSize: 10,
  },
  rsvpTypeGoing: {
    color: globalStyles.colors.green,
  },
  rsvpTypeLimit: {
    color: globalStyles.colors.greyExtraHard,
  },
  rsvpTypeWaitingList: {
    color: globalStyles.colors.orange,
  }
});

module.exports = EventUpcomingRsvpComponent;


text:
package org.apache.polygene.library.rdf.entity;

import org.apache.polygene.api.common.Optional;
import org.apache.polygene.api.property.Property;
import org.apache.polygene.api.value.ValueComposite;

/**
 * JAVADOC
 */
public interface TestValue extends ValueComposite
{
    Property<Long> test1();

    @Optional Property<String> test2();

    Property<Test2Value> test3();
}


text:
<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    android:orientation="vertical" >

	<TextView
		android:id="@+id/ReplyText"
  		android:layout_width="wrap_content"
   		android:layout_height="wrap_content"
		android:text="Question Text"
		android:textAppearance="?android:attr/textAppearanceSmall"
    	android:scrollbars = "vertical" />

  	<TextView
		android:id="@+id/ReplyAuthor"
		android:layout_width="wrap_content"
		android:layout_height="wrap_content"
		android:textColor="#888888"
		android:text="Question Author"
		android:textAppearance="?android:attr/textAppearanceSmall" />

	<TextView
		android:id="@+id/ReplyDate"
		android:layout_width="wrap_content"
		android:layout_height="wrap_content"
		android:textColor="#888888"
		android:text="Question Date"
		android:textAppearance="?android:attr/textAppearanceSmall" />

</LinearLayout>


text:
using System;
using System.Collections.Generic;
using System.Data;
using System.Data.Entity;
using System.Linq;
using System.Threading.Tasks;
using System.Net;
using System.Web;
using System.Web.Mvc;
using RentFlat.Model;

namespace RentFlat.Web.Controllers
{
    public class CountriesController : Controller
    {
        private ApplicationDbContext db = new ApplicationDbContext();

        // GET: Countries
        public async Task<ActionResult> Index()
        {
            return View(await db.Countries.ToListAsync());
        }

        // GET: Countries/Details/5
        public async Task<ActionResult> Details(int? id)
        {
            if (id == null)
            {
                return new HttpStatusCodeResult(HttpStatusCode.BadRequest);
            }
            Country country = await db.Countries.FindAsync(id);
            if (country == null)
            {
                return HttpNotFound();
            }
            return View(country);
        }

        // GET: Countries/Create
        public ActionResult Create()
        {
            return View();
        }

        // POST: Countries/Create
        // To protect from overposting attacks, please enable the specific properties you want to bind to, for
        // more details see http://go.microsoft.com/fwlink/?LinkId=317598.
        [HttpPost]
        [ValidateAntiForgeryToken]
        public async Task<ActionResult> Create([Bind(Include = "ID,CountryName")] Country country)
        {
            if (ModelState.IsValid)
            {
                db.Countries.Add(country);
                await db.SaveChangesAsync();
                return RedirectToAction("Index");
            }

            return View(country);
        }

        // GET: Countries/Edit/5
        public async Task<ActionResult> Edit(int? id)
        {
            if (id == null)
            {
                return new HttpStatusCodeResult(HttpStatusCode.BadRequest);
            }
            Country country = await db.Countries.FindAsync(id);
            if (country == null)
            {
                return HttpNotFound();
            }
            return View(country);
        }

        // POST: Countries/Edit/5
        // To protect from overposting attacks, please enable the specific properties you want to bind to, for
        // more details see http://go.microsoft.com/fwlink/?LinkId=317598.
        [HttpPost]
        [ValidateAntiForgeryToken]
        public async Task<ActionResult> Edit([Bind(Include = "ID,CountryName")] Country country)
        {
            if (ModelState.IsValid)
            {
                db.Entry(country).State = EntityState.Modified;
                await db.SaveChangesAsync();
                return RedirectToAction("Index");
            }
            return View(country);
        }

        // GET: Countries/Delete/5
        public async Task<ActionResult> Delete(int? id)
        {
            if (id == null)
            {
                return new HttpStatusCodeResult(HttpStatusCode.BadRequest);
            }
            Country country = await db.Countries.FindAsync(id);
            if (country == null)
            {
                return HttpNotFound();
            }
            return View(country);
        }

        // POST: Countries/Delete/5
        [HttpPost, ActionName("Delete")]
        [ValidateAntiForgeryToken]
        public async Task<ActionResult> DeleteConfirmed(int id)
        {
            Country country = await db.Countries.FindAsync(id);
            db.Countries.Remove(country);
            await db.SaveChangesAsync();
            return RedirectToAction("Index");
        }

        protected override void Dispose(bool disposing)
        {
            if (disposing)
            {
                db.Dispose();
            }
            base.Dispose(disposing);
        }
    }
}