text:
<?php

return [

    // Setup form fields
    'setup' => [
        'email'            => 'E-Mail',
        'username'         => 'Benutzername',
        'password'         => 'Passwort',
        'site_name'        => 'Seitenname',
        'site_domain'      => 'Domain ihrer Seite',
        'site_timezone'    => 'Wählen Sie Ihre Zeitzone',
        'site_locale'      => 'Wählen Sie Ihre Sprache',
        'enable_google2fa' => 'Google Zwei-Faktor-Authentifizierung aktivieren',
        'cache_driver'     => 'Cache-Treiber',
        'session_driver'   => 'Sitzungs-Treiber',
    ],

    // Login form fields
    'login' => [
        'login'         => 'Nazwa użytkownika lub e-mail',
        'email'         => 'E-Mail',
        'password'      => 'Passwort',
        '2fauth'        => 'Authentifizierungscode',
        'invalid'       => 'Nieprawidłowa nazwa użytkownika lub hasło',
        'invalid-token' => 'Token ist ungültig',
        'cookies'       => 'Sie müssen Cookies aktivieren um sich anzumelden.',
        'rate-limit'    => 'Rate limit exceeded.',
    ],

    // Incidents form fields
    'incidents' => [
        'name'               => 'Name',
        'status'             => 'Status',
        'component'          => 'Komponente',
        'message'            => 'Nachricht',
        'message-help'       => 'Sie können auch Markdown verwenden.',
        'scheduled_at'       => 'Für wann ist die Wartung geplant?',
        'incident_time'      => 'Wann ist dieser Vorfall aufgetreten?',
        'notify_subscribers' => 'Abonnenten benachrichtigen',
        'visibility'         => 'Widoczność zdarzenia',
        'public'             => 'Öffentlich sichtbar',
        'logged_in_only'     => 'Nur für angemeldete Benutzer sichtbar',
        'templates'          => [
            'name'     => 'Name',
            'template' => 'Vorlage',
            'twig'     => 'Szablony wydarzeń mogą korzystać z języka szablonów Twig.',
        ],
    ],

    // Components form fields
    'components' => [
        'name'        => 'Name',
        'status'      => 'Status',
        'group'       => 'Gruppe',
        'description' => 'Beschreibung',
        'link'        => 'Link',
        'tags'        => 'Schlagwörter',
        'tags-help'   => 'Durch Kommata trennen.',
        'enabled'     => 'Component enabled?',

        'groups' => [
            'name'               => 'Name',
            'collapsing'         => 'Wybierz widoczność grupy',
            'visible'            => 'Zawsze rozwinięte',
            'collapsed'          => 'Domyślnie zwiń grupę',
            'collapsed_incident' => 'Zwiń grupę, ale rozwiń ją w razie problemów',
        ],
    ],

    // Metric form fields
    'metrics' => [
        'name'             => 'Name',
        'suffix'           => 'Suffix',
        'description'      => 'Beschreibung',
        'description-help' => 'Sie können auch Markdown verwenden.',
        'display-chart'    => 'Diagramm auf der Statusseite anzeigen?',
        'default-value'    => 'Standardwert',
        'calc_type'        => 'Berechnung der Metrik',
        'type_sum'         => 'Summe',
        'type_avg'         => 'Durchschnitt',
        'places'           => 'Miejsca dziesiętne',
        'default_view'     => 'Domyślny widok',
        'threshold'        => 'Ile minut przerwy między punktami metrycznymi?',

        'points' => [
            'value' => 'Wert',
        ],
    ],

    // Settings
    'settings' => [
        /// Application setup
        'app-setup' => [
            'site-name'              => 'Seitenname',
            'site-url'               => 'URL ihrer Seite',
            'display-graphs'         => 'Graphen auf der Statusseite anzeigen?',
            'about-this-page'        => 'Über diese Seite',
            'days-of-incidents'      => 'Wie viele Tage mit Vorfällen sollen gezeigt werden?',
            'banner'                 => 'Banner',
            'banner-help'            => 'Es wird empfohlen, dass Sie keine Dateien die breiter als 930 Pixel sind hochladen .',
            'subscribers'            => 'Personen die Anmeldung für E-Mail-Benachrichtigung erlauben?',
            'automatic_localization' => 'Automatycznie tłumaczyć twoją stronę statusu na język odwiedzającego?',
        ],
        'analytics' => [
            'analytics_google'       => 'Google Analytics Code',
            'analytics_gosquared'    => 'GoSquared Analytics Code',
            'analytics_piwik_url'    => 'URL der Piwik-Instanz (ohne http(s)://)',
            'analytics_piwik_siteid' => 'Piwik\'s Seiten-ID',
        ],
        'localization' => [
            'site-timezone'        => 'Zeitzone ihrer Seite',
            'site-locale'          => 'Sprache ihrer Seite',
            'date-format'          => 'Datumsformat',
            'incident-date-format' => 'Vorfall Zeitstempel-Format',
        ],
        'security' => [
            'allowed-domains'      => 'Erlaubte Domains',
            'allowed-domains-help' => 'Durch Kommata trennen. Die oben genannte Domain ist standardmäßig erlaubt.',
        ],
        'stylesheet' => [
            'custom-css' => 'Niestandardowy arkusz stylów',
        ],
        'theme' => [
            'background-color'        => 'Kolor tła',
            'background-fills'        => 'Wypełnianie tła (komponenty, wydarzenia, stopka)',
            'banner-background-color' => 'Banner Background Color',
            'banner-padding'          => 'Banner Padding',
            'fullwidth-banner'        => 'Enable fullwidth banner?',
            'text-color'              => 'Kolor tekstu',
            'dashboard-login'         => 'Pokazywać przycisk panelu głównego w stopce?',
            'reds'                    => 'Czerwony (używany przy błędach)',
            'blues'                   => 'Niebieski (używany przy informacjach)',
            'greens'                  => 'Zielony (używany przy powodzeniu)',
            'yellows'                 => 'Żółty (używany przy ostrzeżeniach)',
            'oranges'                 => 'Pomarańczowy (używany przy ogłoszeniach)',
            'metrics'                 => 'Wypełnienie metryki',
            'links'                   => 'Łącza',
        ],
    ],

    'user' => [
        'username'       => 'Benutzername',
        'email'          => 'E-Mail',
        'password'       => 'Passwort',
        'api-token'      => 'API Token',
        'api-token-help' => 'Wenn sie ihren API-Token neu generieren, können bestehende Anwendungen nicht mehr auf Cachet zugreifen.',
        'gravatar'       => 'Change your profile picture at Gravatar.',
        'user_level'     => 'Poziom użytkownika',
        'levels'         => [
            'admin' => 'Administrator',
            'user'  => 'Użytkownik',
        ],
        '2fa' => [
            'help' => 'Die Zwei-Faktor-Authentifizierung erhöht die Sicherheit Ihres Kontos. Sie benötigen Google Authenticator oder eine ähnliche App auf Ihrem Mobilgerät. Beim Anmelden werden sie aufgefordert, einen Token einzugeben, der von der App generiert wird.',
        ],
        'team' => [
            'description' => 'Invite your team members by entering their email addresses here.',
            'email'       => 'Email #:id',
        ],
    ],

    // Buttons
    'add'    => 'Hinzufügen',
    'save'   => 'Speichern',
    'update' => 'Aktualisieren',
    'create' => 'Erstellen',
    'edit'   => 'Bearbeiten',
    'delete' => 'Löschen',
    'submit' => 'Abschicken',
    'cancel' => 'Abbrechen',
    'remove' => 'Entfernen',
    'invite' => 'Zaproś',
    'signup' => 'Zarejestruj się',

    // Other
    'optional' => '* optional',
];

redpajama_set_name: RedPajamaGithub


text:
<?xml version="1.0" encoding="utf-8"?>
<PreferenceScreen xmlns:android="http://schemas.android.com/apk/res/android"
    android:key="pref_screen">

    <PreferenceCategory android:title="Content Suggestions">

        <Preference
            android:key="pref_suggest_places"
            android:summary="Suggest unique places"
            android:title="Places" />

        <Preference
            android:key="pref_suggest_nature_events"
            android:summary="Suggest disasters and good acts"
            android:title="Nature Events" />

        <Preference
            android:key="pref_suggest_hall_of_honor"
            android:summary="Suggest people, websites, organizations, apps and more"
            android:title="Hall of Honor" />

    </PreferenceCategory>

    <PreferenceCategory android:title="Options">

        <Preference
            android:key="pref_data_base"
            android:summary="All of your bookmarked Places will be deleted"
            android:title="Delete Bookmarks" />

    </PreferenceCategory>

    <PreferenceCategory android:title="Misc">

        <Preference
            android:key="pref_changelog"
            android:summary="Check out the latest changes"
            android:title="Changelog" />

        <Preference
            android:key="pref_github"
            android:summary="Places is Open Source"
            android:title="GitHub" />

    </PreferenceCategory>

</PreferenceScreen>


text:
@interface BXQuickMessagesBubleModel ()

@property (nonatomic, strong) UIImage *resizableImage;

@end

@implementation BXQuickMessagesBubleModel

+ (BXQuickMessagesBubleModel *)defaultBubleWithTop:(BOOL)top left:(BOOL)left
{
    if (top) {
        if (left) {
            return [self defaultLeftTopBuble];
        }else {
            return [self defaultRightTopBuble];
        }
    }else {
        if (left) {
            return [self defaultLeftBottomBuble];
        }else {
            return [self defaultRightBottomBuble];
        }
    }
}

+ (BXQuickMessagesBubleModel *)defaultLeftTopBuble
{
    BXQuickMessagesBubleModel *buble = [[BXQuickMessagesBubleModel alloc] init];

    buble.maskBubleImage = @"weChatBubble_Receiving_Solid";
    buble.defaultMaskColor = [UIColor colorWithRed:0xff/255.0 green:0xff/255.0 blue:0xff/255.0 alpha:1.0];
    buble.defaultBorderColor = [UIColor colorWithRed:0xcd/255.0 green:0xcb/255.0 blue:0xca/255.0 alpha:1.0];
    buble.resizableCapInsets = UIEdgeInsetsMake(34, 20, 10, 40);
    buble.bubleContentInsets = UIEdgeInsetsMake(13, 21, 13, 16);
    buble.borderWidthInsets = UIEdgeInsetsMake(0.5, 0.7, 0.5, 0.5);
    buble.defaultTextColor = [UIColor blackColor];

    return buble;
}

+ (BXQuickMessagesBubleModel *)defaultLeftBottomBuble
{
    BXQuickMessagesBubleModel *buble = [[BXQuickMessagesBubleModel alloc] init];

    buble.maskBubleImage = @"weChatBubble_Receiving_Solid";
    buble.defaultMaskColor = [UIColor colorWithRed:0xff/255.0 green:0xff/255.0 blue:0xff/255.0 alpha:1.0];
    buble.defaultBorderColor = [UIColor colorWithRed:0xcd/255.0 green:0xcb/255.0 blue:0xca/255.0 alpha:1.0];
    buble.resizableCapInsets = UIEdgeInsetsMake(10, 40, 34, 20);
    buble.bubleContentInsets = UIEdgeInsetsMake(13, 21, 13, 16);
    buble.borderWidthInsets = UIEdgeInsetsMake(0.5, 0.7, 0.5, 0.5);
    buble.defaultTextColor = [UIColor blackColor];

    return buble;
}

+ (BXQuickMessagesBubleModel *)defaultRightTopBuble
{
    BXQuickMessagesBubleModel *buble = [[BXQuickMessagesBubleModel alloc] init];

    buble.maskBubleImage = @"weChatBubble_Sending_Solid";

    buble.defaultMaskColor = [UIColor colorWithRed:0xa0/255.0 green:0xe7/255.0 blue:0x5a/255.0 alpha:1.0];
    buble.defaultBorderColor = [UIColor colorWithRed:0x83/255.0 green:0xd4/255.0 blue:0x5a/255.0 alpha:1.0];
    buble.resizableCapInsets = UIEdgeInsetsMake(34, 40, 10, 20);
    buble.bubleContentInsets = UIEdgeInsetsMake(13, 16, 13, 21);
    buble.borderWidthInsets = UIEdgeInsetsMake(0.5, 0.5, 0.5, 0.7);
    buble.defaultTextColor = [UIColor blackColor];

    return buble;
}

+ (BXQuickMessagesBubleModel *)defaultRightBottomBuble
{
    BXQuickMessagesBubleModel *buble = [[BXQuickMessagesBubleModel alloc] init];
    buble.maskBubleImage = @"weChatBubble_Sending_Solid";
    buble.defaultMaskColor = [UIColor colorWithRed:0xa0/255.0 green:0xe7/255.0 blue:0x5a/255.0 alpha:1.0];
    buble.defaultBorderColor = [UIColor colorWithRed:0x83/255.0 green:0xd4/255.0 blue:0x5a/255.0 alpha:1.0];
    buble.resizableCapInsets = UIEdgeInsetsMake(10, 40, 34, 20);
    buble.bubleContentInsets = UIEdgeInsetsMake(13, 16, 13, 21);
    buble.borderWidthInsets = UIEdgeInsetsMake(0.5, 0.5, 0.5, 0.7);
    buble.defaultTextColor = [UIColor blackColor];

    return buble;
}

- (UIColor *)currentMaskColor
{
    if (!_currentMaskColor) {
        _currentMaskColor = self.defaultMaskColor;
    }

    return _currentMaskColor;
}

