text:
import Component from '@ember/component';
import { action } from '@ember/object';
import { layout as templateLayout, tagName } from '@ember-decorators/component';
import layout from '../templates/components/liquid-append';

import $ from 'jquery';

@tagName('')
@templateLayout(layout)
export default class LiquidAppend extends Component {
  @action
  _didUpdate(element) {
    if (this.replaceNodes) {
      const nodes = this.nodes;

      $(element).children().remove();
      $(element).append(nodes);
    }
  }

  @action
  _didInsert(element) {
    const notify = this.notify;
    const nodes = this.nodes;

    if (notify && notify.willAppendNodes) {
      notify.willAppendNodes(element);
    }

    $(element).append(nodes);

    if (notify && notify.didAppendNodes) {
      notify.didAppendNodes(element);
    }
  }
}


text:
import imgflipperapi = require('imgflipper');

export class MemeCaptionService {
    private username: string;
    private password: string;
    private imgflipper;

    constructor()
    {
        // Don't be an ass.  Get your own creds.
        this.username = "GeorgeMatthews";
        this.password = "aoX8rZfIk27869v";
        this.imgflipper = new imgflipperapi(this.username, this.password);
    }

    /// wrapper for meme creation
    public GenerateResultForMemeCreate(memetype: number, toptext: string, bottomtext: string, callback: (return_url)=> void)
    {
        this.imgflipper.generateMeme(memetype, toptext, bottomtext, (err, url) => {
          callback(url);
        });
    }

}

redpajama_set_name: RedPajamaGithub


text:
Legend is used to map entities to a character so they can be used in the game.

Example:
```
myLegend.set('A', Animal);
```
Allows us to place `A` on the map and the simulation will understand that it is an `Animal`.

# Legend(legendMap)

Legend constructor

## Legend.prototype.set(character, entityConstructor)

Sets property `character` to value `entityConstructor`

### Parameters

- character: the property name to set the value for.
- entityConstructor: the value for the property name.

## Legend.prototype.get(character)

Returns the value for the property named `character`.

### Parameters

- character: the property name to get the value for.

### Returns

- the value of the property.


text:
@implementation Person

- (id)init
{
	[super init];
	expectedRaise = 5.0;
	personName = @"New Person";
	return self;
}

- (id)initWithCoder:(NSCoder *)coder
{
	[super init];
	personName = [[coder decodeObjectForKey:@"personName"] retain];
	expectedRaise = [coder decodeFloatForKey:@"expectedRaise"];
	return self;
}

- (void)setNilValueForKey:(NSString *)key
{
	if ([key  isEqual:@"expectedRaise"]){
		[self setExpectedRaise:0.0];
	}else{
		[super setNilValueForKey:key];
	}
}

//encoding questions
- (void)encodeWithCoder:(NSCoder *)coder
{
	[coder encodeObject:personName forKey:@"personName"];
	[coder encodeFloat:expectedRaise forKey:@"expectedRaise"];
}

- (void)dealloc
{
	[personName release];
	[super dealloc];
}

@synthesize personName;
@synthesize expectedRaise;
@end


text:
package com.rex.secretSanta;

public class ArrayList2d {

}