- (UIColor *)currentBorderColor
{
    if (!_currentBorderColor) {
        _currentBorderColor = self.defaultBorderColor;
    }

    return _currentBorderColor;
}

- (UIImage *)resizableImage
{
    if (!_resizableImage) {
        UIImage *image = [UIImage buk_imageNamed:self.maskBubleImage];

        image = [self bubleImageFromImage:image maskedWithColor:self.currentMaskColor borderColor:self.currentBorderColor];

        _resizableImage = [image resizableImageWithCapInsets:self.resizableCapInsets];
    }

    return _resizableImage;
}

- (UIImage *)resizableImageWithBorderColor:(UIColor *)borderColor
{
    self.currentBorderColor = borderColor? borderColor : self.currentBorderColor;

    return [self resizableImage];
}

- (UIImage *)resizableImageWithMaskColor:(UIColor *)maskColor borderColor:(UIColor *)borderColor
{
    self.currentMaskColor = maskColor? maskColor : self.currentMaskColor;
    self.currentBorderColor = borderColor? borderColor : self.currentBorderColor;

    return [self resizableImage];
}

- (UIImage *)bubleImageFromImage:(UIImage *)image maskedWithColor:(UIColor *)maskColor borderColor:(UIColor *)borderColor
{
    NSParameterAssert(maskColor != nil);

    CGRect imageRect = CGRectMake(0.0f, 0.0f, image.size.width, image.size.height);
    UIImage *newImage = nil;

    UIGraphicsBeginImageContextWithOptions(imageRect.size, NO, image.scale);
    {
        CGContextRef context = UIGraphicsGetCurrentContext();

        CGContextScaleCTM(context, 1.0f, -1.0f);
        CGContextTranslateCTM(context, 0.0f, -(imageRect.size.height));

        CGContextClipToMask(context, imageRect, image.CGImage);
        CGContextSetFillColorWithColor(context, borderColor.CGColor);
        CGContextFillRect(context, imageRect);

        CGContextSetFillColorWithColor(context, maskColor.CGColor);
        CGRect contentRect = CGRectMake(imageRect.origin.x + self.borderWidthInsets.left,
                                        imageRect.origin.y + self.borderWidthInsets.top,
                                        imageRect.size.width - self.borderWidthInsets.left - self.borderWidthInsets.right,
                                        imageRect.size.height - self.borderWidthInsets.top - self.borderWidthInsets.bottom);
        CGContextClipToMask(context, contentRect, image.CGImage);
        CGContextFillRect(context, contentRect);

        newImage = UIGraphicsGetImageFromCurrentImageContext();
    }
    UIGraphicsEndImageContext();

    return newImage;
}

@end


text:
var _    = require('underscore');
var uuid = require('uuid');
var jrpc = require('jsonrpc-js');
var stats = require('./stats');
var prm   = require('./primitives');

var Methods = {
  ListDBs:       'list_dbs',
  GetSchema:     'get_schema',
  Transact:      'transact',
  Cancel:        'cancel',
  Monitor:       'monitor',
  Update:        'update',
  MonitorCancel: 'monitor_cancel',
  Lock:          'lock',
  Steal:         'steal',
  Unlock:        'unlock',
  Locked:        'locked',
  Stolen:        'stolen',
  Echo:          'echo'
};

function Transaction(peer, id) {
  this.peer = peer;
  this.id   = id;
}

Transaction.prototype.cancel = function() {
  this.peer.notify('cancel', [this.id]);
};

function Monitor(peer, id, cb) {
  this.peer = peer;
  this.id   = id;
  this.cb   = cb;
}

Monitor.prototype.cancel = function(callback) {
  this.peer.request('monitor_cancel', [this.id], callback);
};

function Lock(peer, name) {
  this.peer = peer;
  this.name = name;
}

Lock.prototype.unlock = function(callback) {
  this.peer.request('unlock', [this.name], callback);
};

function OVSDB(cfg, socket) {
  var that = this;
  this.peer = new jrpc.Peer(socket,
    // request callback/handler
    function(msg) {
      that.recvRequest(msg);
    },
    // notification callback/handler
    function(msg) {
      that.recvNotify(msg);
    },
    // unacknowledged request expiration age
    10000,
    // low-level catastrophic failure callback/handler
    function() {
      that.destroy();
    }, cfg);
  this.activeMonitors = {};
  this.stats = new stats.Stats();
}

OVSDB.prototype.recvRequest = function(msg) {
  switch(msg.method) {
    case Methods.ListDBs:
      this.rx_list_dbs(msg);
      break;
    case Methods.GetSchema:
      this.rx_get_schema(msg);
      break;
    case Methods.Transact:
      this.rx_transact(msg);
      break;
    case Methods.Monitor:
      this.rx_monitor(msg);
      break;
    case Methods.Lock:
      this.rx_lock(msg);
      break;
    case Methods.Steal:
      this.rx_steal(msg);
      break;
    case Methods.Unlock:
      this.rx_unlock(msg);
      break;
    case Methods.Echo:
      this.rx_echo(msg);
      break;
    default:
      this.unknown_request(msg);
      break;
  }
};

OVSDB.prototype.recvNotify = function(msg) {
  switch(msg.method) {
    case Methods.Cancel:
      this.rx_cancel(msg);
      break;
    case Methods.Update:
      this.rx_update(msg);
      break;
    case Methods.MonitorCancel:
      this.rx_monitor_cancel(msg);
      break;
    case Methods.Locked:
      this.rx_locked(msg);
      break;
    case Methods.Stolen:
      this.rx_stolen(msg);
      break;
    default:
      this.unknown_notify(msg);
      break;
  }
};

OVSDB.prototype.destroy = function() {
};

OVSDB.prototype.timer = function() {
  this.peer.timer();
};

OVSDB.prototype.unknown_request = function(msg) {
  console.log('unknown request: '+msg);
};

OVSDB.prototype.unknown_notify = function(msg) {
  console.log('unknown notify: '+msg);
};

OVSDB.prototype.rx_list_dbs = function(msg) {
  // Update the stats
  this.stats.rcvPegs.requests++;
  this.stats.rcvPegs.reqs.listDB++;
};

OVSDB.prototype.rx_get_schema = function(msg) {
  // Update the stats
  this.stats.rcvPegs.requests++;
  this.stats.rcvPegs.reqs.getSchema++;
};

OVSDB.prototype.rx_transact = function(msg) {
  // Update the stats
  this.stats.rcvPegs.requests++;
  this.stats.rcvPegs.reqs.transact++;
};

OVSDB.prototype.rx_cancel = function(msg) {
  // Update the stats
  this.stats.rcvPegs.notifications++;
  this.stats.rcvPegs.reqs.cancel++;
};

OVSDB.prototype.rx_montior = function(msg) {
  // Update the stats
  this.stats.rcvPegs.requests++;
  this.stats.rcvPegs.reqs.monitor++;
};

OVSDB.prototype.rx_update = function(msg) {
  var that = this;
  // Update the stats
  this.stats.rcvPegs.notifications++;
  this.stats.rcvPegs.reqs.update++;
  if(_(this.activeMonitors).has(msg.params[0])){
    this.activeMonitors[msg.params[0]].cb(null, msg.params[1]);
  }
};

OVSDB.prototype.rx_monitor_cancel = function(msg) {
  // Update the stats
  this.stats.rcvPegs.notifications++;
  this.stats.rcvPegs.reqs.monitor_cancel++;
};

OVSDB.prototype.rx_lock = function(msg) {
  // Update the stats
  this.stats.rcvPegs.requests++;
  this.stats.rcvPegs.reqs.lock++;
};

OVSDB.prototype.rx_steal = function(msg) {
  // Update the stats
  this.stats.rcvPegs.requests++;
  this.stats.rcvPegs.reqs.steal++;
};

OVSDB.prototype.rx_unlock = function(msg) {
  // Update the stats
  this.stats.rcvPegs.requests++;
  this.stats.rcvPegs.reqs.unlock++;
};

OVSDB.prototype.rx_locked = function(msg) {
  // Update the stats
  this.stats.rcvPegs.notifications++;
  this.stats.rcvPegs.reqs.locked++;
};

OVSDB.prototype.rx_stolen = function(msg) {
  // Update the stats
  this.stats.rcvPegs.notifications++;
  this.stats.rcvPegs.reqs.stolen++;
};

OVSDB.prototype.rx_echo = function(msg) {
  // Update the stats
  this.stats.rcvPegs.requests++;
  this.stats.rcvPegs.reqs.echo++;
  this.peer.response(msg.method, msg.id);
};

OVSDB.prototype.list = function(callback) {
  this.peer.request('list_dbs', [], callback);
};

OVSDB.prototype.get = function(db_name, callback) {
  this.peer.request('get_schema', [db_name], callback);
};

function mkParams(db_name, operations){
  prm.assertArray('operations', operations);
  prm.assertString('db_name', db_name);
  return _.flatten([db_name, operations], true);
}

OVSDB.prototype.transact = function(db_name, operations, callback) {
  var params = mkParams(db_name, operations);
  var msg = this.peer.request('transact', params, callback);
  return new Transaction(this.peer, msg.id);
};

OVSDB.prototype.monitor = function(db_name, reqs, resCB, notCB) {
  // TODO: validate monitor request (reqs)
  // if monitor request is array
  //     each element must specify both columns and select
  //     columns must be non-overlapping sets
  //     RFC 7047, section 4.1.5, pg 16
  var id = uuid.v4();
  var that = this;
  this.peer.request('monitor', [db_name, id , reqs], resCB);
  var m = new Monitor(that.peer, id, notCB);
  that.activeMonitors[id] = m;
};

OVSDB.prototype.lock = function(lock_name, callback) {
  var that = this;
  this.peer.request('lock', [lock_name], function(err, result) {
    if(err) {
      callback(err);
    } else {
      callback(null, new Lock(that.peer, lock_name));
    }
  });
};

OVSDB.prototype.steal = function(lock_name, callback) {
  var that = this;
  this.peer.request('steal', [lock_name], function(err, result) {
    if(err) {
      callback(err);
    } else {
      callback(null, new Lock(that.peer, lock_name));
    }
  });
};

OVSDB.prototype.echo = function() {
  var that = this;
  this.peer.request('echo', [], function(err, res) {
    if(err) {
    } else {
    }
  });
};

exports.OVSDB = OVSDB;


text:
/* ################################################## */
/* # ROOT GUIDE                                       */
/* ################################################## */
body#languageRootGuide { background:#4d4d4d url('../images/body-bg.png') repeat-x; }
body#rootGuide { background:#4d4d4d url('../images/body-bg.png') repeat-x; }
#rootGuide  .wrapper { width: 706px; font-family: Helvetica !important; position: relative; margin-bottom: 100px; }
body > #rootGuide .wrapper { height: 100%; }
#rootGuide .outer-wrapper { background: transparent; padding: 0; }
#rootGuide a { color: #444444; }
#rootGuide h1 { display: none; }
#rootGuide #referenceHeader { border: 0; margin-bottom: 0; border-radius: 4px 4px 0 0; box-shadow: 0 0 10px rgba(0,0,0,0.39); }

#rootGuide .links ul { clear: both; width: 708px; height: 40px; }
#rootGuide .links ul li { background: transparent; list-style-type: none; display: inline-block; margin: 0 2px 0 0; padding: 0; font-size: 0; float: left; }
#rootGuide .links  a { font-size: 15px; display: inline-block; background: #af0d18; line-height: 40px; width: 234px; color: #ffffff; text-align: center; box-shadow: 0 0 10px rgba(0,0,0,0.39); }
#rootGuide .links a:hover { background: #98040a; }

#rootGuide #accordion-container { background: #444; padding: 3px 0; }

#rootGuide .accordion { overflow: hidden; margin: 2px 0 0 0; box-shadow: 0 0 10px #333; }
#rootGuide .accordion-header { font-family: Helvetica !important; line-height: 55px; font-size: 18px; color: #ffffff; padding: 0 0 0 80px; display: block; cursor: pointer; font-weight: normal; display: block; }
  #rootGuide h2.one { background: url('../images/mathematica/1-icon-core-language.png') 10px center no-repeat #dc3410;}
  #rootGuide h2.two { background: url('../images/mathematica/2-icon-mathematics-algorithms.png') 10px center no-repeat #d7300e;}
  #rootGuide h2.three { background: url('../images/mathematica/3-icon-visualization.png') 10px center no-repeat #cf2c0d;}
  #rootGuide h2.four { background: url('../images/mathematica/4-icon-data-visualization.png') 10px center no-repeat #c9280c;}
  #rootGuide h2.five { background: url('../images/mathematica/5-icon-computable-data.png') 10px center no-repeat #c2230a;}
  #rootGuide h2.six { background: url('../images/mathematica/6-icon-dynamic-interactivity.png') 10px center no-repeat #bb2009;}
  #rootGuide h2.seven { background: url('../images/mathematica/7-icon-notebooks-documents.png') 10px center no-repeat #b51c07;}
  #rootGuide h2.eight { background: url('../images/mathematica/8-icon-system-interface.png') 10px center no-repeat #b11906;}
  #rootGuide h2.one:hover { background-color: #c12d0e; }
  #rootGuide h2.two:hover { background-color: #bc2a0c; }
  #rootGuide h2.three:hover { background-color: #b6270c; }
  #rootGuide h2.four:hover { background-color: #b0230b; }
  #rootGuide h2.five:hover { background-color: #aa1f09; }
  #rootGuide h2.six:hover { background-color: #a31c08; }
  #rootGuide h2.seven:hover { background-color: #931906; }
  #rootGuide h2.eight:hover { background-color: #9c1605; }
  #rootGuide h2.accordion-header span { display: block; line-height: 55px; width: 626px; background: url('../images/mathematica/arrow-off.png') right center no-repeat; }
  #rootGuide h2.accordion-header span:hover { background: url('../images/mathematica/arrow-on.png') right center no-repeat; }
  #rootGuide h2.active-header span, #rootGuide h2.active-header span:hover { background: url('../images/mathematica/arrow-selected.png') right center no-repeat;}

#rootGuide .accordion-content { display: none; margin: 0 7px 7px 7px; box-shadow: 0 0 10px rgba(0,0,0,0.39); background-color: #ffffff; overflow: hidden; padding: 10px 0 10px 0; }
#rootGuide .accordion-content a:hover { color: #c00; }
  #rootGuide .accordion.one { background-color: #dc3410; }
  #rootGuide .accordion.two { background-color: #d7300e; }
  #rootGuide .accordion.three { background-color: #cf2c0d; }
  #rootGuide .accordion.four { background-color: #c9280c; }
  #rootGuide .accordion.five { background-color: #c2230a; }
  #rootGuide .accordion.six { background-color: #bb2009; }
  #rootGuide .accordion.seven { background-color: #b51c07; }
  #rootGuide .accordion.eight { background-color: #b11906; }
  #rootGuide .accordion-content ul  li { background: url('../images/mathematica/red-bullet.jpg') no-repeat 8px center; font-size: 13px; font-weight: bold; line-height: 15px; }
  #rootGuide ul.left { float: left; width: 250px; margin-left: 58px; }
  #rootGuide ul.right { float: left; }

#rootGuide .footer { padding-left: 9px; background: #ffffff; box-shadow: 0 0 10px rgba(0,0,0,0.39); display: block; overflow: hidden; margin: 0;  border-radius: 0 0 4px 4px; border: 0; }
  #rootGuide .footer ul { float: left; margin: 10px 0 10px 56px; list-style: none; font-size: 9.5px; }
  #rootGuide .footer ul li { background: transparent !important; }
  #rootGuide .footer a:hover { color: #c00; }

#rootGuide .root-guide-seo p { margin: 20px 25px 0; font-size: 10px; line-height: 14px; color: #ddd; }

#languageRootGuide body { text-align:center;margin:0px;padding:0px; background:#4d4d4d url('../images/body-bg.png') repeat-x; }
#languageRootGuide body, #languageRootGuide p, #languageRootGuide td, #languageRootGuide tr, #languageRootGuide blockquote { font: 11px/15px Arial, Geneva ,sans-serif; }

#languageRootGuide .header { margin: 60px auto 10px; background: url('../images/top-header.png') no-repeat; width: 920px; height: 77px; text-align: right; padding-bottom: 20px; }
#languageRootGuide .header-inner { width: auto; background: transparent; }

#languageRootGuide .outer-wrapper { background: transparent; padding: 0 0 250px 0; }
#languageRootGuide .container { max-width:937px; margin:0px auto 90px auto; padding: 0 0 40px;}
#languageRootGuide .thumb { text-align: left; position: relative; display: inline-block; margin: 5px; width:222px; height:152px; box-shadow: 0px 0px 9px rgba(0,0,0,.3); cursor: pointer; }
  #languageRootGuide .thumb a:link img{border-color:#ccc;}
  #languageRootGuide .thumb a:hover img{border-color:#ffbf4c;}

#languageRootGuide .links-list { width: 299px; background: #fff; position: absolute; top: 80px; display: none; z-index: 9999; box-shadow: 0px 0px 9px rgba(0,0,0,.3); cursor: default; font-family: Arial, Helvetica, sans-serif; }
  #languageRootGuide .links-list ul { list-style-type: none; margin: 11px 0px 14px 0px; padding: 0; }
    #languageRootGuide .links-list ul li { background: none; padding: 0px; margin: .75em 0; }
  #languageRootGuide .links-list a { font-weight: bold; font-size: 14px; line-height: 1.3em; padding: 3px 15px; margin: 5px 0; display: block; cursor: pointer; }
  #languageRootGuide .links-list a:hover { background: #dadada; }

#languageRootGuide .thumb { width: 299px; height: 80px; }
#languageRootGuide .podheader { width: 299px; height: 80px; display: table-cell; vertical-align: middle; font-family: 'Open Sans', serif; }
  #languageRootGuide .podheader .title { color: #fff; font-size: 17px; line-height: 1.4em; display: inline-block; width: 160px; padding: 0 0 0 20px; text-shadow: 0px 1px 4px rgba(0,0,0,.3); }

#languageRootGuide .icon1 { background: url('../images/icon_corelang.png') right center no-repeat; }
#languageRootGuide .icon2 { background: url('../images/icon_symbolic.png') right center no-repeat; }
#languageRootGuide .icon3 { background: url('../images/icon_visualization.png') right center no-repeat; }
#languageRootGuide .icon4 { background: url('../images/icon_data.png') right center no-repeat; }
#languageRootGuide .icon5 { background: url('../images/icon_strings.png') right center no-repeat; }
#languageRootGuide .icon6 { background: url('../images/icon_graphs.png') right center no-repeat; }
#languageRootGuide .icon7 { background: url('../images/icon_images.png') right center no-repeat; }
#languageRootGuide .icon8 { background: url('../images/icon_geometry.png') right center no-repeat; }
#languageRootGuide .icon9 { background: url('../images/icon_sound.png') right center no-repeat; }
#languageRootGuide .icon10 { background: url('../images/icon_time.png') right center no-repeat; }
#languageRootGuide .icon11 { background: url('../images/icon_geographic.png') right center no-repeat; }
#languageRootGuide .icon12 { background: url('../images/icon_scientific.png') right center no-repeat; }
#languageRootGuide .icon13 { background: url('../images/icon_eng.png') right center no-repeat; }
#languageRootGuide .icon14 { background: url('../images/icon_finance.png') right center no-repeat; }
#languageRootGuide .icon15 { background: url('../images/icon_social.png') right center no-repeat; }
#languageRootGuide .icon16 { background: url('../images/icon_highermath.png') right center no-repeat; }
#languageRootGuide .icon17 { background: url('../images/icon_documents.png') right center no-repeat; }
#languageRootGuide .icon18 { background: url('../images/icon_ui.png') right center no-repeat; }
#languageRootGuide .icon19 { background: url('../images/icon_system.png') right center no-repeat; }
#languageRootGuide .icon20 { background: url('../images/icon_external.png') right center no-repeat; }
#languageRootGuide .icon21 { background: url('../images/icon_cloud.png') right center no-repeat; }

#languageRootGuide .redbg .links-list a {color: #a50000;}
#languageRootGuide .orangebg .links-list a {color: #994300;}
#languageRootGuide .bluebg .links-list a {color: #005170;}
#languageRootGuide .greenbg .links-list a {color: #4c7000;}
#languageRootGuide .tealbg .links-list a {color: #01614a;}
#languageRootGuide .greybg .links-list a {color: #444;}

#languageRootGuide .redbg {background:url('../images/redpod.png') repeat-x;}
#languageRootGuide .redbg:hover {background:url('../images/redpodover.png') repeat-x;}

#languageRootGuide .orangebg {background:url('../images/orangepod.png') repeat-x;}
#languageRootGuide .orangebg:hover {background:url('../images/orangepodover.png') repeat-x;}

#languageRootGuide .bluebg {background:url('../images/bluepod.png') repeat-x;}
#languageRootGuide .bluebg:hover {background:url('../images/bluepodover.png') repeat-x;}

#languageRootGuide .greenbg {background:url('../images/greenpod.png') repeat-x;}
#languageRootGuide .greenbg:hover {background:url('../images/greenpodover.png') repeat-x;}

#languageRootGuide .tealbg {background:url('../images/tealpod.png') repeat-x;}
#languageRootGuide .tealbg:hover {background:url('../images/tealpodover.png') repeat-x;}

#languageRootGuide .greybg {background:url('../images/greypod.png') repeat-x;}
#languageRootGuide .greybg:hover {background:url('../images/greypodover.png') repeat-x;}

#languageRootGuide .footer-link a { color: #ccc; margin: 10px 0 0 25px; display: none; }
#languageRootGuide .footer-link a:hover { color: #fff; }

#languageRootGuide .clearfloats { clear: both; }

#languageRootGuide .divider { border-top: 1px solid #acacac; margin: -4px 15px 0; }