text:
Diggler [![dub](https://img.shields.io/dub/v/dirk.svg)](http://code.dlang.org/packages/diggler)
============================================
Diggler is an IRC bot framework for the D programming language.

**Please report bugs and requests to the [issue tracker](https://github.com/JakobOvrum/Diggler/issues). Thanks!**

Directory Structure
============================================

 * `src` - the Diggler source files.
 * `visuald` - [VisualD](http://www.dsource.org/projects/visuald) project files.
 * `lib` - Diggler library files (when built).

Dependencies
============================================
Diggler depends on [Dirk](https://github.com/JakobOvrum/Dirk) which depends on [libev](http://software.schmorp.de/pkg/libev.html). For Debian and deriviates, that's the `libev-dev` package.

[Documentation](http://jakobovrum.github.io/Diggler/)
============================================
You can find automatically generated documentation on the [gh-pages](https://github.com/JakobOvrum/Diggler/tree/gh-pages) branch, or you can [browse it online](http://jakobovrum.github.io/Diggler/).

License
============================================
Diggler is licensed under the terms of the MIT license (see the [LICENSE file](http://github.com/JakobOvrum/Diggler/blob/master/LICENSE) for details).


text: inspec rules to test ursula for compliance


text:
namespace boost {
namespace histogram {
namespace detail {

using std::data;
using std::size;

} // namespace detail
} // namespace histogram
} // namespace boost

#else // std implementations are not available

#include <initializer_list>
#include <type_traits>

namespace boost {
namespace histogram {
namespace detail {

template <class C>
constexpr auto data(C& c) -> decltype(c.data()) {
  return c.data();
}

template <class C>
constexpr auto data(const C& c) -> decltype(c.data()) {
  return c.data();
}

template <class T, std::size_t N>
constexpr T* data(T (&array)[N]) noexcept {
  return array;
}

template <class E>
constexpr const E* data(std::initializer_list<E> il) noexcept {
  return il.begin();
}

template <class C>
constexpr auto size(const C& c) -> decltype(c.size()) {
  return c.size();
}

template <class T, std::size_t N>
constexpr std::size_t size(const T (&)[N]) noexcept {
  return N;
}

} // namespace detail
} // namespace histogram
} // namespace boost

#endif

#endif // BOOST_HISTOGRAM_DETAIL_NONMEMBER_CONTAINER_ACCESS_HPP


text:
<?php

namespace ommu\users\models;

use Yii;
use yii\helpers\Html;
use yii\helpers\Url;

class UserHistoryPassword extends \app\components\ActiveRecord
{
	public $gridForbiddenColumn = [];

	public $userDisplayname;
	public $userLevel;
	public $email_search;

	/**
	 * @return string the associated database table name
	 */
	public static function tableName()
	{
		return 'ommu_user_history_password';
	}

	/**
	 * @return array validation rules for model attributes.
	 */
	public function rules()
	{
		return [
			[['user_id', 'password'], 'required'],
			[['user_id'], 'integer'],
			[['password'], 'string', 'max' => 32],
			[['user_id'], 'exist', 'skipOnError' => true, 'targetClass' => Users::className(), 'targetAttribute' => ['user_id' => 'user_id']],
		];
	}

	/**
	 * @return array customized attribute labels (name=>label)
	 */
	public function attributeLabels()
	{
		return [
			'id' => Yii::t('app', 'ID'),
			'user_id' => Yii::t('app', 'User'),
			'password' => Yii::t('app', 'Password'),
			'update_date' => Yii::t('app', 'Update Date'),
			'userDisplayname' => Yii::t('app', 'User'),
			'userLevel' => Yii::t('app', 'Level'),
			'email_search' => Yii::t('app', 'Email'),
		];
	}

	/**
	 * @return \yii\db\ActiveQuery
	 */
	public function getUser()
	{
		return $this->hasOne(Users::className(), ['user_id' => 'user_id']);
	}

	/**
	 * {@inheritdoc}
	 * @return \ommu\users\models\query\UserHistoryPassword the active query used by this AR class.
	 */
	public static function find()
	{
		return new \ommu\users\models\query\UserHistoryPassword(get_called_class());
	}

	/**
	 * Set default columns to display
	 */
	public function init()
	{
        parent::init();

        if (!(Yii::$app instanceof \app\components\Application)) {
            return;
        }

        if (!$this->hasMethod('search')) {
            return;
        }

		$this->templateColumns['_no'] = [
			'header' => '#',
			'class' => 'app\components\grid\SerialColumn',
			'contentOptions' => ['class' => 'text-center'],
		];
		$this->templateColumns['userDisplayname'] = [
			'attribute' => 'userDisplayname',
			'value' => function($model, $key, $index, $column) {
				return isset($model->user) ? $model->user->displayname : '-';
			},
			'visible' => !Yii::$app->request->get('user') ? true : false,
		];
		$this->templateColumns['userLevel'] = [
			'attribute' => 'userLevel',
			'value' => function($model, $key, $index, $column) {
				return isset($model->user) ? $model->user->level->title->message : '-';
			},
			'filter' => UserLevel::getLevel(),
			'visible' => !Yii::$app->request->get('user') ? true : false,
		];
		$this->templateColumns['email_search'] = [
			'attribute' => 'email_search',
			'value' => function($model, $key, $index, $column) {
				return isset($model->user) ? Yii::$app->formatter->asEmail($model->user->email) : '-';
			},
			'format' => 'html',
			'visible' => !Yii::$app->request->get('user') ? true : false,
		];
		$this->templateColumns['password'] = [
			'attribute' => 'password',
			'value' => function($model, $key, $index, $column) {
				return $model->password;
			},
		];
		$this->templateColumns['update_date'] = [
			'attribute' => 'update_date',
			'value' => function($model, $key, $index, $column) {
				return Yii::$app->formatter->asDatetime($model->update_date, 'medium');
			},
			'filter' => $this->filterDatepicker($this, 'update_date'),
		];
	}

	/**
	 * User get information
	 */
	public static function getInfo($id, $column=null)
	{
        if ($column != null) {
            $model = self::find();
            if (is_array($column)) {
                $model->select($column);
            } else {
                $model->select([$column]);
            }
            $model = $model->where(['id' => $id])->one();
            return is_array($column) ? $model : $model->$column;

        } else {
            $model = self::findOne($id);
            return $model;
        }
	}

	/**
	 * before validate attributes
	 */
	public function beforeValidate()
	{
        if (parent::beforeValidate()) {
            if ($this->isNewRecord) {
                if ($this->user_id == null) {
                    $this->user_id = !Yii::$app->user->isGuest ? Yii::$app->user->id : null;
                }
            }
        }
        return true;
	}
}


text:
Scala Common Enrich is a shared library for processing raw Snowplow events into validated and enriched Snowplow events, ready for loading into [Storage] [storage].

Scala Common Enrich provides record-level enrichment only: feeding in 1 raw Snowplow event will yield 0 or 1 records out, where a record may be an enriched Snowplow event or a reported bad record.

Scala Common Enrich is designed to be used within a "host" enrichment process. The currently supported host enrichment process is our [Hadoop Enrich] [hadoop-enrich] process; however we are also working on a new [Amazon Kinesis] [kinesis]-based enrichment process.

## Find out more

| Technical Docs              | Setup Guide           | Roadmap               | Contributing                  |
|-----------------------------|-----------------------|-----------------------|-------------------------------|
| ![i1] [techdocs-image]      | ![i2] [setup-image]   | ![i3] [roadmap-image] | ![i4] [contributing-image]    |
| [Technical Docs] [techdocs] | [Setup Guide] [setup] | [Roadmap] [roadmap]   | [Contributing] [contributing] |

## Copyright and license

Scala Common Enrich is copyright 2012-2014 Snowplow Analytics Ltd.

Licensed under the [Apache License, Version 2.0] [license] (the "License");
you may not use this software except in compliance with the License.

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.

[storage]: https://github.com/snowplow/snowplow/tree/master/4-storage

[hadoop-enrich]: https://github.com/snowplow/snowplow/tree/master/3-enrich/scala-hadoop-enrich
[kinesis]: http://aws.amazon.com/kinesis/

[techdocs-image]: https://d3i6fms1cm1j0i.cloudfront.net/github/images/techdocs.png
[setup-image]: https://d3i6fms1cm1j0i.cloudfront.net/github/images/setup.png
[roadmap-image]: https://d3i6fms1cm1j0i.cloudfront.net/github/images/roadmap.png
[contributing-image]: https://d3i6fms1cm1j0i.cloudfront.net/github/images/contributing.png

[techdocs]: xxx
[setup]: xxx
[roadmap]: xxx
[contributing]: xxx

[license]: http://www.apache.org/licenses/LICENSE-2.0


text:
package io.opentelemetry.sdk.logs.export;

import io.opentelemetry.sdk.common.CompletableResultCode;
import io.opentelemetry.sdk.logs.LogRecordProcessor;
import io.opentelemetry.sdk.logs.SdkLoggerProvider;
import io.opentelemetry.sdk.logs.data.LogRecordData;
import java.io.Closeable;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.List;
import java.util.concurrent.TimeUnit;

/**
 * An exporter is responsible for taking a collection of {@link LogRecordData}s and transmitting
 * them to their ultimate destination.
 */
public interface LogRecordExporter extends Closeable {

  /**
   * Returns a {@link LogRecordExporter} which delegates all exports to the {@code exporters} in
   * order.
   *
   *
Can be used to export to multiple backends using the same {@link LogRecordProcessor} like a
   * {@link SimpleLogRecordProcessor} or a {@link BatchLogRecordProcessor}.
   */
  static LogRecordExporter composite(LogRecordExporter... exporters) {
    return composite(Arrays.asList(exporters));
  }

  /**
   * Returns a {@link LogRecordExporter} which delegates all exports to the {@code exporters} in
   * order.
   *
   *
Can be used to export to multiple backends using the same {@link LogRecordProcessor} like a
   * {@link SimpleLogRecordProcessor} or a {@link BatchLogRecordProcessor}.
   */
  static LogRecordExporter composite(Iterable<LogRecordExporter> exporters) {
    List<LogRecordExporter> exportersList = new ArrayList<>();
    for (LogRecordExporter exporter : exporters) {
      exportersList.add(exporter);
    }
    if (exportersList.isEmpty()) {
      return NoopLogRecordExporter.getInstance();
    }
    if (exportersList.size() == 1) {
      return exportersList.get(0);
    }
    return MultiLogRecordExporter.create(exportersList);
  }

  /**
   * Exports the collections of given {@link LogRecordData}.
   *
   * @param logs the collection of {@link LogRecordData} to be exported
   * @return the result of the export, which is often an asynchronous operation
   */
  CompletableResultCode export(Collection<LogRecordData> logs);

  /**
   * Exports the collection of {@link LogRecordData} that have not yet been exported.
   *
   * @return the result of the flush, which is often an asynchronous operation
   */
  CompletableResultCode flush();

  /**
   * Shutdown the log exporter. Called when {@link SdkLoggerProvider#shutdown()} is called when this
   * exporter is registered to the provider via {@link BatchLogRecordProcessor} or {@link
   * SimpleLogRecordProcessor}.
   *
   * @return a {@link CompletableResultCode} which is completed when shutdown completes
   */
  CompletableResultCode shutdown();

  /** Closes this {@link LogRecordExporter}, releasing any resources. */
  @Override
  default void close() {
    shutdown().join(10, TimeUnit.SECONDS);
  }
}


text:
#include "ThinClientStickyManager.hpp"
#include "ThinClientPoolDM.hpp"
using namespace apache::geode::client;
bool ThinClientStickyManager::getStickyConnection(
    TcrConnection*& conn, GfErrType* error,
    std::set<ServerLocation>& excludeServers, bool forTransaction) {
  bool maxConnLimit = false;
  bool connFound = false;
  // ACE_Guard<ACE_Recursive_Thread_Mutex> guard( m_stickyLock );
  conn = (*TssConnectionWrapper::s_geodeTSSConn)->getConnection();

  if (!conn) {
    conn =
        m_dm->getConnectionFromQueue(true, error, excludeServers, maxConnLimit);
    if (conn) {
      conn->setAndGetBeingUsed(true, forTransaction);
    }
  } else {
    if (!conn->setAndGetBeingUsed(
            true, forTransaction)) {  // manage connection thread is changing
                                      // the connectiion
      conn = m_dm->getConnectionFromQueue(true, error, excludeServers,
                                          maxConnLimit);
      if (conn) {
        connFound = true;
        conn->setAndGetBeingUsed(true, forTransaction);
      }
    } else {
      connFound = true;
    }
  }
  return connFound;
}

void ThinClientStickyManager::getSingleHopStickyConnection(
    TcrEndpoint* theEP, TcrConnection*& conn) {
  conn = (*TssConnectionWrapper::s_geodeTSSConn)
             ->getSHConnection(theEP, m_dm->getName().c_str());
}

void ThinClientStickyManager::addStickyConnection(TcrConnection* conn) {
  ACE_Guard<ACE_Recursive_Thread_Mutex> guard(m_stickyLock);
  TcrConnection* oldConn =
      (*TssConnectionWrapper::s_geodeTSSConn)->getConnection();
  if (oldConn) {
    std::set<TcrConnection**>::iterator it = m_stickyConnList.find(
        (*TssConnectionWrapper::s_geodeTSSConn)->getConnDoublePtr());
    if (it != m_stickyConnList.end()) {
      oldConn->setAndGetBeingUsed(false, false);
      m_stickyConnList.erase(it);
      std::shared_ptr<Pool> p = nullptr;
      (*TssConnectionWrapper::s_geodeTSSConn)->setConnection(nullptr, p);
      m_dm->put(oldConn, false);
    }
  }

  if (conn) {
    (*TssConnectionWrapper::s_geodeTSSConn)
        ->setConnection(conn, m_dm->shared_from_this());
    conn->setAndGetBeingUsed(true, true);  // this is done for transaction
                                           // thread when some one resume
                                           // transaction
    m_stickyConnList.insert(
        (*TssConnectionWrapper::s_geodeTSSConn)->getConnDoublePtr());
  }
}

void ThinClientStickyManager::setStickyConnection(TcrConnection* conn,
                                                  bool forTransaction) {
  // ACE_Guard<ACE_Recursive_Thread_Mutex> guard( m_stickyLock );
  if (!conn) {
    ACE_Guard<ACE_Recursive_Thread_Mutex> guard(m_stickyLock);
    (*TssConnectionWrapper::s_geodeTSSConn)
        ->setConnection(nullptr, m_dm->shared_from_this());
  } else {
    TcrConnection* currentConn =
        (*TssConnectionWrapper::s_geodeTSSConn)->getConnection();
    if (currentConn != conn)  // otherwsie no need to set it again
    {
      ACE_Guard<ACE_Recursive_Thread_Mutex> guard(m_stickyLock);
      (*TssConnectionWrapper::s_geodeTSSConn)
          ->setConnection(conn, m_dm->shared_from_this());
      conn->setAndGetBeingUsed(
          false,
          forTransaction);  // if transaction then it will keep this as used
      m_stickyConnList.insert(
          (*TssConnectionWrapper::s_geodeTSSConn)->getConnDoublePtr());
    } else {
      currentConn->setAndGetBeingUsed(
          false,
          forTransaction);  // if transaction then it will keep this as used
    }
  }
}

void ThinClientStickyManager::setSingleHopStickyConnection(
    TcrEndpoint* ep, TcrConnection*& conn) {
  (*TssConnectionWrapper::s_geodeTSSConn)->setSHConnection(ep, conn);
}

void ThinClientStickyManager::cleanStaleStickyConnection() {
  LOGDEBUG("Cleaning sticky connections");
  std::set<ServerLocation> excludeServers;
  ACE_Guard<ACE_Recursive_Thread_Mutex> guard(m_stickyLock);
  std::find_if(m_stickyConnList.begin(), m_stickyConnList.end(),
               ThinClientStickyManager::isNULL);
  while (1) {
    std::set<TcrConnection**>::iterator it =
        std::find_if(m_stickyConnList.begin(), m_stickyConnList.end(),
                     ThinClientStickyManager::isNULL);
    if (it == m_stickyConnList.end()) break;
    m_stickyConnList.erase(it);
  }
  bool maxConnLimit = false;
  for (std::set<TcrConnection**>::iterator it = m_stickyConnList.begin();
       it != m_stickyConnList.end(); it++) {
    TcrConnection** conn = (*it);
    if ((*conn)->setAndGetBeingUsed(true, false) &&
        canThisConnBeDeleted(*conn)) {
      GfErrType err = GF_NOERR;
      TcrConnection* temp = m_dm->getConnectionFromQueue(
          false, &err, excludeServers, maxConnLimit);
      if (temp) {
        TcrConnection* temp1 = *conn;
        //*conn = temp; instead of setting in thread local put in queue, thread
        // will come and pick it from there
        *conn = nullptr;
        m_dm->put(temp, false);
        temp1->close();
        _GEODE_SAFE_DELETE(temp1);
        m_dm->removeEPConnections(1, false);
        LOGDEBUG("Replaced a sticky connection");
      } else {
        (*conn)->setAndGetBeingUsed(false, false);
      }
      temp = nullptr;
    }
  }
}

void ThinClientStickyManager::closeAllStickyConnections() {
  LOGDEBUG("ThinClientStickyManager::closeAllStickyConnections()");
  ACE_Guard<ACE_Recursive_Thread_Mutex> guard(m_stickyLock);
  for (std::set<TcrConnection**>::iterator it = m_stickyConnList.begin();
       it != m_stickyConnList.end(); it++) {
    TcrConnection** tempConn = *it;
    if (*tempConn) {
      (*tempConn)->close();
      _GEODE_SAFE_DELETE(*tempConn);
      m_dm->removeEPConnections(1, false);
    }
  }
}
bool ThinClientStickyManager::canThisConnBeDeleted(TcrConnection* conn) {
  bool canBeDeleted = false;
  LOGDEBUG("ThinClientStickyManager::canThisConnBeDeleted()");
  ACE_Guard<ACE_Recursive_Thread_Mutex> guard(m_stickyLock);
  if (m_dm->canItBeDeletedNoImpl(conn)) return true;
  TcrEndpoint* endPt = conn->getEndpointObject();
  ACE_Guard<ACE_Recursive_Thread_Mutex> guardQueue(
      endPt->getQueueHostedMutex());
  if (endPt->isQueueHosted()) {
    for (std::set<TcrConnection**>::iterator it = m_stickyConnList.begin();
         it != m_stickyConnList.end(); it++) {
      TcrConnection* connTemp2 = *(*it);
      if (connTemp2 && connTemp2->getEndpointObject() == endPt) {
        canBeDeleted = true;
        break;
      }
    }
  }
  return canBeDeleted;
}
void ThinClientStickyManager::releaseThreadLocalConnection() {
  TcrConnection* conn =
      (*TssConnectionWrapper::s_geodeTSSConn)->getConnection();
  if (conn) {
    ACE_Guard<ACE_Recursive_Thread_Mutex> guard(m_stickyLock);
    std::set<TcrConnection**>::iterator it = m_stickyConnList.find(
        (*TssConnectionWrapper::s_geodeTSSConn)->getConnDoublePtr());
    LOGDEBUG("ThinClientStickyManager::releaseThreadLocalConnection()");
    if (it != m_stickyConnList.end()) {
      m_stickyConnList.erase(it);
      conn->setAndGetBeingUsed(false,
                               false);  // now this can be used by next one
      m_dm->put(conn, false);
    }
    (*TssConnectionWrapper::s_geodeTSSConn)
        ->setConnection(nullptr, m_dm->shared_from_this());
  }
  (*TssConnectionWrapper::s_geodeTSSConn)
      ->releaseSHConnections(m_dm->shared_from_this());
}
bool ThinClientStickyManager::isNULL(TcrConnection** conn) {
  if (*conn == nullptr) return true;
  return false;
}

void ThinClientStickyManager::getAnyConnection(TcrConnection*& conn) {
  conn = (*TssConnectionWrapper::s_geodeTSSConn)
             ->getAnyConnection(m_dm->getName().c_str());
}


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="wrap_content"
    android:background="@drawable/azuc_list_bg"
    android:orientation="horizontal"
    android:paddingBottom="10dp"
    android:paddingTop="10dp" >

    <LinearLayout
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:layout_weight="1" >

        <ImageView
            android:id="@+id/message_tip"
            android:layout_width="wrap_content"
            android:layout_height="wrap_content"
            android:layout_gravity="center_vertical"
            android:layout_marginLeft="10dp"
            android:layout_marginRight="10dp"
            android:src="@drawable/anzhi_new_msg_tip" />

        <LinearLayout
            android:layout_width="wrap_content"
            android:layout_height="wrap_content"
            android:orientation="vertical" >

            <LinearLayout
                android:layout_width="wrap_content"
                android:layout_height="wrap_content"
                android:layout_marginBottom="5dp" >

                <TextView
                    android:id="@+id/message_title"
                    android:layout_width="wrap_content"
                    android:layout_height="wrap_content"
                    android:layout_weight="1"
                    android:ellipsize="end"
                    android:lines="1"
                    android:singleLine="true"
                    android:textColor="@color/anzhi_333333"
                    android:textSize="16sp" />

                <ImageView
                    android:id="@+id/message_tab"
                    android:layout_width="wrap_content"
                    android:layout_height="wrap_content"
                    android:layout_gravity="center_vertical"
                    android:layout_marginLeft="10dp"
                    android:src="@drawable/anzhi_bg_activity"
                    android:visibility="gone" />
            </LinearLayout>

            <com.anzhi.usercenter.sdk.WordBreakTextView
                android:id="@+id/message_content"
                android:layout_width="wrap_content"
                android:layout_height="wrap_content"
                android:layout_marginBottom="5dp"
                android:ellipsize="end"
                android:maxLines="2"
                android:textColor="@color/anzhi_666666"
                android:textSize="13sp" />

            <TextView
                android:id="@+id/message_time"
                android:layout_width="wrap_content"
                android:layout_height="wrap_content"
                android:textColor="@color/anzhi_a6a6a6"
                android:textSize="13sp" />
        </LinearLayout>
    </LinearLayout>

    <ImageView
        android:id="@+id/message_array"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:layout_gravity="center_vertical"
        android:padding="10dp"
        android:src="@drawable/anzhi_arrow_right_pressed" />

</LinearLayout>


text:
#ifndef true_type_font_h_INCLUDED
#define true_type_font_h_INCLUDED

#include <ft2build.h>
#include FT_FREETYPE_H

#include "true_type_font.h"
#include "../screen_interface/screen_pixel_interface.h"

typedef struct glyph_size_struct {
    int is_valid;
    int advance;
    int bitmap_width;
} glyph_size;

struct true_type_font_struct {
  FT_Face face;
  //bool has_kerning;
  int font_height_in_pixel;
  int line_height;
  z_ucs last_char; // for kerning
  FT_Render_Mode render_mode;
  glyph_size *glyph_size_cache;
  long glyph_size_cache_size;
};

typedef struct true_type_font_struct true_type_font;

int tt_get_glyph_size(true_type_font *font, z_ucs char_code,
    int *advance, int *bitmap_width);
int tt_draw_glyph(true_type_font *font, int x, int y, int x_max,
    int clip_top, int clip_bottom,
    z_rgb_colour foreground_colour, z_rgb_colour background_colour,
    struct z_screen_pixel_interface *screen_pixel_interface,
    z_ucs charcode, int *last_gylphs_xcursorpos);
void tt_destroy_font(true_type_font *font);

#endif // true_type_font_h_INCLUDED


text:
package org.terracotta.nomad.entity.common;

/**
 * @author Mathieu Carbou
 */
public interface NomadEntityConstants {
  String ENTITY_TYPE = "org.terracotta.nomad.entity.client.NomadEntity";
  String ENTITY_NAME = "nomad-entity";
}


text:
<?php

namespace MicroCMS\Domain;

class Perso
{
    /**
     * Experience id.
     *
     * @var integer
     */
    private $id;

    // Adresse
    private $adresse;
    // Adresse
    private $nom;
    // Adresse
    private $content;

    // Adresse
    private $poste;

    // Facebook
    private $facebook;

    // Facebook
    private $codepen;

    // Github
    private $github;

    // LinkedIn
    private $linkedin;

    // CV
    private $cv;

    // Prenom
    private $prenom;

    // Prenom
    private $img;

    // Telephone
    private $tel;

    public function setTel( $tel ){
      $this->tel = $tel;
      return $this;
    }
    public function getTel(){
      return $this->tel;
    }
    public function setFacebook( $facebook ){
      $this->facebook = $facebook;
      return $this;
    }
    public function getFacebook(){
      return $this->facebook;
    }
    public function setGithub( $github ){
      $this->github = $github;
      return $this;
    }
    public function getGithub(){
      return $this->github;
    }
    public function setCodepen( $codepen ){
      $this->codepen = $codepen;
      return $this;
    }
    public function getCodepen(){
      return $this->codepen;
    }
    public function setCv( $cv ){
      $this->cv = $cv;
      return $this;
    }
    public function getCv(){
      return $this->cv;
    }

    public function setLinkedin( $linkedin ){
      $this->linkedin = $linkedin;
      return $this;
    }
    public function getLinkedin(){
      return $this->linkedin;
    }
    public function setPoste( $poste ){
      $this->poste = $poste;
      return $this;
    }
    public function getPoste(){
      return $this->poste;
    }
    public function setImg( $img ){
      $this->img = $img;
      return $this;
    }
    public function getImg(){
      return $this->img;
    }
    public function getAdresse(){
      return $this->adresse;
    }
    public function setAdresse( $adresse ){
      $this->adresse = $adresse;
      return $this;
    }
    public function getPrenom(){
      return $this->prenom;
    }
    public function setPrenom( $prenom ){
      $this->prenom = $prenom;
      return $this;
    }

    public function getId() {
        return $this->id;
    }

    public function setId($id) {
        $this->id = $id;
        return $this;
    }

    public function getNom() {
        return $this->nom;
    }

    public function setNom($nom) {
        $this->nom = $nom;
        return $this;
    }

    public function getContent() {
        return $this->content;
    }

    public function setContent($content) {
        $this->content = $content;
        return $this;
    }
}


text:
package java.security;

class SecurityUtil
{
    static class Implementation
    {
        Object      engine;
        Provider    provider;

        Implementation(
            Object      engine,
            Provider    provider)
        {
            this.engine = engine;
            this.provider = provider;
        }

        Object getEngine()
        {
            return engine;
        }

        Provider getProvider()
        {
            return provider;
        }
    }

    /**
     * see if we can find an algorithm (or its alias and what it represents) in
     * the property table for the given provider.
     *
     * @return null if no algorithm found, an Implementation if it is.
     */
    static private Implementation getImplementation(
        String      baseName,
        String      algorithm,
        Provider    prov)
    {
        String      alias;

        while ((alias = prov.getProperty("Alg.Alias." + baseName + "." + algorithm)) != null)
        {
            algorithm = alias;
        }

        String      className = prov.getProperty(baseName + "." + algorithm);

        if (className != null)
        {
            try
            {
                return new Implementation(Class.forName(className).newInstance(), prov);
            }
            catch (ClassNotFoundException e)
            {
                throw new IllegalStateException(
                    "algorithm " + algorithm + " in provider " + prov.getName() + " but no class found!");
            }
            catch (Exception e)
            {
                throw new IllegalStateException(
                    "algorithm " + algorithm + " in provider " + prov.getName() + " but class inaccessible!");
            }
        }

        return null;
    }

    /**
     * return an implementation for a given algorithm/provider.
     * If the provider is null, we grab the first avalaible who has the required algorithm.
     *
     * @return null if no algorithm found, an Implementation if it is.
     * @exception NoSuchProviderException if a provider is specified and not found.
     */
    static Implementation getImplementation(
        String      baseName,
        String      algorithm,
        String      provider)
        throws NoSuchProviderException
    {
        if (provider == null)
        {
            Provider[] prov = Security.getProviders();

            //
            // search every provider looking for the algorithm we want.
            //
            for (int i = 0; i != prov.length; i++)
            {
                Implementation imp = getImplementation(baseName, algorithm, prov[i]);
                if (imp != null)
                {
                    return imp;
                }
            }
        }
        else
        {
            Provider prov = Security.getProvider(provider);

            if (prov == null)
            {
                throw new NoSuchProviderException("Provider " + provider + " not found");
            }

            return getImplementation(baseName, algorithm, prov);
        }

        return null;
    }
}


text:
// strciphr.h - written and placed in the public domain by Wei Dai

//! \file strciphr.h
//! \brief Classes for implementing stream ciphers
//! \details This file contains helper classes for implementing stream ciphers.
//!   All this infrastructure may look very complex compared to what's in Crypto++ 4.x,
//!   but stream ciphers implementations now support a lot of new functionality,
//!   including better performance (minimizing copying), resetting of keys and IVs, and methods to
//!   query which features are supported by a cipher.
//! \details Here's an explanation of these classes. The word "policy" is used here to mean a class with a
//!   set of methods that must be implemented by individual stream cipher implementations.
//!   This is usually much simpler than the full stream cipher API, which is implemented by
//!   either AdditiveCipherTemplate or CFB_CipherTemplate using the policy. So for example, an
//!   implementation of SEAL only needs to implement the AdditiveCipherAbstractPolicy interface
//!   (since it's an additive cipher, i.e., it xors a keystream into the plaintext).
//!   See this line in seal.h:
//!

//!     typedef SymmetricCipherFinal\<ConcretePolicyHolder\<SEAL_Policy\, AdditiveCipherTemplate\<\> \> \> Encryption;
//!

//! \details AdditiveCipherTemplate and CFB_CipherTemplate are designed so that they don't need
//!   to take a policy class as a template parameter (although this is allowed), so that
//!   their code is not duplicated for each new cipher. Instead they each
//!   get a reference to an abstract policy interface by calling AccessPolicy() on itself, so
//!   AccessPolicy() must be overridden to return the actual policy reference. This is done
//!   by the ConceretePolicyHolder class. Finally, SymmetricCipherFinal implements the constructors and
//!   other functions that must be implemented by the most derived class.

#ifndef CRYPTOPP_STRCIPHR_H
#define CRYPTOPP_STRCIPHR_H

#include "config.h"

#if CRYPTOPP_MSC_VERSION
# pragma warning(push)
# pragma warning(disable: 4127 4189)
#endif

#include "cryptlib.h"
#include "seckey.h"
#include "secblock.h"
#include "argnames.h"

NAMESPACE_BEGIN(CryptoPP)

//! \class AbstractPolicyHolder
//! \brief Access a stream cipher policy object
//! \tparam POLICY_INTERFACE class implementing AbstractPolicyHolder
//! \tparam BASE class or type to use as a base class
template <class POLICY_INTERFACE, class BASE = Empty>
class CRYPTOPP_NO_VTABLE AbstractPolicyHolder : public BASE
{
public:
	typedef POLICY_INTERFACE PolicyInterface;
	virtual ~AbstractPolicyHolder() {}

protected:
	virtual const POLICY_INTERFACE & GetPolicy() const =0;
	virtual POLICY_INTERFACE & AccessPolicy() =0;
};

//! \class ConcretePolicyHolder
//! \brief Stream cipher policy object
//! \tparam POLICY class implementing AbstractPolicyHolder
//! \tparam BASE class or type to use as a base class
template <class POLICY, class BASE, class POLICY_INTERFACE = typename BASE::PolicyInterface>
class ConcretePolicyHolder : public BASE, protected POLICY
{
public:
	virtual ~ConcretePolicyHolder() {}
protected:
	const POLICY_INTERFACE & GetPolicy() const {return *this;}
	POLICY_INTERFACE & AccessPolicy() {return *this;}
};

//! \brief Keystream operation flags
//! \sa AdditiveCipherAbstractPolicy::GetBytesPerIteration(), AdditiveCipherAbstractPolicy::GetOptimalBlockSize()
//!   and AdditiveCipherAbstractPolicy::GetAlignment()
enum KeystreamOperationFlags {
	//! \brief Output buffer is aligned
	OUTPUT_ALIGNED=1,
	//! \brief Input buffer is aligned
	INPUT_ALIGNED=2,
	//! \brief Input buffer is NULL
	INPUT_NULL = 4
};

//! \brief Keystream operation flags
//! \sa AdditiveCipherAbstractPolicy::GetBytesPerIteration(), AdditiveCipherAbstractPolicy::GetOptimalBlockSize()
//!   and AdditiveCipherAbstractPolicy::GetAlignment()
enum KeystreamOperation {
	//! \brief Wirte the keystream to the output buffer, input is NULL
	WRITE_KEYSTREAM				= INPUT_NULL,
	//! \brief Wirte the keystream to the aligned output buffer, input is NULL
	WRITE_KEYSTREAM_ALIGNED		= INPUT_NULL | OUTPUT_ALIGNED,
	//! \brief XOR the input buffer and keystream, write to the output buffer
	XOR_KEYSTREAM				= 0,
	//! \brief XOR the aligned input buffer and keystream, write to the output buffer
	XOR_KEYSTREAM_INPUT_ALIGNED = INPUT_ALIGNED,
	//! \brief XOR the input buffer and keystream, write to the aligned output buffer
	XOR_KEYSTREAM_OUTPUT_ALIGNED= OUTPUT_ALIGNED,
	//! \brief XOR the aligned input buffer and keystream, write to the aligned output buffer
	XOR_KEYSTREAM_BOTH_ALIGNED	= OUTPUT_ALIGNED | INPUT_ALIGNED};

//! \class AdditiveCipherAbstractPolicy
//! \brief Policy object for additive stream ciphers
struct CRYPTOPP_DLL CRYPTOPP_NO_VTABLE AdditiveCipherAbstractPolicy
{
	virtual ~AdditiveCipherAbstractPolicy() {}

	//! \brief Provides data alignment requirements
	//! \returns data alignment requirements, in bytes
	//! \details Internally, the default implementation returns 1. If the stream cipher is implemented
	//!   using an SSE2 ASM or intrinsics, then the value returned is usually 16.
	virtual unsigned int GetAlignment() const {return 1;}

	//! \brief Provides number of bytes operated upon during an iteration
	//! \returns bytes operated upon during an iteration, in bytes
	//! \sa GetOptimalBlockSize()
	virtual unsigned int GetBytesPerIteration() const =0;

	//! \brief Provides number of ideal bytes to process
	//! \returns the ideal number of bytes to process
	//! \details Internally, the default implementation returns GetBytesPerIteration()
	//! \sa GetBytesPerIteration()
	virtual unsigned int GetOptimalBlockSize() const {return GetBytesPerIteration();}

	//! \brief Provides buffer size based on iterations
	//! \returns the buffer size based on iterations, in bytes
	virtual unsigned int GetIterationsToBuffer() const =0;

	//! \brief Generate the keystream
	//! \param keystream the key stream
	//! \param iterationCount the number of iterations to generate the key stream
	//! \sa CanOperateKeystream(), OperateKeystream(), WriteKeystream()
	virtual void WriteKeystream(byte *keystream, size_t iterationCount)
		{OperateKeystream(KeystreamOperation(INPUT_NULL | (KeystreamOperationFlags)IsAlignedOn(keystream, GetAlignment())), keystream, NULL, iterationCount);}

	//! \brief Flag indicating
	//! \returns true if the stream can be generated independent of the transformation input, false otherwise
	//! \sa CanOperateKeystream(), OperateKeystream(), WriteKeystream()
	virtual bool CanOperateKeystream() const {return false;}

	//! \brief Operates the keystream
	//! \param operation the operation with additional flags
	//! \param output the output buffer
	//! \param input the input buffer
	//! \param iterationCount the number of iterations to perform on the input
	//! \details OperateKeystream() will attempt to operate upon GetOptimalBlockSize() buffer,
	//!   which will be derived from GetBytesPerIteration().
	//! \sa CanOperateKeystream(), OperateKeystream(), WriteKeystream(), KeystreamOperation()
	virtual void OperateKeystream(KeystreamOperation operation, byte *output, const byte *input, size_t iterationCount)
		{CRYPTOPP_UNUSED(operation); CRYPTOPP_UNUSED(output); CRYPTOPP_UNUSED(input); CRYPTOPP_UNUSED(iterationCount); CRYPTOPP_ASSERT(false);}

	//! \brief Key the cipher
	//! \param params set of NameValuePairs use to initialize this object
	//! \param key a byte array used to key the cipher
	//! \param length the size of the key array
	virtual void CipherSetKey(const NameValuePairs &params, const byte *key, size_t length) =0;

	//! \brief Resynchronize the cipher
	//! \param keystreamBuffer the keystream buffer
	//! \param iv a byte array used to resynchronize the cipher
	//! \param length the size of the IV array
	virtual void CipherResynchronize(byte *keystreamBuffer, const byte *iv, size_t length)
		{CRYPTOPP_UNUSED(keystreamBuffer); CRYPTOPP_UNUSED(iv); CRYPTOPP_UNUSED(length); throw NotImplemented("SimpleKeyingInterface: this object doesn't support resynchronization");}

	//! \brief Flag indicating random access
	//! \returns true if the cipher is seekable, false otherwise
	//! \sa SeekToIteration()
	virtual bool CipherIsRandomAccess() const =0;

	//! \brief Seeks to a random position in the stream
	//! \returns iterationCount
	//! \sa CipherIsRandomAccess()
	virtual void SeekToIteration(lword iterationCount)
		{CRYPTOPP_UNUSED(iterationCount); CRYPTOPP_ASSERT(!CipherIsRandomAccess()); throw NotImplemented("StreamTransformation: this object doesn't support random access");}
};

//! \class AdditiveCipherConcretePolicy
//! \brief Base class for additive stream ciphers
//! \tparam WT word type
//! \tparam W count of words
//! \tparam X bytes per iteration count
//! \tparam BASE AdditiveCipherAbstractPolicy derived base class
template <typename WT, unsigned int W, unsigned int X = 1, class BASE = AdditiveCipherAbstractPolicy>
struct CRYPTOPP_NO_VTABLE AdditiveCipherConcretePolicy : public BASE
{
	typedef WT WordType;
	CRYPTOPP_CONSTANT(BYTES_PER_ITERATION = sizeof(WordType) * W)

#if !(CRYPTOPP_BOOL_X86 || CRYPTOPP_BOOL_X64)
	//! \brief Provides data alignment requirements
	//! \returns data alignment requirements, in bytes
	//! \details Internally, the default implementation returns 1. If the stream cipher is implemented
	//!   using an SSE2 ASM or intrinsics, then the value returned is usually 16.
	unsigned int GetAlignment() const {return GetAlignmentOf<WordType>();}
#endif

	//! \brief Provides number of bytes operated upon during an iteration
	//! \returns bytes operated upon during an iteration, in bytes
	//! \sa GetOptimalBlockSize()
	unsigned int GetBytesPerIteration() const {return BYTES_PER_ITERATION;}

	//! \brief Provides buffer size based on iterations
	//! \returns the buffer size based on iterations, in bytes
	unsigned int GetIterationsToBuffer() const {return X;}

	//! \brief Flag indicating
	//! \returns true if the stream can be generated independent of the transformation input, false otherwise
	//! \sa CanOperateKeystream(), OperateKeystream(), WriteKeystream()
	bool CanOperateKeystream() const {return true;}

	//! \brief Operates the keystream
	//! \param operation the operation with additional flags
	//! \param output the output buffer
	//! \param input the input buffer
	//! \param iterationCount the number of iterations to perform on the input
	//! \details OperateKeystream() will attempt to operate upon GetOptimalBlockSize() buffer,
	//!   which will be derived from GetBytesPerIteration().
	//! \sa CanOperateKeystream(), OperateKeystream(), WriteKeystream(), KeystreamOperation()
	virtual void OperateKeystream(KeystreamOperation operation, byte *output, const byte *input, size_t iterationCount) =0;
};

//! \brief Helper macro to implement OperateKeystream
#define CRYPTOPP_KEYSTREAM_OUTPUT_WORD(x, b, i, a)	\
	PutWord(bool(x & OUTPUT_ALIGNED), b, output+i*sizeof(WordType), (x & INPUT_NULL) ? (a) : (a) ^ GetWord<WordType>(bool(x & INPUT_ALIGNED), b, input+i*sizeof(WordType)));

//! \brief Helper macro to implement OperateKeystream
#define CRYPTOPP_KEYSTREAM_OUTPUT_XMM(x, i, a)	{\
	__m128i t = (x & INPUT_NULL) ? a : _mm_xor_si128(a, (x & INPUT_ALIGNED) ? _mm_load_si128((__m128i *)input+i) : _mm_loadu_si128((__m128i *)input+i));\
	if (x & OUTPUT_ALIGNED) _mm_store_si128((__m128i *)output+i, t);\
	else _mm_storeu_si128((__m128i *)output+i, t);}

//! \brief Helper macro to implement OperateKeystream
#define CRYPTOPP_KEYSTREAM_OUTPUT_SWITCH(x, y)	\
	switch (operation)							\
	{											\
		case WRITE_KEYSTREAM:					\
			x(WRITE_KEYSTREAM)					\
			break;								\
		case XOR_KEYSTREAM:						\
			x(XOR_KEYSTREAM)					\
			input += y;							\
			break;								\
		case XOR_KEYSTREAM_INPUT_ALIGNED:		\
			x(XOR_KEYSTREAM_INPUT_ALIGNED)		\
			input += y;							\
			break;								\
		case XOR_KEYSTREAM_OUTPUT_ALIGNED:		\
			x(XOR_KEYSTREAM_OUTPUT_ALIGNED)		\
			input += y;							\
			break;								\
		case WRITE_KEYSTREAM_ALIGNED:			\
			x(WRITE_KEYSTREAM_ALIGNED)			\
			break;								\
		case XOR_KEYSTREAM_BOTH_ALIGNED:		\
			x(XOR_KEYSTREAM_BOTH_ALIGNED)		\
			input += y;							\
			break;								\
	}											\
	output += y;

//! \class AdditiveCipherTemplate
//! \brief Base class for additive stream ciphers with SymmetricCipher interface
//! \tparam BASE AbstractPolicyHolder base class
template <class BASE = AbstractPolicyHolder<AdditiveCipherAbstractPolicy, SymmetricCipher> >
class CRYPTOPP_NO_VTABLE AdditiveCipherTemplate : public BASE, public RandomNumberGenerator
{
public:
	virtual ~AdditiveCipherTemplate() {}

	//! \brief Generate random array of bytes
	//! \param output the byte buffer
	//! \param size the length of the buffer, in bytes
	//! \details All generated values are uniformly distributed over the range specified within the
	//!   the constraints of a particular generator.
	void GenerateBlock(byte *output, size_t size);

	//! \brief Apply keystream to data
	//! \param outString a buffer to write the transformed data
	//! \param inString a buffer to read the data
	//! \param length the size fo the buffers, in bytes
	//! \details This is the primary method to operate a stream cipher. For example:
	//!

	//!     size_t size = 30;
	//!     byte plain[size] = "Do or do not; there is no try";
	//!     byte cipher[size];
	//!     ...
	//!     ChaCha20 chacha(key, keySize);
	//!     chacha.ProcessData(cipher, plain, size);
	//!

    void ProcessData(byte *outString, const byte *inString, size_t length);

	//! \brief Resynchronize the cipher
	//! \param iv a byte array used to resynchronize the cipher
	//! \param length the size of the IV array
	void Resynchronize(const byte *iv, int length=-1);

	//! \brief Provides number of ideal bytes to process
	//! \returns the ideal number of bytes to process
	//! \details Internally, the default implementation returns GetBytesPerIteration()
	//! \sa GetBytesPerIteration() and GetOptimalNextBlockSize()
	unsigned int OptimalBlockSize() const {return this->GetPolicy().GetOptimalBlockSize();}

	//! \brief Provides number of ideal bytes to process
	//! \returns the ideal number of bytes to process
	//! \details Internally, the default implementation returns remaining unprocessed bytes
	//! \sa GetBytesPerIteration() and OptimalBlockSize()
	unsigned int GetOptimalNextBlockSize() const {return (unsigned int)this->m_leftOver;}

	//! \brief Provides number of ideal data alignment
	//! \returns the ideal data alignment, in bytes
	//! \sa GetAlignment() and OptimalBlockSize()
	unsigned int OptimalDataAlignment() const {return this->GetPolicy().GetAlignment();}

	//! \brief Determines if the cipher is self inverting
	//! \returns true if the stream cipher is self inverting, false otherwise
	bool IsSelfInverting() const {return true;}

	//! \brief Determines if the cipher is a forward transformation
	//! \returns true if the stream cipher is a forward transformation, false otherwise
	bool IsForwardTransformation() const {return true;}

	//! \brief Flag indicating random access
	//! \returns true if the cipher is seekable, false otherwise
	//! \sa Seek()
	bool IsRandomAccess() const {return this->GetPolicy().CipherIsRandomAccess();}

	//! \brief Seeks to a random position in the stream
	//! \param position the absolute position in the stream
	//! \sa IsRandomAccess()
	void Seek(lword position);

	typedef typename BASE::PolicyInterface PolicyInterface;

protected:
	void UncheckedSetKey(const byte *key, unsigned int length, const NameValuePairs &params);

	unsigned int GetBufferByteSize(const PolicyInterface &policy) const {return policy.GetBytesPerIteration() * policy.GetIterationsToBuffer();}

	inline byte * KeystreamBufferBegin() {return this->m_buffer.data();}
	inline byte * KeystreamBufferEnd() {return (this->m_buffer.data() + this->m_buffer.size());}

	SecByteBlock m_buffer;
	size_t m_leftOver;
};

//! \class CFB_CipherAbstractPolicy
//! \brief Policy object for feeback based stream ciphers
class CRYPTOPP_DLL CRYPTOPP_NO_VTABLE CFB_CipherAbstractPolicy
{
public:
	virtual ~CFB_CipherAbstractPolicy() {}

	//! \brief Provides data alignment requirements
	//! \returns data alignment requirements, in bytes
	//! \details Internally, the default implementation returns 1. If the stream cipher is implemented
	//!   using an SSE2 ASM or intrinsics, then the value returned is usually 16.
	virtual unsigned int GetAlignment() const =0;

	//! \brief Provides number of bytes operated upon during an iteration
	//! \returns bytes operated upon during an iteration, in bytes
	//! \sa GetOptimalBlockSize()
	virtual unsigned int GetBytesPerIteration() const =0;

	//! \brief Access the feedback register
	//! \returns pointer to the first byte of the feedback register
	virtual byte * GetRegisterBegin() =0;

	//! \brief TODO
	virtual void TransformRegister() =0;

	//! \brief Flag indicating iteration support
	//! \returns true if the cipher supports iteration, false otherwise
	virtual bool CanIterate() const {return false;}

	//! \brief Iterate the cipher
	//! \param output the output buffer
	//! \param input the input buffer
	//! \param dir the direction of the cipher
	//! \param iterationCount the number of iterations to perform on the input
	//! \sa IsSelfInverting() and IsForwardTransformation()
	virtual void Iterate(byte *output, const byte *input, CipherDir dir, size_t iterationCount)
		{CRYPTOPP_UNUSED(output); CRYPTOPP_UNUSED(input); CRYPTOPP_UNUSED(dir); CRYPTOPP_UNUSED(iterationCount);
		 CRYPTOPP_ASSERT(false); /*throw 0;*/ throw Exception(Exception::OTHER_ERROR, "SimpleKeyingInterface: unexpected error");}

	//! \brief Key the cipher
	//! \param params set of NameValuePairs use to initialize this object
	//! \param key a byte array used to key the cipher
	//! \param length the size of the key array
	virtual void CipherSetKey(const NameValuePairs &params, const byte *key, size_t length) =0;

	//! \brief Resynchronize the cipher
	//! \param iv a byte array used to resynchronize the cipher
	//! \param length the size of the IV array
	virtual void CipherResynchronize(const byte *iv, size_t length)
		{CRYPTOPP_UNUSED(iv); CRYPTOPP_UNUSED(length); throw NotImplemented("SimpleKeyingInterface: this object doesn't support resynchronization");}
};

//! \class CFB_CipherConcretePolicy
//! \brief Base class for feedback based stream ciphers
//! \tparam WT word type
//! \tparam W count of words
//! \tparam BASE CFB_CipherAbstractPolicy derived base class
template <typename WT, unsigned int W, class BASE = CFB_CipherAbstractPolicy>
struct CRYPTOPP_NO_VTABLE CFB_CipherConcretePolicy : public BASE
{
	typedef WT WordType;

	//! \brief Provides data alignment requirements
	//! \returns data alignment requirements, in bytes
	//! \details Internally, the default implementation returns 1. If the stream cipher is implemented
	//!   using an SSE2 ASM or intrinsics, then the value returned is usually 16.
	unsigned int GetAlignment() const {return sizeof(WordType);}

	//! \brief Provides number of bytes operated upon during an iteration
	//! \returns bytes operated upon during an iteration, in bytes
	//! \sa GetOptimalBlockSize()
	unsigned int GetBytesPerIteration() const {return sizeof(WordType) * W;}

	//! \brief Flag indicating iteration support
	//! \returns true if the cipher supports iteration, false otherwise
	bool CanIterate() const {return true;}

	//! \brief Perform one iteration in the forward direction
	void TransformRegister() {this->Iterate(NULL, NULL, ENCRYPTION, 1);}

	//! \brief
	//! \tparam B enumeration indicating endianness
	//! \details RegisterOutput() provides alternate access to the feedback register. The
	//!   enumeration B is BigEndian or LittleEndian. Repeatedly applying operator()
	//!   results in advancing in the register.
	template <class B>
	struct RegisterOutput
	{
		RegisterOutput(byte *output, const byte *input, CipherDir dir)
			: m_output(output), m_input(input), m_dir(dir) {}

		//! \brief XOR feedback register with data
		//! \param registerWord data represented as a word type
		//! \returns reference to the next feedback register word
		inline RegisterOutput& operator()(WordType &registerWord)
		{
			CRYPTOPP_ASSERT(IsAligned<WordType>(m_output));
			CRYPTOPP_ASSERT(IsAligned<WordType>(m_input));

			if (!NativeByteOrderIs(B::ToEnum()))
				registerWord = ByteReverse(registerWord);

			if (m_dir == ENCRYPTION)
			{
				if (m_input == NULL)
				{
					CRYPTOPP_ASSERT(m_output == NULL);
				}
				else
				{
					WordType ct = *(const WordType *)m_input ^ registerWord;
					registerWord = ct;
					*(WordType*)m_output = ct;
					m_input += sizeof(WordType);
					m_output += sizeof(WordType);
				}
			}
			else
			{
				WordType ct = *(const WordType *)m_input;
				*(WordType*)m_output = registerWord ^ ct;
				registerWord = ct;
				m_input += sizeof(WordType);
				m_output += sizeof(WordType);
			}

			// registerWord is left unreversed so it can be xor-ed with further input

			return *this;
		}

		byte *m_output;
		const byte *m_input;
		CipherDir m_dir;
	};
};

//! \class CFB_CipherTemplate
//! \brief Base class for feedback based stream ciphers with SymmetricCipher interface
//! \tparam BASE AbstractPolicyHolder base class
template <class BASE>
class CRYPTOPP_NO_VTABLE CFB_CipherTemplate : public BASE
{
public:
	//! \brief Apply keystream to data
	//! \param outString a buffer to write the transformed data
	//! \param inString a buffer to read the data
	//! \param length the size fo the buffers, in bytes
	//! \details This is the primary method to operate a stream cipher. For example:
	//!

	//!     size_t size = 30;
	//!     byte plain[size] = "Do or do not; there is no try";
	//!     byte cipher[size];
	//!     ...
	//!     ChaCha20 chacha(key, keySize);
	//!     chacha.ProcessData(cipher, plain, size);
	//!

	void ProcessData(byte *outString, const byte *inString, size_t length);

	//! \brief Resynchronize the cipher
	//! \param iv a byte array used to resynchronize the cipher
	//! \param length the size of the IV array
	void Resynchronize(const byte *iv, int length=-1);

	//! \brief Provides number of ideal bytes to process
	//! \returns the ideal number of bytes to process
	//! \details Internally, the default implementation returns GetBytesPerIteration()
	//! \sa GetBytesPerIteration() and GetOptimalNextBlockSize()
	unsigned int OptimalBlockSize() const {return this->GetPolicy().GetBytesPerIteration();}

	//! \brief Provides number of ideal bytes to process
	//! \returns the ideal number of bytes to process
	//! \details Internally, the default implementation returns remaining unprocessed bytes
	//! \sa GetBytesPerIteration() and OptimalBlockSize()
	unsigned int GetOptimalNextBlockSize() const {return (unsigned int)m_leftOver;}

	//! \brief Provides number of ideal data alignment
	//! \returns the ideal data alignment, in bytes
	//! \sa GetAlignment() and OptimalBlockSize()
	unsigned int OptimalDataAlignment() const {return this->GetPolicy().GetAlignment();}

	//! \brief Flag indicating random access
	//! \returns true if the cipher is seekable, false otherwise
	//! \sa Seek()
	bool IsRandomAccess() const {return false;}

	//! \brief Determines if the cipher is self inverting
	//! \returns true if the stream cipher is self inverting, false otherwise
	bool IsSelfInverting() const {return false;}

	typedef typename BASE::PolicyInterface PolicyInterface;

protected:
	virtual void CombineMessageAndShiftRegister(byte *output, byte *reg, const byte *message, size_t length) =0;

	void UncheckedSetKey(const byte *key, unsigned int length, const NameValuePairs &params);

	size_t m_leftOver;
};

//! \class CFB_EncryptionTemplate
//! \brief Base class for feedback based stream ciphers in the forward direction with SymmetricCipher interface
//! \tparam BASE AbstractPolicyHolder base class
template <class BASE = AbstractPolicyHolder<CFB_CipherAbstractPolicy, SymmetricCipher> >
class CRYPTOPP_NO_VTABLE CFB_EncryptionTemplate : public CFB_CipherTemplate<BASE>
{
	bool IsForwardTransformation() const {return true;}
	void CombineMessageAndShiftRegister(byte *output, byte *reg, const byte *message, size_t length);
};

//! \class CFB_DecryptionTemplate
//! \brief Base class for feedback based stream ciphers in the reverse direction with SymmetricCipher interface
//! \tparam BASE AbstractPolicyHolder base class
template <class BASE = AbstractPolicyHolder<CFB_CipherAbstractPolicy, SymmetricCipher> >
class CRYPTOPP_NO_VTABLE CFB_DecryptionTemplate : public CFB_CipherTemplate<BASE>
{
	bool IsForwardTransformation() const {return false;}
	void CombineMessageAndShiftRegister(byte *output, byte *reg, const byte *message, size_t length);
};

//! \class CFB_RequireFullDataBlocks
//! \brief Base class for feedback based stream ciphers with a mandatory block size
//! \tparam BASE CFB_EncryptionTemplate or CFB_DecryptionTemplate base class
template <class BASE>
class CFB_RequireFullDataBlocks : public BASE
{
public:
	unsigned int MandatoryBlockSize() const {return this->OptimalBlockSize();}
};

//! \class SymmetricCipherFinal
//! \brief SymmetricCipher implementation
//! \tparam BASE AbstractPolicyHolder derived base class
//! \tparam INFO AbstractPolicyHolder derived information class
//! \sa Weak::ARC4, ChaCha8, ChaCha12, ChaCha20, Salsa20, SEAL, Sosemanuk, WAKE
template <class BASE, class INFO = BASE>
class SymmetricCipherFinal : public AlgorithmImpl<SimpleKeyingInterfaceImpl<BASE, INFO>, INFO>
{
public:
	virtual ~SymmetricCipherFinal() {}

	//! \brief Construct a stream cipher
 	SymmetricCipherFinal() {}

	//! \brief Construct a stream cipher
	//! \param key a byte array used to key the cipher
	//! \details This overload uses DEFAULT_KEYLENGTH
	SymmetricCipherFinal(const byte *key)
		{this->SetKey(key, this->DEFAULT_KEYLENGTH);}

	//! \brief Construct a stream cipher
	//! \param key a byte array used to key the cipher
	//! \param length the size of the key array
	SymmetricCipherFinal(const byte *key, size_t length)
		{this->SetKey(key, length);}

	//! \brief Construct a stream cipher
	//! \param key a byte array used to key the cipher
	//! \param length the size of the key array
	//! \param iv a byte array used as an initialization vector
	SymmetricCipherFinal(const byte *key, size_t length, const byte *iv)
		{this->SetKeyWithIV(key, length, iv);}

	//! \brief Clone a SymmetricCipher
	//! \returns a new SymmetricCipher based on this object
	Clonable * Clone() const {return static_cast<SymmetricCipher *>(new SymmetricCipherFinal<BASE, INFO>(*this));}
};

NAMESPACE_END

#ifdef CRYPTOPP_MANUALLY_INSTANTIATE_TEMPLATES
#include "strciphr.cpp"
#endif

NAMESPACE_BEGIN(CryptoPP)
CRYPTOPP_DLL_TEMPLATE_CLASS AbstractPolicyHolder<AdditiveCipherAbstractPolicy, SymmetricCipher>;
CRYPTOPP_DLL_TEMPLATE_CLASS AdditiveCipherTemplate<AbstractPolicyHolder<AdditiveCipherAbstractPolicy, SymmetricCipher> >;
CRYPTOPP_DLL_TEMPLATE_CLASS CFB_CipherTemplate<AbstractPolicyHolder<CFB_CipherAbstractPolicy, SymmetricCipher> >;
CRYPTOPP_DLL_TEMPLATE_CLASS CFB_EncryptionTemplate<AbstractPolicyHolder<CFB_CipherAbstractPolicy, SymmetricCipher> >;
CRYPTOPP_DLL_TEMPLATE_CLASS CFB_DecryptionTemplate<AbstractPolicyHolder<CFB_CipherAbstractPolicy, SymmetricCipher> >;

NAMESPACE_END

#if CRYPTOPP_MSC_VERSION
# pragma warning(pop)
#endif

#endif


text:
package com.facebook.react.uimanager;

import java.util.HashMap;
import java.util.List;
import java.util.Map;

/**
 * Class that stores the mapping between native view name used in JS and the corresponding instance
 * of {@link ViewManager}.
 */
public class ViewManagerRegistry {

  private final Map<String, ViewManager> mViewManagers = new HashMap<>();

  public ViewManagerRegistry(List<ViewManager> viewManagerList) {
    for (ViewManager viewManager : viewManagerList) {
      mViewManagers.put(viewManager.getName(), viewManager);
    }
  }

  public ViewManager get(String className) {
    ViewManager viewManager = mViewManagers.get(className);
    if (viewManager != null) {
      return viewManager;
    } else {
      throw new IllegalViewOperationException("No ViewManager defined for class " + className);
    }
  }
}


text:
package com.vladium.jcd.cls.attribute;

// ----------------------------------------------------------------------------
/**
 * @author (C) 2001, Vlad Roubtsov
 */
public
interface IAttributeVisitor
{
    // public: ................................................................

    Object visit (GenericAttribute_info attribute, Object ctx);

    Object visit (CodeAttribute_info attribute, Object ctx);
    Object visit (ConstantValueAttribute_info attribute, Object ctx);
    Object visit (ExceptionsAttribute_info attribute, Object ctx);
    Object visit (LineNumberTableAttribute_info attribute, Object ctx);
    Object visit (SourceFileAttribute_info attribute, Object ctx);
    Object visit (SyntheticAttribute_info attribute, Object ctx);
    Object visit (BridgeAttribute_info attribute, Object ctx);
    Object visit (InnerClassesAttribute_info attribute, Object ctx);

} // end of interface
// ----------------------------------------------------------------------------


text:
<?xml version="1.0" encoding="UTF-8"?>
<Form xmlns="http://v8.1c.ru/8.3/xcf/logform" xmlns:app="http://v8.1c.ru/8.2/managed-application/core" xmlns:cfg="http://v8.1c.ru/8.1/data/enterprise/current-config" xmlns:dcscor="http://v8.1c.ru/8.1/data-composition-system/core" xmlns:dcsset="http://v8.1c.ru/8.1/data-composition-system/settings" xmlns:ent="http://v8.1c.ru/8.1/data/enterprise" xmlns:lf="http://v8.1c.ru/8.2/managed-application/logform" xmlns:style="http://v8.1c.ru/8.1/data/ui/style" xmlns:sys="http://v8.1c.ru/8.1/data/ui/fonts/system" xmlns:v8="http://v8.1c.ru/8.1/data/core" xmlns:v8ui="http://v8.1c.ru/8.1/data/ui" xmlns:web="http://v8.1c.ru/8.1/data/ui/colors/web" xmlns:win="http://v8.1c.ru/8.1/data/ui/colors/windows" xmlns:xr="http://v8.1c.ru/8.3/xcf/readable" xmlns:xs="http://www.w3.org/2001/XMLSchema" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" version="2.1">
	<WindowOpeningMode>LockOwnerWindow</WindowOpeningMode>
	<AutoCommandBar name="ФормаКоманднаяПанель" id="-1"/>
	<ChildItems>
		<InputField name="Период" id="1">
			<DataPath>Запись.Period</DataPath>
			<Title>
				<v8:item>
					<v8:lang>ru</v8:lang>
					<v8:content>Дата</v8:content>
				</v8:item>
			</Title>
			<ContextMenu name="ПериодКонтекстноеМеню" id="2"/>
			<ExtendedTooltip name="ПериодExtendedTooltip" id="13"/>
		</InputField>
		<InputField name="Организация" id="3">
			<DataPath>Запись.Организация</DataPath>
			<ContextMenu name="ОрганизацияКонтекстноеМеню" id="4"/>
			<ExtendedTooltip name="ОрганизацияExtendedTooltip" id="14"/>
		</InputField>
		<InputField name="ПодразделениеОрганизации" id="7">
			<DataPath>Запись.ПодразделениеОрганизации</DataPath>
			<ContextMenu name="ПодразделениеОрганизацииКонтекстноеМеню" id="8"/>
			<ExtendedTooltip name="ПодразделениеОрганизацииExtendedTooltip" id="16"/>
		</InputField>
		<InputField name="ФизическоеЛицо" id="5">
			<DataPath>Запись.ФизическоеЛицо</DataPath>
			<ContextMenu name="ФизическоеЛицоКонтекстноеМеню" id="6"/>
			<ExtendedTooltip name="ФизическоеЛицоExtendedTooltip" id="15"/>
		</InputField>
		<InputField name="ТабельныйНомер" id="11">
			<DataPath>Запись.ТабельныйНомер</DataPath>
			<ContextMenu name="ТабельныйНомерКонтекстноеМеню" id="12"/>
			<ExtendedTooltip name="ТабельныйНомерExtendedTooltip" id="18"/>
		</InputField>
		<InputField name="ЗанимаемыхСтавок" id="9">
			<DataPath>Запись.ЗанимаемыхСтавок</DataPath>
			<ContextMenu name="ЗанимаемыхСтавокКонтекстноеМеню" id="10"/>
			<ExtendedTooltip name="ЗанимаемыхСтавокExtendedTooltip" id="17"/>
		</InputField>
	</ChildItems>
	<Attributes>
		<Attribute name="Запись" id="1">
			<Type>
				<v8:Type>cfg:InformationRegisterRecordManager._ДемоРаботникиОрганизаций</v8:Type>
			</Type>
			<MainAttribute>true</MainAttribute>
			<SavedData>true</SavedData>
		</Attribute>
	</Attributes>
</Form>


text:
ACCEPTED

#### According to
International Plant Names Index

#### Published in
Bull. Acad. Imp. Sci. Saint-Pétersbourg 31:64; Mélanges Biol. Bull. Phys. -Math. Acad. Imp. Sci. Saint-Pétersbourg 12:489. 1886 (Diagn. pl. nov. asiat. )

#### Original name
null

### Remarks
null


text:
<?php
$defflip = (!cfip()) ? exit(header('HTTP/1.1 401 Unauthorized')) : 1;

// Globally available variables
$debug->append('Global smarty variables', 3);

$debug->append('No cached page detected, loading smarty globals', 3);
// Defaults to get rid of PHP Notice warnings
$dDifficulty = 1;

// Fetch round shares
if (!$aRoundShares = $statistics->getRoundShares()) {
  $aRoundShares = array('valid' => 0, 'invalid' => 0);
}

if ($bitcoin->can_connect() === true) {
  $dDifficulty = $bitcoin->getdifficulty();
  $dNetworkHashrate = $bitcoin->getnetworkhashps();
} else {
  $dDifficulty = 1;
  $dNetworkHashrate = 0;
}

// Baseline pool hashrate for templates
if ( ! $dPoolHashrateModifier = $setting->getValue('statistics_pool_hashrate_modifier') ) $dPoolHashrateModifier = 1;
$iCurrentPoolHashrate =  $statistics->getCurrentHashrate();

// Avoid confusion, ensure our nethash isn't higher than poolhash
if ($iCurrentPoolHashrate > $dNetworkHashrate / 1000) $dNetworkHashrate = $iCurrentPoolHashrate;

// Baseline network hashrate for templates
if ( ! $dPersonalHashrateModifier = $setting->getValue('statistics_personal_hashrate_modifier') ) $dPersonalHashrateModifier = 1;
if ( ! $dNetworkHashrateModifier = $setting->getValue('statistics_network_hashrate_modifier') ) $dNetworkHashrateModifier = 1;

// Apply modifier now
$dNetworkHashrate = $dNetworkHashrate / 1000 * $dNetworkHashrateModifier;
$iCurrentPoolHashrate = $iCurrentPoolHashrate * $dPoolHashrateModifier;

// Share rate of the entire pool
$iCurrentPoolShareRate = $statistics->getCurrentShareRate();

// Active workers
if (!$iCurrentActiveWorkers = $worker->getCountAllActiveWorkers()) $iCurrentActiveWorkers = 0;

// Some settings to propagate to template
if (! $statistics_ajax_refresh_interval = $setting->getValue('statistics_ajax_refresh_interval')) $statistics_ajax_refresh_interval = 10;
if (! $statistics_ajax_long_refresh_interval = $setting->getValue('statistics_ajax_long_refresh_interval')) $statistics_ajax_long_refresh_interval = 10;

// Small helper array
$aHashunits = array( '1' => 'KH/s', '0.001' => 'MH/s', '0.000001' => 'GH/s', '0.000000001' => 'TH/s' );

// Global data for Smarty
$aGlobal = array(
  'hashunits' => array( 'pool' => $aHashunits[$dPoolHashrateModifier], 'network' => $aHashunits[$dNetworkHashrateModifier], 'personal' => $aHashunits[$dPersonalHashrateModifier]),
  'hashmods' => array( 'personal' => $dPersonalHashrateModifier ),
  'hashrate' => $iCurrentPoolHashrate,
  'nethashrate' => $dNetworkHashrate,
  'sharerate' => $iCurrentPoolShareRate,
  'workers' => $iCurrentActiveWorkers,
  'roundshares' => $aRoundShares,
  'fees' => $config['fees'],
  'confirmations' => $config['confirmations'],
  'reward' => $config['reward_type'] == 'fixed' ? $config['reward'] : $block->getAverageAmount(),
  'price' => $setting->getValue('price'),
  'twofactor' => $config['twofactor'],
  'csrf' => $config['csrf'],
  'config' => array(
    'recaptcha_enabled' => $setting->getValue('recaptcha_enabled'),
    'recaptcha_enabled_logins' => $setting->getValue('recaptcha_enabled_logins'),
    'disable_navbar' => $setting->getValue('disable_navbar'),
    'disable_navbar_api' => $setting->getValue('disable_navbar_api'),
    'disable_payouts' => $setting->getValue('disable_payouts'),
    'disable_manual_payouts' => $setting->getValue('disable_manual_payouts'),
    'disable_auto_payouts' => $setting->getValue('disable_auto_payouts'),
    'disable_contactform' => $setting->getValue('disable_contactform'),
    'disable_contactform_guest' => $setting->getValue('disable_contactform_guest'),
    'algorithm' => $config['algorithm'],
    'target_bits' => $config['target_bits'],
    'accounts' => $config['accounts'],
    'disable_invitations' => $setting->getValue('disable_invitations'),
    'disable_notifications' => $setting->getValue('disable_notifications'),
    'monitoring_uptimerobot_api_keys' => $setting->getValue('monitoring_uptimerobot_api_keys'),
    'statistics_ajax_refresh_interval' => $statistics_ajax_refresh_interval,
    'statistics_ajax_long_refresh_interval' => $statistics_ajax_long_refresh_interval,
    'price' => array( 'currency' => $config['price']['currency'] ),
    'targetdiff' => $config['difficulty'],
    'currency' => $config['currency'],
    'txfee_manual' => $config['txfee_manual'],
    'txfee_auto' => $config['txfee_auto'],
    'payout_system' => $config['payout_system'],
    'mp_threshold' => $config['mp_threshold'],
    'ap_threshold' => array(
      'min' => $config['ap_threshold']['min'],
      'max' => $config['ap_threshold']['max']
    )
  )
);

// Website configurations
$aGlobal['website']['name'] = $setting->getValue('website_name');
$aGlobal['website']['title'] = $setting->getValue('website_title');
$aGlobal['website']['slogan'] = $setting->getValue('website_slogan');
$aGlobal['website']['email'] = $setting->getValue('website_email');
$aGlobal['website']['api']['disabled'] = $setting->getValue('disable_api');
$aGlobal['website']['blockexplorer']['disabled'] = $setting->getValue('website_blockexplorer_disabled');
$aGlobal['website']['transactionexplorer']['disabled'] = $setting->getValue('website_transactionexplorer_disabled');
$aGlobal['website']['chaininfo']['disabled'] = $setting->getValue('website_chaininfo_disabled');
$aGlobal['website']['donors']['disabled'] = $setting->getValue('disable_donors');
$aGlobal['website']['about']['disabled'] = $setting->getValue('disable_about');
$setting->getValue('website_blockexplorer_url') ? $aGlobal['website']['blockexplorer']['url'] = $setting->getValue('website_blockexplorer_url') : $aGlobal['website']['blockexplorer']['url'] = 'http://explorer.litecoin.net/block/';
$setting->getValue('website_transactionexplorer_url') ? $aGlobal['website']['transactionexplorer']['url'] = $setting->getValue('website_transactionexplorer_url') : $aGlobal['website']['transactionexplorer']['url'] = 'http://explorer.litecoin.net/tx/';
$setting->getValue('website_chaininfo_url') ? $aGlobal['website']['chaininfo']['url'] = $setting->getValue('website_chaininfo_url') : $aGlobal['website']['chaininfo']['url'] = 'http://allchains.info';

// Google Analytics
$aGlobal['statistics']['analytics']['enabled'] = $setting->getValue('statistics_analytics_enabled');
$aGlobal['statistics']['analytics']['code'] = $setting->getValue('statistics_analytics_code');

// ACLs
$aGlobal['acl']['pool']['statistics'] = $setting->getValue('acl_pool_statistics');
$aGlobal['acl']['block']['statistics'] = $setting->getValue('acl_block_statistics');
$aGlobal['acl']['round']['statistics'] = $setting->getValue('acl_round_statistics');
$aGlobal['acl']['blockfinder']['statistics'] = $setting->getValue('acl_blockfinder_statistics');
$aGlobal['acl']['voting']['statistics'] = $setting->getValue('acl_voting_statistics');
$aGlobal['acl']['uptime']['statistics'] = $setting->getValue('acl_uptime_statistics');
$aGlobal['acl']['graphs']['statistics'] = $setting->getValue('acl_graphs_statistics');
$aGlobal['acl']['donors']['page'] = $setting->getValue('acl_donors_page');
$aGlobal['acl']['about']['page'] = $setting->getValue('acl_about_page');
$aGlobal['acl']['contactform'] = $setting->getValue('acl_contactform');
$aGlobal['acl']['chat']['page'] = $setting->getValue('acl_chat_page', 2);

// We don't want these session infos cached
if (@$_SESSION['USERDATA']['id']) {
  $aGlobal['userdata'] = $_SESSION['USERDATA']['id'] ? $user->getUserData($_SESSION['USERDATA']['id']) : array();
  $aGlobal['userdata']['balance'] = $transaction->getBalance($_SESSION['USERDATA']['id']);

  // Other userdata that we can cache savely
  $aGlobal['userdata']['shares'] = $statistics->getUserShares($_SESSION['USERDATA']['username'], $_SESSION['USERDATA']['id']);
  $aUserMiningStats = $statistics->getUserMiningStats($_SESSION['USERDATA']['username'], $_SESSION['USERDATA']['id']);
  $aGlobal['userdata']['rawhashrate'] = $aUserMiningStats['hashrate'];
  $aGlobal['userdata']['hashrate'] = $aGlobal['userdata']['rawhashrate'] * $dPersonalHashrateModifier;
  $aGlobal['userdata']['sharerate'] = $aUserMiningStats['sharerate'];
  $aGlobal['userdata']['sharedifficulty'] = $aUserMiningStats['avgsharediff'];

  switch ($config['payout_system']) {
  case 'prop':
    // Some estimations
    $aEstimates = $statistics->getUserEstimates($aRoundShares, $aGlobal['userdata']['shares'], $aGlobal['userdata']['donate_percent'], $aGlobal['userdata']['no_fees']);
    $aGlobal['userdata']['estimates'] = $aEstimates;
    break;
  case 'pplns':
    $aGlobal['pplns']['target'] = $config['pplns']['shares']['default'];
    if ($aLastBlock = $block->getLast()) {
      if ($iAvgBlockShares = round($block->getAvgBlockShares($aLastBlock['height'], $config['pplns']['blockavg']['blockcount']))) {
        $aGlobal['pplns']['target'] = $iAvgBlockShares;
      }
    }
    $aEstimates = $statistics->getUserEstimates($aRoundShares, $aGlobal['userdata']['shares'], $aGlobal['userdata']['donate_percent'], $aGlobal['userdata']['no_fees']);
    $aGlobal['userdata']['estimates'] = $aEstimates;
    break;
  case 'pps':
    $aGlobal['userdata']['pps']['unpaidshares'] = $statistics->getUserUnpaidPPSShares($_SESSION['USERDATA']['username'], $_SESSION['USERDATA']['id'], $setting->getValue('pps_last_share_id'));
    $aGlobal['ppsvalue'] = number_format($statistics->getPPSValue(), 12);
    $aGlobal['poolppsvalue'] = $aGlobal['ppsvalue'] * pow(2, $config['difficulty'] - 16);
    $aGlobal['userdata']['estimates'] = $statistics->getUserEstimates($aGlobal['userdata']['sharerate'], $aGlobal['userdata']['sharedifficulty'], $aGlobal['userdata']['donate_percent'], $aGlobal['userdata']['no_fees'], $aGlobal['ppsvalue']);
    break;
  }

  // Site-wide notifications, based on user events
  if ($aGlobal['userdata']['balance']['confirmed'] >= $config['ap_threshold']['max'])
    $_SESSION['POPUP'][] = array('CONTENT' => 'You have exceeded the pools configured ' . $config['currency'] . ' warning threshold. Please initiate a transfer!', 'TYPE' => 'errormsg');
  if ($user->getUserFailed($_SESSION['USERDATA']['id']) > 0)
    $_SESSION['POPUP'][] = array('CONTENT' => 'You have ' . $user->getUserFailed($_SESSION['USERDATA']['id']) . ' failed login attempts! Reset Counter', 'TYPE' => 'errormsg');
}

if ($setting->getValue('maintenance'))
  $_SESSION['POPUP'][] = array('CONTENT' => 'This pool is currently in maintenance mode.', 'TYPE' => 'warning');
if ($motd = $setting->getValue('system_motd'))
  $_SESSION['POPUP'][] = array('CONTENT' => $motd, 'TYPE' => 'info');

// So we can display additional info
$smarty->assign('DEBUG', $config['DEBUG']);

// Lets check for our cron status and render a message
require_once(INCLUDE_DIR . '/config/monitor_crons.inc.php');
$bMessage = false;
$aCronMessage[] = 'We are investingating issues in the backend. Your shares and hashrate are safe and we will fix things ASAP.

';
foreach ($aMonitorCrons as $strCron) {
  if ($monitoring->isDisabled($strCron) == 1) {
    $bMessage = true;
    switch ($strCron) {
    case 'payouts':
      $aCronMessage[] = '
 Payouts disabled, you will not receive any coins to your offline wallet for the time being
';
      break;
    case 'findblock':
      $aCronMessage[] = '
 Findblocks disabled, new blocks will currently not show up in the frontend
';
      break;
    case 'blockupdate':
      $aCronMessage[] = '
 Blockupdate disabled, blocks and transactions confirmations are delayed
';
      break;
    case 'pplns_payout':
      $aCronMessage[] = '
 PPLNS payout disabled, round credit transactions are delayed
';
      break;
    case 'prop_payout':
      $aCronMessage[] = '
 Proportional payout disabled, round credit transactions are delayed
';
      break;
    case 'pps_payout':
      $aCronMessage[] = '
 PPS payout disabled, share credit transactions are delayed
';
      break;
    }
  }
}
if ($bMessage)
  $_SESSION['POPUP'][] = array('CONTENT' => implode($aCronMessage, ''));

// Make it available in Smarty
$smarty->assign('PATH', 'site_assets/' . THEME);
$smarty->assign('GLOBALASSETS', 'site_assets/global');
$smarty->assign('GLOBAL', $aGlobal);
?>


text:
CREATE TABLE [dbo].[DynSettings] (
    [ID]                      BIGINT           IDENTITY (1, 1) NOT NULL,
    [DBVersion]               REAL             NOT NULL,
    [DevelopmentMode]         BIT              NOT NULL,
    [DefaultRecordsPerMaster] INT              NOT NULL,
    [DefaultRecordsPerChild]  INT              NOT NULL,
    [PlatformKey]             UNIQUEIDENTIFIER NOT NULL,
    [PublicAccess]            BIT              NOT NULL,
    [PublicSignUP]            BIT              NOT NULL,
    [EnableSystemLogger]      BIT              NOT NULL,
    [App_TimeZone]            INT              NOT NULL,
    [PlatformTitle]           NVARCHAR (128)   NULL,
    [LastCentralSync]         DATETIME         NOT NULL,
    [DeploymentTimeStamp]     DATETIME         NOT NULL,
    [NotifcationMail]         NVARCHAR (50)    NULL,
    [SMTPAddress]             NVARCHAR (50)    NULL,
    [SMTPPort]                INT              NULL,
    CONSTRAINT [PK_DynSettings] PRIMARY KEY CLUSTERED ([ID] ASC)
);


text:
@interface BHTransitionFromFirstToSecond : NSObject<UIViewControllerAnimatedTransitioning>

@end


text:
export * from './data';
export * from './discord';
export * from './logging';
export * from './moment';
export * from './socket';


text:
require 'rails_helper'

RSpec.describe "photos/edit", :type => :view do
  # before(:each) do
  #   @photo = assign(:photo, Photo.create!(
  #     :description => "MyString",
  #     :uploader_id => 1,
  #     :url => "MyString"
  #   ))
  # end

  # it "renders the edit photo form" do
  #   render

  #   assert_select "form[action=?][method=?]", photo_path(@photo), "post" do

  #     assert_select "input#photo_description[name=?]", "photo[description]"

  #     assert_select "input#photo_uploader_id[name=?]", "photo[uploader_id]"

  #     assert_select "input#photo_url[name=?]", "photo[url]"
  #   end
  # end
end


text:
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
  "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">

    <meta http-equiv="Content-Type" content="text/html; charset=utf-8" />

    <title>Foreword: Why Paver? — Paver 1.1.0 documentation</title>

    <link rel="stylesheet" href="_static/default.css" type="text/css" />
    <link rel="stylesheet" href="_static/pygments.css" type="text/css" />

    <link rel="top" title="Paver 1.1.0 documentation" href="index.html" />
    <link rel="next" title="Paver's Features" href="features.html" />
    <link rel="prev" title="Paver: Easy Scripting for Software Projects" href="index.html" />

Navigation

          index

          modules |

          next |

          previous |

Paver 1.1.0 documentation »

Foreword: Why Paver?¶

Paver occupies a sweet spot in the python toolset, the design is sound,
it’s easier than mud to work with at a basic level, and it has a nice grade
of descent into more advanced things.

—David Eyk

I didn’t want to make a new build tool. Honestly. The main reason that I created Paver
is...

The Declarative/Imperative Divide¶

When you solve the same problem repeatedly, patterns emerge and you’re able to easily
see ways to reduce how much effort is involved in solving that problem. Often
times, you’ll end up with a declarative solution. Python’s standard distutils
is a declarative solution. In your call to the <tt class="docutils literal">setup()</tt> function, you declare
some metadata about your project and provide a list of the parts and you end
up with a nice command line interface. That command line interface knows how to
make redistributable tarballs (and eggs if you have setuptools), install the
package, build C extensions and more.

zc.buildout does a similar thing for deployments. Declare the parts of your system
and specify a recipe for each part (each recipe with its own collection of options)
and you can build up a consistent system with one command.

These tools sound great, don’t they? They are great. As long as you don’t need
to customize the capabilities they provide. For example, it’s not uncommon that
you’ll need to move some file here, create some directory there, etc. Then what?

In an imperative system, you’d just add the few lines of code you need.

For distutils and zc.builout and other similar tools, the answer usually involves
extra boilerplate surrounding the code in question and then installing that code somewhere. You basically have to create declarative syntax for something that is a one-off rather than a larger, well-understood problem. And, for distutils and zc.buildout, you have to use two entirely different mechanisms.

Consistency for Project Related Tasks¶

And that’s the next thing that bothered me with the state of Python tools. It
would be nice to have a consistent interface in command line and configuration
for the tools that I use to work with my projects. Every tool I bring in to
the project adds new command line interfaces, more config files (and some of
those config files duplicate project metadata!).

That’s Why Paver Is Here¶

Paver is set up to provide declarative handling of common tasks with as easy
an escape hatch to imperative programming as possible (just add a function
with a decorator in the same file). Your project-related configuration
options are all together and all accessible to different parts of your
build and deployment setup. And the language used for everything is Python,
so you’re not left guessing how to do a <tt class="docutils literal">for</tt> loop.

Of course, rebuilding the great infrastructure provided by tools like distutils
makes no sense. So, Paver just uses distutils and other tools directly.

Paver also goes beyond just providing an extension mechanism for distutils.
It adds a bunch of useful capabilities for things like working with files
and directories, elegantly handling sample code for your documentation and
building bootstrap scripts to allow your software to easily be installed
in an isolated virtualenv.

I’m already using Paver for SitePen’s Support service user interface
project and I use Paver to manage Paver itself! It’s been working out
great for me, and it’s set up in such a way that whatever kind of scripting
your project needs it should be pretty simple with Paver.

Making the Switch is Easy¶

Finally, I’ve put some time into making sure that moving a project from
distutils to Paver is easy for everyone involved (people making the
projects and people using the projects). Check out the
Getting Started Guide to see an example of how
a project moves from distutils to Paver (even maintaining the
<tt class="docutils literal">python setup.py install</tt> command that everyone’s used to!)

Thanks for reading!

Kevin Dangoor
May 2008

Table Of Contents

Foreword: Why Paver?

The Declarative/Imperative Divide

Consistency for Project Related Tasks

That’s Why Paver Is Here

Making the Switch is Easy

Previous topic

Paver: Easy Scripting for Software Projects

Next topic

Paver’s Features

This Page

Show Source

Quick search

    <form class="search" action="search.html" method="get">
      <input type="text" name="q" />
      <input type="submit" value="Go" />
      <input type="hidden" name="check_keywords" value="yes" />
      <input type="hidden" name="area" value="default" />
    </form>

    Enter search terms or a module, class or function name.

Navigation

          index

          modules |

          next |

          previous |

Paver 1.1.0 documentation »

        © Copyright 2008, SitePen, Inc..
      Last updated on Jul 30, 2012.
      Created using Sphinx 1.1.3.


text:
var game: BrickBreaker;

class Ball {
    private velocity: number;
    private radius: number;
    private speedX: number;
    private speedY: number;
    private x: number;
    private y: number;

    constructor() {
        this.radius = 5;
        this.x = 400;
        this.y = 300;
        this.speedX = 5;
        this.speedY = 5;
    }

    update(boundx, boundy) {
        this.x += this.speedX;
        this.y += this.speedY;

        if (this.x > boundx || this.x < 0)
            this.speedX = -this.speedX;
        if (this.y > boundy || this.y < 0)
            this.speedY = -this.speedY;
    }

    render(context : CanvasRenderingContext2D) {
        context.fillStyle = "rgb(255,0,0)";
        context.beginPath();
        context.arc(this.x - this.radius, this.y - this.radius, this.radius, 0, 2 * Math.PI, false);
        context.stroke();
    }
}

class Brick {
    colour: string;
    width: number;
    height: number;
    alive: boolean;
    x: number;
    y: number;

    constructor(x ,y) {
        this.colour = "rgb(" + Math.floor(Math.random() * 255)
            + "," + Math.floor(Math.random() * 255) + ","
            + Math.floor(Math.random() * 255) + ")";
        this.width = 50;
        this.height = 10;
        this.alive = true;
        this.x = x * this.width;
        this.y = y * this.height + 50;
    }

    render(context: CanvasRenderingContext2D, x, y) {
        if (this.alive) {
            context.fillStyle = this.colour;
            context.fillRect(this.x, this.y, this.width, this.height);
        }
    }
}

class Player extends Brick {
    maxPosition: number;

    constructor(maxPosition) {
        super(0, 0);
        this.x = (maxPosition / 2) - 25;
        this.y = 380;
        this.colour = "rgb(0,0,0)";
        this.maxPosition = maxPosition;
    }

    moveLeft() {
        this.x -= 10;

        if (this.x < this.width / 2) {
            this.x = this.width / 2;
        }
    }

    moveRight() {
        this.x += 10;

        if (this.x > this.maxPosition - this.width / 2) {
            this.x = this.maxPosition - this.width / 2;
        }
    }

    render(context: CanvasRenderingContext2D) {
        context.fillStyle = this.colour;
        context.fillRect(this.x - this.width / 2, this.y, this.width, this.height);
    }
}

class BrickBreaker {
    private canvas : HTMLCanvasElement;
    private bricks: Array<Array<Brick>>;
    private player: Player;
    private ball: Ball;
    private renderTimer: number;

    constructor(canvas : HTMLCanvasElement) {
        this.canvas = canvas;
        this.bricks = new Array<Array<Brick>>(5);
        this.player = new Player(canvas.width);
        this.ball = new Ball();

        for (var i = 0; i < this.bricks.length; i++) {
            this.bricks[i] = new Array<Brick>(16);
            for (var j = 0; j < this.bricks[i].length; j ++) {
                this.bricks[i][j] = new Brick(j, i);
            }
        }

        var fps = 30;
        this.renderTimer = setInterval(function() {
            game.update();
            game.render();
        }, fps);
    }

    private update() {
        this.ball.update(this.canvas.width, this.canvas.height);
    }

    private render() {
        var context = this.canvas.getContext("2d");
        context.fillStyle = "rgb(255, 255,255)";
        context.clearRect(0, 0, this.canvas.width, this.canvas.height);

        this.player.render(context);
        this.ball.render(context);

        for (var y = 0; y < this.bricks.length; y++) {
            for (var x = 0; x < this.bricks[y].length; x++) {
                var brick = this.bricks[y][x];
                brick.render(context, x, y);
            }
        }
    }

    play() {
        this.update();
        this.render();
    }

    input(event) {
        //Left arrow;
        if (event.keyCode === 37) {
            game.player.moveLeft();
        }

        //Right arrow;
        if (event.keyCode === 39) {
            game.player.moveRight();
        }
    }
}

window.onload = () => {
    var canvas = document.getElementsByTagName("canvas")[0];
    game = new BrickBreaker(canvas);
    document.onkeydown = game.input;
};


text:
package java.util.spi;

import java.util.Locale;

/**
 *

 * This is the super class of all the locale sensitive service provider
 * interfaces (SPIs).
 *

 * Locale sensitive  service provider interfaces are interfaces that
 * correspond to locale sensitive classes in the java.text
 * and java.util packages. The interfaces enable the
 * construction of locale sensitive objects and the retrieval of
 * localized names for these packages. Locale sensitive factory methods
 * and methods for name retrieval in the java.text and
 * java.util packages use implementations of the provider
 * interfaces to offer support for locales beyond the set of locales
 * supported by the Java runtime environment itself.
 *
 *
Packaging of Locale Sensitive Service Provider Implementations

 * Implementations of these locale sensitive services are packaged using the
 * Java Extension Mechanism
 * as installed extensions.  A provider identifies itself with a
 * provider-configuration file in the resource directory META-INF/services,
 * using the fully qualified provider interface class name as the file name.
 * The file should contain a list of fully-qualified concrete provider class names,
 * one per line. A line is terminated by any one of a line feed ('\n'), a carriage
 * return ('\r'), or a carriage return followed immediately by a line feed. Space
 * and tab characters surrounding each name, as well as blank lines, are ignored.
 * The comment character is '#' ('\u0023'); on each line all characters following
 * the first comment character are ignored. The file must be encoded in UTF-8.
 *

 * If a particular concrete provider class is named in more than one configuration
 * file, or is named in the same configuration file more than once, then the
 * duplicates will be ignored. The configuration file naming a particular provider
 * need not be in the same jar file or other distribution unit as the provider itself.
 * The provider must be accessible from the same class loader that was initially
 * queried to locate the configuration file; this is not necessarily the class loader
 * that loaded the file.
 *

 * For example, an implementation of the
 * {@link java.text.spi.DateFormatProvider DateFormatProvider} class should
 * take the form of a jar file which contains the file:
 *

 * META-INF/services/java.text.spi.DateFormatProvider
 *

 * And the file java.text.spi.DateFormatProvider should have
 * a line such as:
 *

 * com.foo.DateFormatProviderImpl
 *

 * which is the fully qualified class name of the class implementing
 * DateFormatProvider.
 *
Invocation of Locale Sensitive Services

 *

 * Locale sensitive factory methods and methods for name retrieval in the
 * java.text and java.util packages invoke
 * service provider methods when needed to support the requested locale.
 * The methods first check whether the Java runtime environment itself
 * supports the requested locale, and use its support if available.
 * Otherwise, they call the {@link #isSupportedLocale(Locale) isSupportedLocale}
 * methods of installed providers for the appropriate interface to find one that
 * supports the requested locale. If such a provider is found, its other
 * methods are called to obtain the requested object or name.  When checking
 * whether a locale is supported, the
 * locale's extensions are ignored by default. (If locale's extensions should
 * also be checked, the {@code isSupportedLocale} method must be overridden.)
 * If neither the Java runtime environment itself nor an installed provider
 * supports the requested locale, the methods go through a list of candidate
 * locales and repeat the availability check for each until a match is found.
 * The algorithm used for creating a list of candidate locales is same as
 * the one used by ResourceBundle by default (see
 * {@link java.util.ResourceBundle.Control#getCandidateLocales getCandidateLocales}
 * for the details).  Even if a locale is resolved from the candidate list,
 * methods that return requested objects or names are invoked with the original
 * requested locale including {@code Locale} extensions. The Java runtime
 * environment must support the root locale for all locale sensitive services in
 * order to guarantee that this process terminates.
 *

 * Providers of names (but not providers of other objects) are allowed to
 * return null for some name requests even for locales that they claim to
 * support by including them in their return value for
 * getAvailableLocales. Similarly, the Java runtime
 * environment itself may not have all names for all locales that it
 * supports. This is because the sets of objects for which names are
 * requested can be large and vary over time, so that it's not always
 * feasible to cover them completely. If the Java runtime environment or a
 * provider returns null instead of a name, the lookup will proceed as
 * described above as if the locale was not supported.
 *

 * Starting from JDK8, the search order of locale sensitive services can
 * be configured by using the "java.locale.providers" system property.
 * This system property declares the user's preferred order for looking up
 * the locale sensitive services separated by a comma. It is only read at
 * the Java runtime startup, so the later call to System.setProperty() won't
 * affect the order.
 *

 * For example, if the following is specified in the property:
 *

 * java.locale.providers=SPI,JRE
 *

 * where "SPI" represents the locale sensitive services implemented in the
 * installed SPI providers, and "JRE" represents the locale sensitive services
 * in the Java Runtime Environment, the locale sensitive services in the SPI
 * providers are looked up first.
 *

 * There are two other possible locale sensitive service providers, i.e., "CLDR"
 * which is a provider based on Unicode Consortium's
 * CLDR Project, and "HOST" which is a
 * provider that reflects the user's custom settings in the underlying operating
 * system. These two providers may not be available, depending on the Java Runtime
 * Environment implementation. Specifying "JRE,SPI" is identical to the default
 * behavior, which is compatibile with the prior releases.
 *
 * @since        1.6
 */
public abstract class LocaleServiceProvider {

    /**
     * Sole constructor.  (For invocation by subclass constructors, typically
     * implicit.)
     */
    protected LocaleServiceProvider() {
    }

    /**
     * Returns an array of all locales for which this locale service provider
     * can provide localized objects or names. This information is used to
     * compose {@code getAvailableLocales()} values of the locale-dependent
     * services, such as {@code DateFormat.getAvailableLocales()}.
     *
     *
The array returned by this method should not include two or more
     * {@code Locale} objects only differing in their extensions.
     *
     * @return An array of all locales for which this locale service provider
     * can provide localized objects or names.
     */
    public abstract Locale[] getAvailableLocales();

    /**
     * Returns {@code true} if the given {@code locale} is supported by
     * this locale service provider. The given {@code locale} may contain
     * extensions that should be
     * taken into account for the support determination.
     *
     *
The default implementation returns {@code true} if the given {@code locale}
     * is equal to any of the available {@code Locale}s returned by
     * {@link #getAvailableLocales()} with ignoring any extensions in both the
     * given {@code locale} and the available locales. Concrete locale service
     * provider implementations should override this method if those
     * implementations are {@code Locale} extensions-aware. For example,
     * {@code DecimalFormatSymbolsProvider} implementations will need to check
     * extensions in the given {@code locale} to see if any numbering system is
     * specified and can be supported. However, {@code CollatorProvider}
     * implementations may not be affected by any particular numbering systems,
     * and in that case, extensions for numbering systems should be ignored.
     *
     * @param locale a {@code Locale} to be tested
     * @return {@code true} if the given {@code locale} is supported by this
     *         provider; {@code false} otherwise.
     * @throws NullPointerException
     *         if the given {@code locale} is {@code null}
     * @see Locale#hasExtensions()
     * @see Locale#stripExtensions()
     * @since 1.8
     */
    public boolean isSupportedLocale(Locale locale) {
        locale = locale.stripExtensions(); // throws NPE if locale == null
        for (Locale available : getAvailableLocales()) {
            if (locale.equals(available.stripExtensions())) {
                return true;
}
        }
        return false;
    }
}


text:
@extends('layout.bootstraplogin.index')

@section('content')
@if (Session::has('message'))

    <button type="button" class="close" data-dismiss="alert" aria-hidden="true">×</button>
    {{ Session::get('message') }}

@endif

                    Form Login Administrator

                    <form class="form-horizontal" action="<?php echo URL::to("/login/proses"); ?>" method="post">

                            Email

                                <input type="text" name="email" class="form-control " placeholder="john@doe.com">

 {{ $errors->first('email') }}

                            Password

                                <input type="password" name="password" class="form-control" placeholder="Password">

 {{ $errors->first('password') }}

                                <button type="submit" class="btn btn-info"> Login</button>
                                <button type="reset" class="btn btn-danger"> Reset</button>

                    </form>

@stop