#languageRootGuide #query { width: 255px; height: 20px; margin: 37px 0 0 0; background: transparent; font-family: 'Open Sans', serif; font-size: 14px; color: #eaeaea; border: 0; outline: none;}
#languageRootGuide .header label.placeholder { right: 142px; }
#languageRootGuide input.search-reference-input-button { background: transparent; width: 25px; height: 19px; margin: 0 5px 0; border: 0; font-size: 0; cursor: pointer; outline: none; }
.noscript { color: #ccc; background: #555; padding: 10px 15px; border: 1px solid #888; margin: 20px 5px; }
  .noscript a { color: #e77477; }
    .noscript a:hover { color: #bb7777; }

@media all and (max-width: 951px) {
    #languageRootGuide .container { width: 627px; }
}

@media all and (max-width: 638px) {
    #languageRootGuide .container { width: 300px; }
}


text:
#import <PassKit/PKPassGroupStackView.h>

@interface PKPassGroupStackView (PKPassGroupStackViewPPTTesting)
- (void)gotoBaseTestState;
- (void)beginFlipCardTest;
- (void)testFlipToFront;
- (void)testFlipToBack;
- (void)beginSelectCardTest;
- (void)testGroupSelection;
- (void)testGoModal;
- (void)beginScrollCardListTest;
- (void)scrollUpTest;
- (void)noteDidEndScrollingForTesting;
- (void)scrollDownTest;
- (void)scrollNext;
@end


text:
<?php

class MyPasswordController extends FwController {
    const access_level = 0; #logged only
    const route_default_action = '';
    public $base_url = '/My/Password';
    public $model_name = 'Users';

    public function IndexAction() {
        $this->routeRedirect("ShowForm");
    }

    public function ShowFormAction() {
        $id = Utils::me();

        if ($this->fw->isGetRequest()){
            if ($id>0){
                $item = $this->model->one($id);
            }else{
                #defaults
                $item=array(
                );
            }
        }else{
            $itemdb = $this->model->one($id);
            $item = array_merge($itemdb, reqh('item'));
        }

        $ps = array(
            'id'    => $id,
            'i'     => $item,
        );

        return $ps;
    }

    public function SaveAction() {
        $id = Utils::me();
        $item = reqh('item');

        try{
            $this->Validate($id, $item);

            $vars = FormUtils::filter($item, 'email pwd');
            $vars['pwd']=trim($vars['pwd']);
            $this->model->update($id, $vars);

            $this->fw->model('FwEvents')->log('chpwd', $id);
            $this->fw->flash("record_updated", true);
            fw::redirect($this->base_url);

        }catch( ApplicationException $ex ){
            $this->setFormError($ex->getMessage());
            $this->routeRedirect("ShowForm");
        }
    }

    public function Validate($id, $item) {
        $result= $this->validateRequired($item, "email old_pwd pwd pwd2");

        if ($result){
            $itemdb=$this->model->one($id);
            if ( !$this->model->checkPwd($item['old_pwd'],$itemdb['pwd']) ){
                $this->setError('old_pwd', 'WRONG');
            }

            if ($this->model->isExists( $item['email'], $id ) ){
                $this->setError('email', 'EXISTS');
            }

            if (!FormUtils::isEmail( $item['email'] ) ){
                $this->setError('email', 'WRONG');
            }

            if ($item['pwd']!=trim($item['pwd2']) ){
                $this->setError('pwd2', 'NOTEQUAL');
            }

        }

        $this->validateCheckResult();
    }

}//end of class

?>


text:
Unreleased Changes
------------------

1.3.0 (2022-10-28)
------------------

* Feature - Fix incorrect endpoint-prefix in endpoint ruleset.

1.2.0 (2022-10-25)
------------------

* Feature - Code Generated Changes, see `./build_tools` or `aws-sdk-core`'s CHANGELOG.md for details.

1.1.0 (2022-10-19)
------------------

* Feature - This release adds the RegisterSlackWorkspaceForOrganization API. You can use the API to register a Slack workspace for an AWS account that is part of an organization.

1.0.0 (2022-08-22)
------------------

* Feature - Initial release of `aws-sdk-supportapp`.


text:
require 'spec_helper'

describe User do
    before(:each) do
        OmniAuth.config.mock_auth[:fivecolleges] = OmniAuth::AuthHash.new({
            'uid' => '00002@example.com',
            'provider' => "testing",
            'info' => {
                'name' => "Dorothea Brooke",
                'email' => "dorothea@example.com"
            }
        })
        @user1 = FactoryGirl.create(:user)
        @user2 = User.find_for_fivecolleges_oauth(OmniAuth.config.mock_auth[:fivecolleges])
    end
    after(:each) do
        @user1.delete if @user1
        @user2.delete if @user2
    end

    it "should have an email" do
        @user1.email.should == "will@example.com"
        @user2.email.should == "dorothea@example.com"
    end
    it "should have a display name" do
        @user1.display_name.should == "Will Ladislaw"
        @user2.display_name.should == "Dorothea Brooke"
    end
    it "should have a UID" do
        @user1.uid.should == "00000@example.com"
        @user2.uid.should == "00002@example.com"
    end
    it "should stringify to the email address" do
        @user1.to_s.should == "will@example.com"
        @user1.to_s.should == @user1.email
        @user2.to_s.should == "dorothea@example.com"
        @user2.to_s.should == @user2.email
    end
end


text:
package flags

func getTerminalColumns() int {
	return 80
}


text:
========
Usage
========

To use monit-master in a project::

	import monit-master


text:
require "test/unit"
require "MyGem"


text:
package org.codehaus.groovy.transform;

import groovy.transform.AutoFinal;
import org.codehaus.groovy.ast.ASTNode;
import org.codehaus.groovy.ast.AnnotatedNode;
import org.codehaus.groovy.ast.AnnotationNode;
import org.codehaus.groovy.ast.ClassCodeVisitorSupport;
import org.codehaus.groovy.ast.ClassHelper;
import org.codehaus.groovy.ast.ClassNode;
import org.codehaus.groovy.ast.ConstructorNode;
import org.codehaus.groovy.ast.FieldNode;
import org.codehaus.groovy.ast.MethodNode;
import org.codehaus.groovy.ast.Parameter;
import org.codehaus.groovy.ast.expr.ClosureExpression;
import org.codehaus.groovy.ast.expr.DeclarationExpression;
import org.codehaus.groovy.control.CompilePhase;
import org.codehaus.groovy.control.SourceUnit;

import java.lang.reflect.Modifier;
import java.util.Iterator;

import static org.codehaus.groovy.ast.tools.ClosureUtils.getParametersSafe;

/**
 * Handles generation of code for the {@link AutoFinal} annotation.
 */
@GroovyASTTransformation(phase = CompilePhase.SEMANTIC_ANALYSIS)
public class AutoFinalASTTransformation extends AbstractASTTransformation {

    private static final Class<?> MY_CLASS = AutoFinal.class;
    private static final ClassNode MY_TYPE = ClassHelper.make(MY_CLASS);

    private AnnotatedNode target;

    @Override
    public  void visit(final ASTNode[] nodes, final SourceUnit source) {
        init(nodes, source);
        process(nodes, createVisitor());
    }

    private void process(final ASTNode[] nodes, final ClassCodeVisitorSupport visitor) {
        target = (AnnotatedNode) nodes[1];
        AnnotationNode node = (AnnotationNode) nodes[0];
        if (!MY_TYPE.equals(node.getClassNode())) return;
        if (memberHasValue(node, "enabled", Boolean.FALSE)) return; // GROOVY-10585

        if (target instanceof ClassNode) {
            processClass((ClassNode) target, visitor);
        } else if (target instanceof FieldNode) {
            processField((FieldNode) target, visitor);
        } else if (target instanceof MethodNode) {
            processConstructorOrMethod((MethodNode) target, visitor);
        } else if (target instanceof DeclarationExpression) {
            processLocalVariable((DeclarationExpression) target, visitor);
        }
    }

    private void processClass(final ClassNode node, final ClassCodeVisitorSupport visitor) {
        if (!isEnabled(node)) return;

        if (node.isInterface()) {
            addError("Error processing interface '" + node.getName() + "'. @" + MY_TYPE.getNameWithoutPackage() + " only allowed for classes.", node);
            return;
        }

        for (ConstructorNode cn : node.getDeclaredConstructors()) {
            if (hasNoExplicitAutoFinal(cn)) {
                processConstructorOrMethod(cn, visitor);
            }
        }

        for (MethodNode mn : node.getAllDeclaredMethods()) {
            if (hasNoExplicitAutoFinal(mn)) {
                processConstructorOrMethod(mn, visitor);
            }
        }

        for (Iterator<? extends ClassNode> it = node.getInnerClasses(); it.hasNext(); ) { ClassNode cn = it.next();
            if (hasNoExplicitAutoFinal(cn) && !cn.isInterface()) { // GROOVY-10585
                processClass(cn, visitor);
            }
        }

        visitor.visitClass(node);
    }

    private void processField(final FieldNode node, final ClassCodeVisitorSupport visitor) {
        if (!isEnabled(node)) return;
        if (node.hasInitialExpression() && node.getInitialExpression() instanceof ClosureExpression) {
            visitor.visitField(node);
        }
    }

    private void processConstructorOrMethod(final MethodNode node, final ClassCodeVisitorSupport visitor) {
        if (!isEnabled(node)) return;
        if (node.isSynthetic()) return;
        for (Parameter p : node.getParameters()) {
            p.setModifiers(p.getModifiers() | Modifier.FINAL);
        }
        visitor.visitMethod(node);
    }

    private void processLocalVariable(final DeclarationExpression expr, final ClassCodeVisitorSupport visitor) {
        if (!isEnabled(expr)) return;
        if (expr.getRightExpression() instanceof ClosureExpression) {
            visitor.visitDeclarationExpression(expr);
        }
    }

    //--------------------------------------------------------------------------

    private ClassCodeVisitorSupport createVisitor() {
        return new ClassCodeVisitorSupport() {
            @Override
            public void visitClosureExpression(final ClosureExpression expression) {
                if (!expression.isSynthetic()) {
                    for (Parameter p : getParametersSafe(expression)) {
                        p.setModifiers(p.getModifiers() | Modifier.FINAL);
                    }
                    super.visitClosureExpression(expression);
                }
            }

            @Override
            protected void visitConstructorOrMethod(final MethodNode node, final boolean isConstructor) {
                if (target == node || hasNoExplicitAutoFinal(node)) {
                    super.visitConstructorOrMethod(node, isConstructor);
                }
            }

            @Override
            public void visitField(final FieldNode node) {
                if (target == node || hasNoExplicitAutoFinal(node)) {
                    super.visitField(node);
                }
            }

            @Override
            public void visitDeclarationExpression(final DeclarationExpression expr) {
                if (target == expr || hasNoExplicitAutoFinal(expr)) {
                    super.visitDeclarationExpression(expr);
                }
            }

            @Override
            protected SourceUnit getSourceUnit() {
                return sourceUnit;
            }
        };
    }

    private boolean isEnabled(final AnnotatedNode node) {
        // any explicit false for enabled disables processing
        // this allows, for example, config script to set all
        // classes to true and one class to be explicitly disabled
        return node != null && node.getAnnotations(MY_TYPE).stream()
            .noneMatch(anno -> memberHasValue(anno, "enabled", Boolean.FALSE));
    }

    private static boolean hasNoExplicitAutoFinal(final AnnotatedNode node) {
        return node.getAnnotations(MY_TYPE).isEmpty();
    }
}


text:
/*
Simplify the following application by modifying the type of the variable
processors and replacing the for loop with a standard C++ algorithm:
*/
#include <vector>
#include <iostream>
#include <cstdlib>
#include <cstring>

int main()
{
  std::vector<int(*)(const char*)> processors;
  processors.push_back(std::atoi);
  processors.push_back(reinterpret_cast<int(*)(const char*)>(std::strlen));

  const char data[] = "1.23";

  for (std::vector<int(*)(const char*)>::iterator it = processors.begin(); it != processors.end(); ++it)
    std::cout << (*it)(data) << std::endl;
}


text:
.admin-chart {
	background-color: #fff;
}


text:
"""Miscellaneous utility functions related to GTK widgets."""

from __future__ import absolute_import, division, print_function, unicode_literals
from future.builtins import *

import pygtk
pygtk.require('2.0')
import gtk
import pango

__all__ = [
  'get_toplevel_window',
  'label_fits_text',
  'get_label_full_text_width',
  'menu_popup_below_widget',
  'get_position_below_widget',
]

def get_toplevel_window(widget):
  """
  Return the toplevel window (`gtk.Window`) for the specified widget
  (`gtk.Widget`). If the widget has no toplevel window, return None.
  """
  toplevel_widget = widget.get_toplevel()
  if toplevel_widget.flags() & gtk.TOPLEVEL:
    return toplevel_widget
  else:
    return None

def label_fits_text(label, use_markup=True):
  """
  If the `label` is wide enough to display the entire text, return `True`,
  otherwise `False`. If `use_markup` is `True`, treat the label text as
  marked-up text.
  """
  return (label.get_layout().get_pixel_size()[0]
          >= get_label_full_text_width(label, use_markup))

def get_label_full_text_width(label, use_markup=True):
  """
  Return the pixel width of the label text. If `use_markup` is `True`, treat the
  label text as marked-up text.
  """
  full_text_layout = pango.Layout(label.get_pango_context())

  if use_markup:
    full_text_layout.set_markup_with_accel(label.get_label(), '_')
  else:
    full_text_layout.set_text(label.get_text())

  return full_text_layout.get_pixel_size()[0]

def menu_popup_below_widget(
      menu,
      widget,
      parent_menu_shell=None,
      parent_menu_item=None,
      button=0,
      activate_time=0):
  """
  Display popup of the specified menu below the specified widget. If the widget
  has no associated top-level window, display the popup on the cursor position.
  """
  position_below_widget = get_position_below_widget(widget)

  if position_below_widget is not None:
    menu.popup(
      parent_menu_shell,
      parent_menu_item,
      lambda menu_: (position_below_widget[0], position_below_widget[1], True),
      button,
      activate_time)
  else:
    menu.popup(parent_menu_shell, parent_menu_item, None, button, activate_time)

def get_position_below_widget(widget):
  toplevel_window = get_toplevel_window(widget)

  if toplevel_window is not None:
    toplevel_window_position = toplevel_window.get_window().get_origin()
    widget_allocation = widget.get_allocation()
    return (
      toplevel_window_position[0] + widget_allocation.x,
      toplevel_window_position[1] + widget_allocation.y + widget_allocation.height)
  else:
    return None


text:
<?php

namespace Jlis\Judge\Voters;

use Jlis\Judge\Judges\FeatureJudge;
use Jlis\Judge\Contracts\VoterInterface;
use Symfony\Component\ExpressionLanguage\ExpressionLanguage;

/**
 * @author Julius Ehrlich <julius@ehrlich-bros.de>
 */
class ExpressionLanguageVoter implements VoterInterface
{
    /**
     * {@inheritdoc}
     */
    public function vote($parameter = null, $user = null, array $additional = [])
    {
        if (empty($parameter)) {
            return false;
        }

        $language = new ExpressionLanguage();
        if (! array_key_exists('user', $additional)) {
            $additional['user'] = $user;
        }

        return FeatureJudge::isTrue($language->evaluate($parameter, $additional));
    }
}


text:
package com.serphacker.serposcope.models.base;

import java.time.LocalTime;
import java.util.Arrays;
import java.util.List;
import java.util.regex.Pattern;

public class Config {

    public final static Pattern PATTERN_CRONTIME = Pattern.compile("^([0-9]+):([0-9]+)$");

//    boolean cronEnabled;
    LocalTime cronTime;

    String dbcUser;
    String dbcPass;

    String decaptcherUser;
    String decaptcherPass;

    String anticaptchaKey;

    String twoCaptchaKey;

    String imageTyperzKey;

    public final static String DEFAULT_DISPLAY_HOME = "summary";
    public final static List<String> VALID_DISPLAY_HOME = Arrays.asList("summary","table");
    public final static String DEFAULT_DISPLAY_GOOGLE_TARGET = "table";
    public final static List<String> VALID_DISPLAY_GOOGLE_TARGET = Arrays.asList("variation","chart","table");
    public final static String DEFAULT_DISPLAY_GOOGLE_SEARCH = "split";
    public final static List<String> VALID_DISPLAY_GOOGLE_SEARCH = Arrays.asList("split","chart","table");

    String displayHome=DEFAULT_DISPLAY_HOME;
    String displayGoogleTarget=DEFAULT_DISPLAY_GOOGLE_TARGET;
    String displayGoogleSearch=DEFAULT_DISPLAY_GOOGLE_SEARCH;

    public final static int DEFAULT_PRUNE_RUNS = 365;
    int pruneRuns = DEFAULT_PRUNE_RUNS;

    public String getDbcUser() {
        return dbcUser;
    }

    public void setDbcUser(String dbcUser) {
        this.dbcUser = dbcUser;
    }

    public String getDbcPass() {
        return dbcPass;
    }

    public void setDbcPass(String dbcPass) {
        this.dbcPass = dbcPass;
    }

    public String getDecaptcherUser() {
        return decaptcherUser;
    }

    public void setDecaptcherUser(String decaptcherUser) {
        this.decaptcherUser = decaptcherUser;
    }

    public String getDecaptcherPass() {
        return decaptcherPass;
    }

    public void setDecaptcherPass(String decaptcherPass) {
        this.decaptcherPass = decaptcherPass;
    }

    public String getAnticaptchaKey() {
        return anticaptchaKey;
    }

    public void setAnticaptchaKey(String anticaptchaKey) {
        this.anticaptchaKey = anticaptchaKey;
    }

    public String getTwoCaptchaKey() {
        return twoCaptchaKey;
    }

    public void setTwoCaptchaKey(String twoCaptchaKey) {
        this.twoCaptchaKey = twoCaptchaKey;
    }

    public String getImageTyperzKey() {
        return imageTyperzKey;
    }

    public void setImageTyperzKey(String imageTyperzKey) {
        this.imageTyperzKey = imageTyperzKey;
    }

    public LocalTime getCronTime() {
        return cronTime;
    }

    public void setCronTime(LocalTime cronTime) {
        this.cronTime = cronTime;
    }

    public void setCronTime(String dateTime){
        if(dateTime == null || dateTime.isEmpty()){
            this.cronTime = null;
        }
        try{
            this.cronTime = LocalTime.parse(dateTime);
        } catch(Exception ex){
            this.cronTime = null;
        }
    }

    public String getDisplayHome() {
        return displayHome;
    }

    public void setDisplayHome(String displayHome) {
        this.displayHome = displayHome;
    }

    public String getDisplayGoogleTarget() {
        return displayGoogleTarget;
    }

    public void setDisplayGoogleTarget(String displayGoogleTarget) {
        this.displayGoogleTarget = displayGoogleTarget;
    }

    public String getDisplayGoogleSearch() {
        return displayGoogleSearch;
    }

    public void setDisplayGoogleSearch(String displayGoogleSearch) {
        this.displayGoogleSearch = displayGoogleSearch;
    }

    public int getPruneRuns() {
        return pruneRuns;
    }

    public void setPruneRuns(int pruneRuns) {
        this.pruneRuns = pruneRuns;
    }

}


text:
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
var mongoose_1 = require("mongoose");
var eSchemaDef = {
    surname: { type: String, list: {} },
    forename: { type: String, list: true },
    weight: { type: Number, form: { label: 'Weight (lbs)' } },
    leadMentor: { type: mongoose_1.Schema.Types.ObjectId, ref: 'c_subdoc_example', required: true },
    mentor: { type: mongoose_1.Schema.Types.ObjectId, ref: 'c_subdoc_example' },
    guide: { type: mongoose_1.Schema.Types.ObjectId, ref: 'b_enhanced_schema', form: { directive: 'fng-ui-select' } },
    teacher: { type: mongoose_1.Schema.Types.ObjectId, ref: 'b_enhanced_schema', form: { directive: 'fng-ui-select', fngUiSelect: { fngAjax: true } } },
    dateOfBirth: Date,
    assistants: [{ type: mongoose_1.Schema.Types.ObjectId, ref: 'a_unadorned_schema' }],
    assistants2: { type: [mongoose_1.Schema.Types.ObjectId], ref: 'a_unadorned_schema' },
    team: [{ type: mongoose_1.Schema.Types.ObjectId, ref: 'f_nested_schema', form: { directive: 'fng-ui-select', fngUiSelect: { fngAjax: true } } }],
    team2: { type: [mongoose_1.Schema.Types.ObjectId], ref: 'f_nested_schema', form: { directive: 'fng-ui-select', fngUiSelect: { fngAjax: true } } },
    accepted: Boolean
};
var ESchema = new mongoose_1.Schema(eSchemaDef);
var E;
try {
    E = (0, mongoose_1.model)('e_referencing_another_collection');
}
catch (e) {
    E = (0, mongoose_1.model)('e_referencing_another_collection', ESchema);
}
ESchema.statics.report = function (report) {
    var reportSchema = '';
    switch (report) {
        case 'class-sizes':
            reportSchema = {
                pipeline: [
                    { $group: { _id: '$teacher', count: { '$sum': 1 } } }
                ],
                title: 'Class Sizes',
                columnDefs: [
                    { field: '_id', displayName: 'Teacher' },
                    { field: 'count', displayName: 'Number in Class' }
                ],
                columnTranslations: [
                    { field: '_id', ref: 'b_enhanced_schema' }
                ]
            };
            break;
    }
    return reportSchema;
};
ESchema.statics.form = function (layout) {
    var formSchema = '';
    switch (layout) {
        case 'links':
            formSchema = {
                surname: {},
                forename: {},
                weight: {},
                leadMentor: { link: { linkOnly: true } },
                mentor: { link: { linkOnly: false, label: true } }
            };
            break;
    }
    return formSchema;
};
module.exports = {
    model: E
};
//# sourceMappingURL=e_referencing_another_collection.js.map


text:
package gov.nasa.jpf.listener;

import gov.nasa.jpf.Config;
import gov.nasa.jpf.ListenerAdapter;
import gov.nasa.jpf.vm.ClassInfo;
import gov.nasa.jpf.vm.ElementInfo;
import gov.nasa.jpf.vm.VM;
import gov.nasa.jpf.vm.ThreadInfo;
import gov.nasa.jpf.jvm.bytecode.ALOAD;
import gov.nasa.jpf.jvm.bytecode.ARETURN;
import gov.nasa.jpf.jvm.bytecode.ASTORE;
import gov.nasa.jpf.jvm.bytecode.IFNONNULL;
import gov.nasa.jpf.jvm.bytecode.IFNULL;
import gov.nasa.jpf.vm.bytecode.InstanceFieldInstruction;
import gov.nasa.jpf.vm.Instruction;
import gov.nasa.jpf.jvm.bytecode.MONITORENTER;
import gov.nasa.jpf.jvm.bytecode.VirtualInvocation;
import gov.nasa.jpf.vm.StackFrame;

/**
 *
 */
public class NonSharedChecker extends ListenerAdapter {

  boolean throwOnCycle = false;

  static class Access {
    ThreadInfo ti;
    Access prev;

    Access(ThreadInfo ti, Access prev){
      this.ti = ti;
      this.prev = prev;
    }

    // <2do> get a better hashCode for state hashing
    public int hashCode() {
      int h = ti.getId();
      for (Access p = prev; p!= null; p = p.prev){
        h = 31*h + p.ti.getId();
      }
      return h;
    }
    // but we don't care for equals()
  }

  public NonSharedChecker (Config conf){
    throwOnCycle = conf.getBoolean("nonshared.throw_on_cycle");
  }

  boolean isNonShared(ElementInfo ei){
    ClassInfo ci = ei.getClassInfo();
    return (ci.getAnnotation("gov.nasa.jpf.annotation.NonShared") != null);
  }

  boolean checkLiveCycles (ElementInfo ei, ThreadInfo ti, Access ac){
    if (ti == ac.ti){
      return true; // Ok, fine - no need to record

    } else {
      boolean foundLiveOne = false;
      for (Access a = ac; a != null; a = a.prev){
        ThreadInfo t = a.ti;
        if (t == ti){ // cycle detected
          return !foundLiveOne;
        }
        foundLiveOne = (foundLiveOne || t.isAlive()); // <2do> maybe we should check for non-blocked threads
      }

      // new one, record it in the access history of the object
      ac = new Access(ti, ac);
      ei = ei.getModifiableInstance();
      ei.setObjectAttr(ac);
    }

    return true;
  }

  @Override
  public void executeInstruction (VM vm, ThreadInfo ti, Instruction insn){

    ElementInfo ei = null;

    if (ti.isFirstStepInsn()) {
      return;
    }

    if (insn instanceof InstanceFieldInstruction){
      ei = ((InstanceFieldInstruction)insn).peekElementInfo(ti);
    } else if (insn instanceof VirtualInvocation){
      ei = ((VirtualInvocation)insn).getThisElementInfo(ti);  // Outch - that's expensive
    } else if (insn instanceof MONITORENTER ||
               insn instanceof ASTORE ||
               insn instanceof ARETURN ||
               insn instanceof IFNONNULL ||
               insn instanceof IFNULL) {
      StackFrame frame = ti.getTopFrame();
      int ref = frame.peek();
      if (ref != -1){
        ei = ti.getElementInfo(ref);
      }
    } else if (insn instanceof ALOAD){
      StackFrame frame = ti.getTopFrame();
      int ref = frame.getLocalVariable(((ALOAD)insn).getLocalVariableIndex());
      if (ref != -1){
        ei = ti.getElementInfo(ref);
      }
    }

    if (ei != null){
      Access ac = ei.getObjectAttr(Access.class);
      if (ac != null){
        if (!checkLiveCycles(ei,ti,ac)){
          StringBuilder sb = new StringBuilder("NonShared object: ");
          sb.append( ei);
          sb.append(" accessed in live thread cycle: ");
          sb.append( ti.getName());
          for (Access a = ac; a != null; a = a.prev ){
            sb.append(',');
            sb.append(a.ti.getName());
          }
          String msg = sb.toString();

          if (throwOnCycle){
            ti.setNextPC( ti.createAndThrowException("java.lang.AssertionError", msg));
          } else {
            System.err.println("WARNING: " + msg);
            System.err.println("\tat " + insn.getSourceLocation());
          }
          return;
        }
      }
    }
  }

  @Override
  public void objectCreated (VM vm, ThreadInfo ti, ElementInfo ei){
    if (isNonShared(ei)){
      ei.setObjectAttrNoClone(new Access(ti, null));
    }
  }
}


text:
package com.intellij.lang.ant.validation;

import com.intellij.lang.ant.dom.AntDomFileDescription;
import com.intellij.openapi.editor.HectorComponentPanel;
import com.intellij.openapi.editor.HectorComponentPanelsProvider;
import com.intellij.psi.PsiFile;
import com.intellij.psi.xml.XmlFile;
import org.jetbrains.annotations.NotNull;

/**
 * @author Eugene Zhuravlev
 */
public class AntHectorPanelProvider implements HectorComponentPanelsProvider{
  public HectorComponentPanel createConfigurable(@NotNull final PsiFile file) {
    if (file instanceof XmlFile && AntDomFileDescription.isAntFile(((XmlFile)file))) {
      return new AntHectorConfigurable(((XmlFile)file));
    }
    return null;
  }
}


text:
module.exports = {
  spec: 'functionalTests-lib/**/*.js',
  ignore: 'functionalTests-lib/node_modules/**',
  require: [
    require.resolve('iconv-lite/encodings'),
    require.resolve('mock-fs'),
    require.resolve('./functionalTests/test_env')
  ],
};


text:
module.exports =
/******/ (function(modules) { // webpackBootstrap
/******/ 	// The module cache
/******/ 	var installedModules = {};

/******/ 	// The require function
/******/ 	function __webpack_require__(moduleId) {

/******/ 		// Check if module is in cache
/******/ 		if(installedModules[moduleId])
/******/ 			return installedModules[moduleId].exports;

/******/ 		// Create a new module (and put it into the cache)
/******/ 		var module = installedModules[moduleId] = {
/******/ 			exports: {},
/******/ 			id: moduleId,
/******/ 			loaded: false
/******/ 		};

/******/ 		// Execute the module function
/******/ 		modules[moduleId].call(module.exports, module, module.exports, __webpack_require__);

/******/ 		// Flag the module as loaded
/******/ 		module.loaded = true;

/******/ 		// Return the exports of the module
/******/ 		return module.exports;
/******/ 	}

/******/ 	// expose the modules object (__webpack_modules__)
/******/ 	__webpack_require__.m = modules;

/******/ 	// expose the module cache
/******/ 	__webpack_require__.c = installedModules;

/******/ 	// __webpack_public_path__
/******/ 	__webpack_require__.p = "";

/******/ 	// Load entry module and return exports
/******/ 	return __webpack_require__(0);
/******/ })
/************************************************************************/
/******/ ({

/***/ 0:
/***/ (function(module, exports, __webpack_require__) {

	__webpack_require__(973);
	module.exports = __webpack_require__(973);

/***/ }),

/***/ 973:
/***/ (function(module, exports) {

	(function ($, undefined) {
	/* FlatColorPicker messages */

	if (kendo.ui.FlatColorPicker) {
	kendo.ui.FlatColorPicker.prototype.options.messages =
	$.extend(true, kendo.ui.FlatColorPicker.prototype.options.messages,{
	  "apply": "Aplicar",
	  "cancel": "Cancelar"
	});
	}

	/* ColorPicker messages */

	if (kendo.ui.ColorPicker) {
	kendo.ui.ColorPicker.prototype.options.messages =
	$.extend(true, kendo.ui.ColorPicker.prototype.options.messages,{
	  "apply": "Aplicar",
	  "cancel": "Cancelar"
	});
	}

	/* ColumnMenu messages */

	if (kendo.ui.ColumnMenu) {
	kendo.ui.ColumnMenu.prototype.options.messages =
	$.extend(true, kendo.ui.ColumnMenu.prototype.options.messages,{
	  "sortAscending": "Ordenação Ascendente",
	  "sortDescending": "Ordenação Descendente",
	  "filter": "Filtro",
	  "columns": "Colunas",
	  "done": "Feito",
	  "settings": "Definições da Coluna",
	  "lock": "Trancar",
	  "unlock": "Destrancar"
	});
	}

	/* Editor messages */

	if (kendo.ui.Editor) {
	kendo.ui.Editor.prototype.options.messages =
	$.extend(true, kendo.ui.Editor.prototype.options.messages,{
	  "bold": "Negrito",
	  "italic": "Itálico",
	  "underline": "Sublinhado",
	  "strikethrough": "Rasurado",
	  "superscript": "Superior à linha",
	  "subscript": "Inferior à linha",
	  "justifyCenter": "Centrar texto",
	  "justifyLeft": "Alinhar texto à esquerda",
	  "justifyRight": "Alinhar texto à direita",
	  "justifyFull": "Justificar",
	  "insertUnorderedList": "Inserir lista de marcas",
	  "insertOrderedList": "Inserir lista numerada",
	  "indent": "Aumentar avanço",
	  "outdent": "Diminuir avanço",
	  "createLink": "Inserir ligação",
	  "unlink": "Remover ligação",
	  "insertImage": "Inserir imagem",
	  "insertFile": "Inserir ficheiro",
	  "insertHtml": "Inserir HTML",
	  "viewHtml": "Ver HTML",
	  "fontName": "Selecionar tipo de letra",
	  "fontNameInherit": "(tipo de letra herdado)",
	  "fontSize": "Selecionar tamanho da letra",
	  "fontSizeInherit": "(tamanho herdado)",
	  "formatBlock": "Formatar",
	  "formatting": "Formatar",
	  "foreColor": "Cor",
	  "backColor": "Cor do fundo",
	  "style": "Estilos",
	  "emptyFolder": "Pasta Vazia",
	  "uploadFile": "Submeter",
	  "orderBy": "Ordenar por:",
	  "orderBySize": "Tamanho",
	  "orderByName": "Nome",
	  "invalidFileType": "O ficheiro selecionado \"{0}\" não é válido. Tipos suportados são {1}.",
	  "deleteFile": 'Tem a certeza que quer eliminar "{0}"?',
	  "overwriteFile": 'Um ficheiro com o nome "{0}" já existe na pasta atual. Quer substituí-lo?',
	  "directoryNotFound": "Não foi encontrada nenhuma pasta com este nome.",
	  "imageWebAddress": "Endereço Web",
	  "imageAltText": "Texto alternativo",
	  "imageWidth": "Largura (px)",
	  "imageHeight": "Altura (px)",
	  "fileWebAddress": "Endereço Web",
	  "fileTitle": "Título",
	  "linkWebAddress": "Endereço Web",
	  "linkText": "Texto",
	  "linkToolTip": "ToolTip",
	  "linkOpenInNewWindow": "Abrir ligação numa nova janela",
	  "dialogUpdate": "Atualizar",
	  "dialogInsert": "Inserir",
	  "dialogButtonSeparator": "ou",
	  "dialogCancel": "Cancelar",
	  "createTable": "Criar tabela",
	  "addColumnLeft": "Adicionar coluna à esquerda",
	  "addColumnRight": "Adicionar coluna à direita",
	  "addRowAbove": "Adicionar linha acima",
	  "addRowBelow": "Adicionar linha abaixo",
	  "deleteRow": "Eliminar linha",
	  "deleteColumn": "Eliminar coluna"
	});
	}

	/* FileBrowser messages */

	if (kendo.ui.FileBrowser) {
	kendo.ui.FileBrowser.prototype.options.messages =
	$.extend(true, kendo.ui.FileBrowser.prototype.options.messages,{
	  "uploadFile": "Submeter",
	  "orderBy": "Ordenar por",
	  "orderByName": "Nome",
	  "orderBySize": "Tamanho",
	  "directoryNotFound": "Não foi encontrada nenhuma pasta com este nome.",
	  "emptyFolder": "Pasta Vazia",
	  "deleteFile": 'Tem a certeza que quer eliminar "{0}"?',
	  "invalidFileType": "O ficheiro selecionado \"{0}\" não é válido. Tipos suportados são {1}.",
	  "overwriteFile": "Um ficheiro com o nome \"{0}\" já existe nesta pasta. Quer substituí-lo?",
	  "dropFilesHere": "Largue um ficheiro aqui para o submeter",
	  "search": "Pesquisar"
	});
	}

	/* FilterCell messages */

	if (kendo.ui.FilterCell) {
	kendo.ui.FilterCell.prototype.options.messages =
	$.extend(true, kendo.ui.FilterCell.prototype.options.messages,{
	  "isTrue": "é verdadeiro",
	  "isFalse": "é falso",
	  "filter": "Filtrar",
	  "clear": "Limpar",
	  "operator": "Operador"
	});
	}

	/* FilterCell operators */

	if (kendo.ui.FilterCell) {
	kendo.ui.FilterCell.prototype.options.operators =
	$.extend(true, kendo.ui.FilterCell.prototype.options.operators,{
	  "string": {
	    "eq": "É igual a",
	    "neq": "Não é igual a",
	    "startswith": "Começa com",
	    "contains": "Contém",
	    "doesnotcontain": "Não contém",
	    "endswith": "Termina com",
	    "isnull": "É nulo",
	    "isnotnull": "É não nulo",
	    "isempty": "É vazio",
	    "isnotempty": "É não vazio"
	  },
	  "number": {
	    "eq": "É igual a",
	    "neq": "Não é igual a",
	    "gte": "É maior ou igual a",
	    "gt": "É maior que",
	    "lte": "É menor ou igual a",
	    "lt": "É menor que",
	    "isnull": "É nulo",
	    "isnotnull": "É não nulo"
	  },
	  "date": {
	    "eq": "É igual a",
	    "neq": "Não é igual a",
	    "gte": "É posterior ou igual a",
	    "gt": "É posterior a",
	    "lte": "É anterior ou igual a",
	    "lt": "É anterior a",
	    "isnull": "É nulo",
	    "isnotnull": "É não nulo"
	  },
	  "enums": {
	    "eq": "É igual a",
	    "neq": "Não é igual a",
	    "isnull": "É nulo",
	    "isnotnull": "É não nulo"
	  }
	});
	}

	/* FilterMenu messages */

	if (kendo.ui.FilterMenu) {
	kendo.ui.FilterMenu.prototype.options.messages =
	$.extend(true, kendo.ui.FilterMenu.prototype.options.messages,{
	  "info": "Mostrar itens com valor que:",
	  "isTrue": "é verdadeiro",
	  "isFalse": "é falso",
	  "filter": "Filtrar",
	  "clear": "Limpar",
	  "and": "E",
	  "or": "OU",
	  "selectValue": "-Selecionar valor-",
	  "operator": "Operador",
	  "value": "Valor",
	  "cancel": "Cancelar"
	});
	}

	/* FilterMenu operator messages */

	if (kendo.ui.FilterMenu) {
	kendo.ui.FilterMenu.prototype.options.operators =
	$.extend(true, kendo.ui.FilterMenu.prototype.options.operators,{
	  "string": {
	    "eq": "É igual a",
	    "neq": "Não é igual a",
	    "startswith": "Começa com",
	    "contains": "Contém",
	    "doesnotcontain": "Não contém",
	    "endswith": "Termina com",
	    "isnull": "É nulo",
	    "isnotnull": "É não nulo",
	    "isempty": "É vazio",
	    "isnotempty": "É não vazio"
	  },
	  "number": {
	    "eq": "É igual a",
	    "neq": "Não é igual a",
	    "gte": "É maior ou igual a",
	    "gt": "É maior que",
	    "lte": "É menor ou igual a",
	    "lt": "É menor que",
	    "isnull": "É nulo",
	    "isnotnull": "É não nulo"
	  },
	  "date": {
	    "eq": "É igual a",
	    "neq": "Não é igual a",
	    "gte": "É posterior ou igual a",
	    "gt": "É posterior a",
	    "lte": "É anterior ou igual a",
	    "lt": "É anterior a",
	    "isnull": "É nulo",
	    "isnotnull": "É não nulo"
	  },
	  "enums": {
	    "eq": "É igual a",
	    "neq": "Não é igual a",
	    "isnull": "É nulo",
	    "isnotnull": "É não nulo"
	  }
	});
	}

	/* FilterMultiCheck messages */

	if (kendo.ui.FilterMultiCheck) {
	kendo.ui.FilterMultiCheck.prototype.options.messages =
	$.extend(true, kendo.ui.FilterMultiCheck.prototype.options.messages,{
	  "checkAll": "Selecionar Tudo",
	  "clear": "Limpar",
	  "filter": "Filtrar",
	  "search": "Pesquisar"
	});
	}

	/* Gantt messages */

	if (kendo.ui.Gantt) {
	kendo.ui.Gantt.prototype.options.messages =
	$.extend(true, kendo.ui.Gantt.prototype.options.messages,{
	  "actions": {
	    "addChild": "Adicionar Descendente",
	    "append": "Adicionar Tarefa",
	    "insertAfter": "Adicionar Abaixo",
	    "insertBefore": "Adicionar Acima",
	    "pdf": "Exportar para PDF"
	  },
	  "cancel": "Cancelar",
	  "deleteDependencyWindowTitle": "Eliminar dependência",
	  "deleteTaskWindowTitle": "Eliminar tarefa",
	  "destroy": "Eliminar",
	  "editor": {
	    "assingButton": "Atribuir",
	    "editorTitle": "Tarefa",
	    "end": "Fim",
	    "percentComplete": "Completo",
	    "resources": "Recursos",
	    "resourcesEditorTitle": "Recursos",
	    "resourcesHeader": "Recursos",
	    "start": "Início",
	    "title": "Título",
	    "unitsHeader": "Unidades"
	  },
	  "save": "Guardar",
	  "views": {
	    "day": "Dia",
	    "end": "Fim",
	    "month": "Mês",
	    "start": "Início",
	    "week": "Semana",
	    "year": "Ano"
	  }
	});
	}

	/* Grid messages */

	if (kendo.ui.Grid) {
	kendo.ui.Grid.prototype.options.messages =
	$.extend(true, kendo.ui.Grid.prototype.options.messages,{
	  "commands": {
	    "cancel": "Cancelar alterações",
	    "canceledit": "Cancelar",
	    "create": "Adicionar novo registo",
	    "destroy": "Eliminar",
	    "edit": "Editar",
	    "excel": "Exportar para Excel",
	    "pdf": "Exportar para PDF",
	    "save": "Guardar alterações",
	    "select": "Selecionar",
	    "update": "Atualizar"
	  },
	  "editable": {
	    "cancelDelete": "Cancelar",
	    "confirmation": "Tem a certeza que pretende eliminar este registo?",
	    "confirmDelete": "Eliminar"
	  },
	  "noRecords": "Nenhum registo disponível."
	});
	}

	/* Groupable messages */

	if (kendo.ui.Groupable) {
	kendo.ui.Groupable.prototype.options.messages =
	$.extend(true, kendo.ui.Groupable.prototype.options.messages,{
	  "empty": "Arraste uma coluna para este espaço para agrupar pelo valor da mesma"
	});
	}

	/* NumericTextBox messages */

	if (kendo.ui.NumericTextBox) {
	kendo.ui.NumericTextBox.prototype.options =
	$.extend(true, kendo.ui.NumericTextBox.prototype.options,{
	  "upArrowText": "Aumentar valor",
	  "downArrowText": "Diminuir valor"
	});
	}

	/* Pager messages */

	if (kendo.ui.Pager) {
	kendo.ui.Pager.prototype.options.messages =
	$.extend(true, kendo.ui.Pager.prototype.options.messages,{
	  "allPages": "Tudo",
	  "display": "Registos {0} - {1} de {2}",
	  "empty": "Sem registos para apresentar.",
	  "page": "Página",
	  "of": "de {0}",
	  "itemsPerPage": "itens por página",
	  "first": "Ir para a primeira página",
	  "previous": "Ir para a página anterior",
	  "next": "Ir para a próxima página",
	  "last": "Ir para a última página",
	  "refresh": "Atualizar",
	  "morePages": "Mais páginas"
	});
	}

	/* PivotGrid messages */

	if (kendo.ui.PivotGrid) {
	kendo.ui.PivotGrid.prototype.options.messages =
	$.extend(true, kendo.ui.PivotGrid.prototype.options.messages,{
	  "measureFields": "Largue campos de dados aqui",
	  "columnFields": "Largue campos de colunas aqui",
	  "rowFields": "Largue campos de linhas aqui"
	});
	}

	/* PivotFieldMenu messages */

	if (kendo.ui.PivotFieldMenu) {
	kendo.ui.PivotFieldMenu.prototype.options.messages =
	$.extend(true, kendo.ui.PivotFieldMenu.prototype.options.messages,{
	  "info": "mostrar itens com valor que:",
	  "filterFields": "Filtro de Campos",
	  "filter": "Filtrar",
	  "include": "Incluir Campos...",
	  "title": "Campos a incluir",
	  "clear": "Limpar",
	  "ok": "Ok",
	  "cancel": "Cancelar",
	  "operators": {
	    "contains": "Contém",
	    "doesnotcontain": "Não contém",
	    "startswith": "Começa com",
	    "endswith": "Termina com",
	    "eq": "É igual a",
	    "neq": "Não é igual a"
	  }
	});
	}

	/* RecurrenceEditor messages */

	if (kendo.ui.RecurrenceEditor) {
	kendo.ui.RecurrenceEditor.prototype.options.messages =
	$.extend(true, kendo.ui.RecurrenceEditor.prototype.options.messages,{
	  "frequencies": {
	    "never": "Nunca",
	    "hourly": "A cada hora",
	    "daily": "Diariamente",
	    "weekly": "Semanalmente",
	    "monthly": "Mensalmente",
	    "yearly": "Anualmente"
	  },
	  "hourly": {
	    "repeatEvery": "Repetir a cada: ",
	    "interval": " hora(s)"
	  },
	  "daily": {
	    "repeatEvery": "Repetir a cada: ",
	    "interval": " dia(s)"
	  },
	  "weekly": {
	    "interval": " semana(s)",
	    "repeatEvery": "Repetir a cada: ",
	    "repeatOn": "Repetir em: "
	  },
	  "monthly": {
	    "repeatEvery": "Repetir a cada: ",
	    "repeatOn": "Repetir em: ",
	    "interval": " mês(es)",
	    "day": "Dia "
	  },
	  "yearly": {
	    "repeatEvery": "Repetir a cada: ",
	    "repeatOn": "Repetir em: ",
	    "interval": " ano(s)",
	    "of": " de "
	  },
	  "end": {
	    "label": "Fim:",
	    "mobileLabel": "Fim",
	    "never": "Nunca",
	    "after": "Depois",
	    "occurrence": " ocorrência(s)",
	    "on": "Em "
	  },
	  "offsetPositions": {
	    "first": "primeiro",
	    "second": "segundo",
	    "third": "terceiro",
	    "fourth": "quarto",
	    "last": "último"
	  },
	  "weekdays": {
	    "day": "dia",
	    "weekday": "semana",
	    "weekend": "fim de semana"
	  }
	});
	}

	/* Scheduler messages */

	if (kendo.ui.Scheduler) {
	kendo.ui.Scheduler.prototype.options.messages =
	$.extend(true, kendo.ui.Scheduler.prototype.options.messages,{
	  "allDay": "todo o dia",
	  "date": "Data",
	  "event": "Evento",
	  "time": "Hora",
	  "showFullDay": "Mostrar dia completo",
	  "showWorkDay": "Mostrar horário de trabalho",
	  "today": "Hoje",
	  "save": "Guardar",
	  "cancel": "Cancelar",
	  "destroy": "Eliminar",
	  "deleteWindowTitle": "Eliminar evento",
	  "ariaSlotLabel": "Selecionado entre {0:t} e {1:t}",
	  "ariaEventLabel": "{0} em {1:D} às {2:t}",
	  "editable": {
	    "confirmation": "Tem a certeza que quer eliminar este evento?"
	  },
	  "views": {
	    "day": "Dia",
	    "week": "Semana",
	    "workWeek": "Semana de Trabalho",
	    "agenda": "Agenda",
	    "month": "Mês"
	  },
	  "recurrenceMessages": {
	    "deleteWindowTitle": "Eliminar item recorrente",
	    "deleteWindowOccurrence": "Eliminar ocorrência atual",
	    "deleteWindowSeries": "Eliminar série de ocorrências",
	    "editWindowTitle": "Editar Item Recorrente",
	    "editWindowOccurrence": "Editar ocorrência atual",
	    "editWindowSeries": "Editar série de ocorrências",
	    "deleteRecurring": "Quer eliminar só esta ocorrência ou toda a série de ocorrências?",
	    "editRecurring": "Quer editar só esta ocorrência ou toda a série de ocorrências?"
	  },
	  "editor": {
	    "title": "Titulo",
	    "start": "Início",
	    "end": "Fim",
	    "allDayEvent": "Evento todo o dia",
	    "description": "Descrição",
	    "repeat": "Repetição",
	    "timezone": " ",
	    "startTimezone": "Início do fuso horário",
	    "endTimezone": "Fim do fuso horário",
	    "separateTimezones": "Usar fusos horários de início e fim separados",
	    "timezoneEditorTitle": "Fusos Horários",
	    "timezoneEditorButton": "Fuso horário",
	    "timezoneTitle": "Fusos Horários",
	    "noTimezone": "Sem fuso horário",
	    "editorTitle": "Evento"
	  }
	});
	}

	/* Spreadsheet messages */

	if (kendo.spreadsheet && kendo.spreadsheet.messages.borderPalette) {
	kendo.spreadsheet.messages.borderPalette =
	$.extend(true, kendo.spreadsheet.messages.borderPalette,{
	  "allBorders": "Todas as bordas",
	  "insideBorders": "Bordas interiores",
	  "insideHorizontalBorders": "Bordas interiores horizontais",
	  "insideVerticalBorders": "Bordas interiores verticais",
	  "outsideBorders": "Bordas exteriores",
	  "leftBorder": "Borda esquerda",
	  "topBorder": "Borda superior",
	  "rightBorder": "Borda direita",
	  "bottomBorder": "Borda inferior",
	  "noBorders": "Sem bordas",
	  "reset": "Reiniciar cor",
	  "customColor": "Personalizar cor...",
	  "apply": "Aplicar",
	  "cancel": "Cancelar"
	});
	}

	if (kendo.spreadsheet && kendo.spreadsheet.messages.dialogs) {
	kendo.spreadsheet.messages.dialogs =
	$.extend(true, kendo.spreadsheet.messages.dialogs,{
	  "apply": "Aplicar",
	  "save": "Guardar",
	  "cancel": "Cancelar",
	  "remove": "Remover",
	  "retry": "Tentar Novamente",
	  "revert": "Reverter",
	  "okText": "OK",
	  "formatCellsDialog": {
	    "title": "Formatar",
	    "categories": {
	      "number": "Número",
	      "currency": "Moeda",
	      "date": "Data"
	      }
	  },
	  "fontFamilyDialog": {
	    "title": "Tipo de Letra"
	  },
	  "fontSizeDialog": {
	    "title": "Tamanho da Letra"
	  },
	  "bordersDialog": {
	    "title": "Bordas"
	  },
	  "alignmentDialog": {
	    "title": "Alinhamento de texto",
	    "buttons": {
	     "justtifyLeft": "Alinhar à esquerda",
	     "justifyCenter": "Centro",
	     "justifyRight": "Alinhar à direita",
	     "justifyFull": "Justificar",
	     "alignTop": "Alinhar ao topo",
	     "alignMiddle": "Alinhar ao centro",
	     "alignBottom": "Alinhar ao fundo"
	    }
	  },
	  "mergeDialog": {
	    "title": "Unir Células",
	    "buttons": {
	      "mergeCells": "Unir tudo",
	      "mergeHorizontally": "Unir horizontalmente",
	      "mergeVertically": "Unir verticalmente",
	      "unmerge": "Desunir"
	    }
	  },
	  "freezeDialog": {
	    "title": "Congelar painéis",
	    "buttons": {
	      "freezePanes": "Congelar painéis",
	      "freezeRows": "Congelar linhas",
	      "freezeColumns": "Congelar colunas",
	      "unfreeze": "Descongelar painéis"
	    }
	  },
	  "validationDialog": {
	    "title": "Validação de Dados",
	    "hintMessage": "Por favor indique um valor {1} válido {0}.",
	    "hintTitle": "Validação {0}",
	    "criteria": {
	      "any": "Qualquer valor",
	      "number": "Número",
	      "text": "Texto",
	      "date": "Data",
	      "custom": "Personalizar Fórmula",
	      "list": "Lista"
	    },
	    "comparers": {
	      "greaterThan": "maior que",
	      "lessThan": "menor que",
	      "between": "entre",
	      "notBetween": "não entre",
	      "equalTo": "igual a",
	      "notEqualTo": "não igual a",
	      "greaterThanOrEqualTo": "maior que ou igual a",
	      "lessThanOrEqualTo": "menor que ou igual a"
	    },
	    "comparerMessages": {
	      "greaterThan": "maior que {0}",
	      "lessThan": "menor que {0}",
	      "between": "entre {0} e {1}",
	      "notBetween": "não entre {0} e {1}",
	      "equalTo": "igual a {0}",
	      "notEqualTo": "não igual a {0}",
	      "greaterThanOrEqualTo": "maior que ou igual a {0}",
	      "lessThanOrEqualTo": "menor que ou igual a {0}",
	      "custom": "que satisfaça a fórmula: {0}"
	    },
	    "labels": {
	      "criteria": "Critério",
	      "comparer": "Comparador",
	      "min": "Min",
	      "max": "Max",
	      "value": "Valor",
	      "start": "Inicio",
	      "end": "Fim",
	      "onInvalidData": "Quando dados inválidos",
	      "rejectInput": "Rejeitar entrada",
	      "showWarning": "Mostrar aviso",
	      "showHint": "Mostrar dica",
	      "hintTitle": "Título da dica",
	      "hintMessage": "Mensagem da dica",
	      "ignoreBlank": "Ignorar brancos"
	    },
	    "placeholders": {
	      "typeTitle": "Digite o título",
	      "typeMessage": "Digite a mensagem"
	    }
	  },
	  "saveAsDialog": {
	    "title": "Guardar Como...",
	    "labels": {
	      "fileName": "Nome do ficheiro",
	      "saveAsType": "Guardar como tipo"
	    }
	  },
	  "exportAsDialog": {
	    "title": "Exportar...",
	    "labels": {
	      "fileName": "Nome do ficheiro",
	      "saveAsType": "Guardar como tipo",
	      "exportArea": "Exportar",
	      "paperSize": "Dimensão do papel",
	      "margins": "Margens",
	      "orientation": "Orientação",
	      "print": "Imprimir",
	      "guidelines": "Guias",
	      "center": "Centrar",
	      "horizontally": "Horizontalmente",
	      "vertically": "Verticalmente"
	    }
	  },
	  "modifyMergedDialog": {
	    "errorMessage": "Não pode fazer parte de uma célula unida."
	  },
	  "useKeyboardDialog": {
	    "title": "Copiar e colar",
	    "errorMessage": "Estas ações não podem ser invocadas pelo menu. Por favor use antes os atalhos do teclado:",
	    "labels": {
	      "forCopy": "para copiar",
	      "forCut": "para cortar",
	      "forPaste": "para colar"
	    }
	  },
	  "unsupportedSelectionDialog": {
	    "errorMessage": "Esta ação não pode ser efectuada em seleções múltiplas."
	  }
	});
	}

	if (kendo.spreadsheet && kendo.spreadsheet.messages.filterMenu) {
	kendo.spreadsheet.messages.filterMenu =
	$.extend(true, kendo.spreadsheet.messages.filterMenu,{
	  "sortAscending": "Ordenar intervalo de A a Z",
	  "sortDescending": "Ordenar intervalo de Z a A",
	  "filterByValue": "Filtrar por valor",
	  "filterByCondition": "Filtrar por condição",
	  "apply": "Aplicar",
	  "search": "Pesquisar",
	  "addToCurrent": "Adicionar à seleção atual",
	  "clear": "Limpar",
	  "blanks": "(Brancos)",
	  "operatorNone": "Nenhum",
	  "and": "E",
	  "or": "OU",
	  "operators": {
	    "string": {
	      "contains": "Texto contém",
	      "doesnotcontain": "Texto não contém",
	      "startswith": "Texto começa com",
	      "endswith": "Texto termina com"
	    },
	    "date": {
	      "eq":  "Data é",
	      "neq": "Data não é",
	      "lt":  "Data é anterior",
	      "gt":  "Data é posterior"
	    },
	    "number": {
	      "eq": "É igual a",
	      "neq": "Não é igual a",
	      "gte": "É maior que ou igual a",
	      "gt": "É maior que",
	      "lte": "É menor que ou igual a",
	      "lt": "É menor que"
	    }
	  }
	});
	}

	if (kendo.spreadsheet && kendo.spreadsheet.messages.toolbar) {
	kendo.spreadsheet.messages.toolbar =
	$.extend(true, kendo.spreadsheet.messages.toolbar,{
	  "addColumnLeft": "Adicionar coluna à esquerda",
	  "addColumnRight": "Adicionar coluna à direita",
	  "addRowAbove": "Adicionar linha acima",
	  "addRowBelow": "Adicionar linha abaixo",
	  "alignment": "Alinhmento",
	  "alignmentButtons": {
	    "justtifyLeft": "Alinhar à esquerda",
	    "justifyCenter": "Centrar",
	    "justifyRight": "Alinhar à direita",
	    "justifyFull": "Justificar",
	    "alignTop": "Alinhar ao topo",
	    "alignMiddle": "Alinhar ao meio",
	    "alignBottom": "Alinhar ao fundo"
	  },
	  "backgroundColor": "Fundo",
	  "bold": "Negrito",
	  "borders": "Bordas",
	  "colorPicker": {
	    "reset": "Repôr cor",
	    "customColor": "Personalizar cor..."
	  },
	  "copy": "Copiar",
	  "cut": "Cortar",
	  "deleteColumn": "Eliminar coluna",
	  "deleteRow": "Eliminar linha",
	  "excelImport": "Importar de Excel...",
	  "filter": "Filtrar",
	  "fontFamily": "Tipo de letra",
	  "fontSize": "Tamanho da letra",
	  "format": "Personalizar formatação...",
	  "formatTypes": {
	    "automatic": "Automático",
	    "number": "Número",
	    "percent": "Percentagem",
	    "financial": "Financeiro",
	    "currency": "Moeda",
	    "date": "Data",
	    "time": "Hora",
	    "dateTime": "Data e hora",
	    "duration": "Duração",
	    "moreFormats": "Mais formatos..."
	  },
	  "formatDecreaseDecimal": "Decrementar decimais",
	  "formatIncreaseDecimal": "Incrementar decimais",
	  "freeze": "Congelar painéis",
	  "freezeButtons": {
	    "freezePanes": "Congelar paineis",
	    "freezeRows": "Congelar linhas",
	    "freezeColumns": "Congelar colunas",
	    "unfreeze": "Descongelar painéis"
	  },
	  "italic": "Itálico",
	  "merge": "Unir células",
	  "mergeButtons": {
	    "mergeCells": "Unir tudo",
	    "mergeHorizontally": "Unir horizontalmente",
	    "mergeVertically": "Unir verticalmente",
	    "unmerge": "Desunir"
	  },
	  "open": "Abrir...",
	  "paste": "Colar",
	  "quickAccess": {
	    "redo": "Refazer",
	    "undo": "Desfazer"
	  },
	  "saveAs": "Guardar como...",
	  "sortAsc": "Ordenação ascendente",
	  "sortDesc": "Ordenação descendente",
	  "sortButtons": {
	    "sortSheetAsc": "Ordenar folha de A a Z",
	    "sortSheetDesc": "Ordenar folha de Z a A",
	    "sortRangeAsc": "Ordenar folha de A a Z",
	    "sortRangeDesc": "Ordenar folha de Z a A"
	  },
	  "textColor": "Cor do Texto",
	  "textWrap": "Quebrar texto",
	  "underline": "Sublinhado",
	  "validation": "Validação de dados..."
	});
	}

	if (kendo.spreadsheet && kendo.spreadsheet.messages.view) {
	kendo.spreadsheet.messages.view =
	$.extend(true, kendo.spreadsheet.messages.view,{
	  "errors": {
	    "shiftingNonblankCells": "Não é possível inserir células devido a possível perda de dados. Escolha outra localização para inserir ou elimine os dados do final da sua folha de dados.",
	    "filterRangeContainingMerges": "Não é possível criar um filtro dentro de um intervalo contendo uniões",
	    "validationError": "O valor que indicou viola as regras de validação definidas na célula."
	  },
	  "tabs": {
	    "home": "Início",
	    "insert": "Inserir",
	    "data": "Dados"
	  }
	});
	}

	/* Slider messages */

	if (kendo.ui.Slider) {
	kendo.ui.Slider.prototype.options =
	$.extend(true, kendo.ui.Slider.prototype.options,{
	  "increaseButtonTitle": "Incrementar",
	  "decreaseButtonTitle": "Decrementar"
	});
	}

	/* TreeList messages */

	if (kendo.ui.TreeList) {
	kendo.ui.TreeList.prototype.options.messages =
	$.extend(true, kendo.ui.TreeList.prototype.options.messages,{
	  "noRows": "Sem registos para mostrar",
	  "loading": "A carregar...",
	  "requestFailed": "Pedido falhado.",
	  "retry": "Repetir",
	  "commands": {
	      "edit": "Editar",
	      "update": "Atualizar",
	      "canceledit": "Cancelar",
	      "create": "Adicionar novo registo",
	      "createchild": "Adicionar registo descendente",
	      "destroy": "Eliminar",
	      "excel": "Exportar para Excel",
	      "pdf": "Exportar para PDF"
	  }
	});
	}

	if (kendo.ui.TreeList) {
	kendo.ui.TreeList.prototype.options.columnMenu =
	$.extend(true, kendo.ui.TreeList.prototype.options.columnMenu, {
	    "messages": {
	        "columns": "Escolher colunas",
	        "filter": "Aplicar filtro",
	        "sortAscending": "Ordenar (asc)",
	        "sortDescending": "Ordenar (desc)"
	    }
	});
	}

	/* TreeView messages */

	if (kendo.ui.TreeView) {
	kendo.ui.TreeView.prototype.options.messages =
	$.extend(true, kendo.ui.TreeView.prototype.options.messages,{
	  "loading": "A carregar...",
	  "requestFailed": "O pedido falhou.",
	  "retry": "Repetir"
	});
	}

	/* Upload messages */

	if (kendo.ui.Upload) {
	kendo.ui.Upload.prototype.options.localization=
	$.extend(true, kendo.ui.Upload.prototype.options.localization,{
	  "select": "Selecionar ficheiros...",
	  "cancel": "Cancelar",
	  "retry": "Repetir",
	  "remove": "Remover",
	  "uploadSelectedFiles": "Submeter ficheiros",
	  "dropFilesHere": "largue ficheiros aqui para submeter",
	  "statusUploading": "a enviar",
	  "statusUploaded": "submetido",
	  "statusWarning": "aviso",
	  "statusFailed": "falhou",
	  "headerStatusUploading": "Enviando...",
	  "headerStatusUploaded": "Feito"
	});
	}

	/* Validator messages */

	if (kendo.ui.Validator) {
	kendo.ui.Validator.prototype.options.messages =
	$.extend(true, kendo.ui.Validator.prototype.options.messages,{
	  "required": "{0} é obrigatório",
	  "pattern": "{0} não é válido",
	  "min": "{0} deve ser maior ou igual a {1}",
	  "max": "{0} deve ser menor ou igual a {1}",
	  "step": "{0} não é válido",
	  "email": "{0} não é um email válido",
	  "url": "{0} não é um endereço web válido",
	  "date": "{0} não é uma data válida",
	  "dateCompare": "A data final deve ser posterior à data inicial"
	});
	}

	/* Dialog */

	if (kendo.ui.Dialog) {
	kendo.ui.Dialog.prototype.options.messages =
	$.extend(true, kendo.ui.Dialog.prototype.options.localization, {
	  "close": "Fechar"
	});
	}

	/* Alert */

	if (kendo.ui.Alert) {
	kendo.ui.Alert.prototype.options.messages =
	$.extend(true, kendo.ui.Alert.prototype.options.localization, {
	  "okText": "OK"
	});
	}

	/* Confirm */

	if (kendo.ui.Confirm) {
	kendo.ui.Confirm.prototype.options.messages =
	$.extend(true, kendo.ui.Confirm.prototype.options.localization, {
	  "okText": "OK",
	  "cancel": "Cancelar"
	});
	}

	/* Prompt */
	if (kendo.ui.Prompt) {
	kendo.ui.Prompt.prototype.options.messages =
	$.extend(true, kendo.ui.Prompt.prototype.options.localization, {
	  "okText": "OK",
	  "cancel": "Cancelar"
	});
	}

	})(window.kendo.jQuery);

/***/ })

/******/ });


text:
This library allows you to produce messages to the Kafka distributed publish/subscribe messaging service.

## Requirements
Tested on Ubuntu and Redhat both with g++ 4.4 and Boost 1.46.1

## Installation
Make sure you have g++ and the latest version of Boost:
http://gcc.gnu.org/
http://www.boost.org/

```bash
./autoconf.sh
./configure
```

Run this to generate the makefile for your system. Do this first.

```bash
make
```

builds the producer example and the KafkaConnect library

```bash
make check
```

builds and runs the unit tests,

```bash
make install
```

to install as a shared library to 'default' locations (/usr/local/lib and /usr/local/include on linux)

## Usage
Example.cpp is a very basic Kafka Producer

## API docs
There isn't much code, if I get around to writing the other parts of the library I'll document it sensibly,
for now have a look at the header file:  /src/producer.hpp

## Contact for questions

Ben Gray, MediaSift Ltd.

http://twitter.com/benjamg


text:
// Licensed to the .NET Foundation under one or more agreements.
// The .NET Foundation licenses this file to you under the MIT license.
// See the LICENSE file in the project root for more information.

using System.Collections.Immutable;

namespace Microsoft.CodeAnalysis
{
    /// <summary>
    /// The result of <see cref="SymbolKey.Resolve"/>. If the <see cref="SymbolKey"/> could be uniquely mapped to a
    /// single <see cref="ISymbol"/> then that will be returned in <see cref="Symbol"/>.  Otherwise, if the key resolves
    /// to multiple symbols (which can happen in error scenarios), then <see cref="CandidateSymbols"/> and <see
    /// cref="CandidateReason"/> will be returned.
    ///
    /// If no symbol can be found <see cref="Symbol"/> will be <c>null</c> and <see cref="CandidateSymbols"/>
    /// will be empty.
    /// </summary>
    internal readonly partial struct SymbolKeyResolution
    {
        private readonly ImmutableArray<ISymbol> _candidateSymbols;

        internal SymbolKeyResolution(ISymbol? symbol)
        {
            Symbol = symbol;
            _candidateSymbols = default;
            CandidateReason = CandidateReason.None;
        }

        internal SymbolKeyResolution(ImmutableArray<ISymbol> candidateSymbols, CandidateReason candidateReason)
        {
            Symbol = null;
            _candidateSymbols = candidateSymbols;
            CandidateReason = candidateReason;
        }

        internal int SymbolCount => Symbol != null ? 1 : CandidateSymbols.Length;

        public ISymbol? Symbol { get; }
        public CandidateReason CandidateReason { get; }
        public ImmutableArray<ISymbol> CandidateSymbols => _candidateSymbols.NullToEmpty();

        public Enumerator<ISymbol> GetEnumerator()
            => new(this);

        internal Enumerable<TSymbol> OfType<TSymbol>() where TSymbol : ISymbol
            => new(this);
    }
}


text:
class CreateRestaurantFoods < ActiveRecord::Migration[5.0]
  def change
    create_table :restaurant_foods do |t|
      t.integer :restaurant_id
      t.integer :food_id

      t.timestamps
    end
  end
end


text:
package dimitris.chess.core;

/**
 * Created by enviouscreep on 1/16/16.
 */
interface GameEventsDispatcher {
    void registerGameEventsListener(PuzzleGameEventsListener toRegister);
    void removeGameEventsListener(PuzzleGameEventsListener toRemove);
}


text:
from ....testing import assert_equal
from ..tensors import ConstrainedSphericalDeconvolution

def test_ConstrainedSphericalDeconvolution_inputs():
    input_map = dict(args=dict(argstr='%s',
    ),
    debug=dict(argstr='-debug',
    ),
    directions_file=dict(argstr='-directions %s',
    position=-2,
    ),
    encoding_file=dict(argstr='-grad %s',
    position=1,
    ),
    environ=dict(nohash=True,
    usedefault=True,
    ),
    filter_file=dict(argstr='-filter %s',
    position=-2,
    ),
    ignore_exception=dict(nohash=True,
    usedefault=True,
    ),
    in_file=dict(argstr='%s',
    mandatory=True,
    position=-3,
    ),
    iterations=dict(argstr='-niter %s',
    ),
    lambda_value=dict(argstr='-lambda %s',
    ),
    mask_image=dict(argstr='-mask %s',
    position=2,
    ),
    maximum_harmonic_order=dict(argstr='-lmax %s',
    ),
    normalise=dict(argstr='-normalise',
    position=3,
    ),
    out_filename=dict(argstr='%s',
    genfile=True,
    position=-1,
    ),
    response_file=dict(argstr='%s',
    mandatory=True,
    position=-2,
    ),
    terminal_output=dict(nohash=True,
    ),
    threshold_value=dict(argstr='-threshold %s',
    ),
    )
    inputs = ConstrainedSphericalDeconvolution.input_spec()

    for key, metadata in list(input_map.items()):
        for metakey, value in list(metadata.items()):
            yield assert_equal, getattr(inputs.traits()[key], metakey), value

def test_ConstrainedSphericalDeconvolution_outputs():
    output_map = dict(spherical_harmonics_image=dict(),
    )
    outputs = ConstrainedSphericalDeconvolution.output_spec()

    for key, metadata in list(output_map.items()):
        for metakey, value in list(metadata.items()):
            yield assert_equal, getattr(outputs.traits()[key], metakey), value


text:
import {
  HTTP_INTERCEPTORS,
  HttpHandler,
  HttpInterceptor,
  HttpRequest
} from '@angular/common/http'
import { Injectable } from '@angular/core'
import { catchError } from 'rxjs/operators'

import { ErrorService } from './error.service'

@Injectable()
export class RadarHttpInterceptor implements HttpInterceptor {
  intercept(req: HttpRequest<any>, next: HttpHandler) {
    return next.handle(req).pipe(catchError(ErrorService.handleError))
  }
}

export const RadarHttpInterceptorProvider = {
  provide: HTTP_INTERCEPTORS,
  useClass: RadarHttpInterceptor,
  multi: true
}


text:
using System;

class StartUp
{
    static void Main()
    {
        string citizenInfo;
        while ((citizenInfo = Console.ReadLine()) != "End")
        {
            var tokens = citizenInfo.Split();
            var name = tokens[0];
            var country = tokens[1];
            var age = int.Parse(tokens[2]);
            var currentCitizen = new Citizen(name,country,age);

            var currentIPerson = (IPerson)currentCitizen;
            var currentIResident = (IResident)currentCitizen;

            Console.WriteLine(currentIPerson.GetName());
            Console.WriteLine(currentIResident.GetName());
        }

    }
}


text:
<ScrollView xmlns:android="http://schemas.android.com/apk/res/android"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    android:layout_marginBottom="@dimen/activity_vertical_margin"
    android:layout_marginTop="@dimen/activity_vertical_margin">

    <LinearLayout xmlns:tools="http://schemas.android.com/tools"
        android:layout_width="match_parent"
        android:layout_height="match_parent"
        android:orientation="vertical"
        tools:context=".MainActivity">

        <TextView
            style="@style/TextView.Simple"
            android:layout_width="wrap_content"
            android:layout_height="wrap_content"
            android:text="@string/defaultVerbiage" />

        <ImageView
            android:id="@+id/mainImgDefault"
            android:layout_width="wrap_content"
            android:layout_height="wrap_content"
            android:layout_gravity="center_horizontal" />

        <TextView
            style="@style/TextView.Simple"
            android:layout_width="wrap_content"
            android:layout_height="wrap_content"
            android:text="@string/modVerbiage" />

        <ImageView
            android:id="@+id/mainImgMod"
            android:layout_width="wrap_content"
            android:layout_height="wrap_content"
            android:layout_gravity="center_horizontal" />

    </LinearLayout>

</ScrollView>