text:
    Please enter a valid Version Control URL.

    This field is mandatory in case of OSS Bintray repository.


text:
package TeamSeven.dispatcher;

import TeamSeven.common.message.BaseMessage;
import TeamSeven.common.message.client.ClientChatMessage;
import TeamSeven.common.message.client.ClientGroupChatMessage;
import TeamSeven.common.message.client.ClientLoginMessage;
import TeamSeven.common.message.client.ClientRespEncryptTypeMessage;
import TeamSeven.common.message.server.ServerAskEncryptTypeMessage;
import TeamSeven.handler.serverside.console.*;
import org.java_websocket.WebSocket;

/**
 * Created by joshoy on 16/4/18.
 */
public class ConsoleServerSideMessageDispatcher extends MessageDispatcher {

    public ConsoleServerSideMessageDispatcher(Object applier) {
        super(applier);
    }

    @Override
    public void dispatch(BaseMessage message, WebSocket conn)  {

        System.out.println("服务端接收到消息类型: " + message.getType().toString());

        switch (message.getType()) {
            case CLIENT_CHAT:
                handler = new ClientChatHandler((ClientChatMessage) message, conn, applier);
                break;
            case CLIENT_RESP_ENCRYPT_TYPE:
                handler = new ClientRespEncryptTypeHandler((ClientRespEncryptTypeMessage) message, conn, applier);
                break;
            case SERVER_ASK_ENCRYPT_TYPE:
                handler = new ServerAskEncryptTypeHandler((ServerAskEncryptTypeMessage) message, conn, applier);
                break;
            case CLIENT_LOGIN:
                handler = new ClientLoginHandler( (ClientLoginMessage) message, conn, applier );
                break;

            /**
             *  服务器分发  群组聊天的 信息
             */
            case CLIENT_GROUP_CHAT:
                handler = new ClientGroupChatHandler((ClientGroupChatMessage) message,conn,applier);
            default:
                break;
        }
        if (null == handler) {
            System.err.println("错误: 消息的handler还未定义! 消息类型为: " + message.getType().toString());
        }
        else {
            handler.onHandle();
        }
    }
}

redpajama_set_name: RedPajamaGithub


text:
import os
import sys
import json
import stat
import ctypes
import colorlog
import requests
import requests.cookies

from selenium import webdriver
from selenium.webdriver.common.desired_capabilities import DesiredCapabilities
from nyawc.helpers.HTTPRequestHelper import HTTPRequestHelper
from nyawc.helpers.URLHelper import URLHelper
from nyawc.http.Request import Request

try: # Python 3
    from urllib.parse import quote, urlparse
except: # Python 2
    from urllib import quote
    from urlparse import urlparse

class BrowserHelper:
    """The BrowserHelper enables headless web browsing.

    Attributes:
        __phantomjs_driver (str): The cached path to the executable PhantomJS driver.

    """

    __phantomjs_driver = None

    @staticmethod
    def request(queue_item):
        """Execute the given queue item and return the browser instance.

        Args:
            queue_item (:class:`nyawc.QueueItem`): The queue item to execute the JavaScript on.

        Returns:
            obj: The browser instance reference.

        """

        try:
            browser = BrowserHelper.__get_browser(queue_item)

            if queue_item.request.method == Request.METHOD_POST:
                browser.get('about:blank')
                browser.execute_script('window.doRequest=function(a,b,c){c=c||"post";var d=document.createElement("form");d.setAttribute("method",c),d.setAttribute("action",a),b=decodeURIComponent(b),b=JSON.parse(b);for(var e in b)if(b.hasOwnProperty(e)){var f=document.createElement("input");f.setAttribute("type","hidden"),f.setAttribute("name",e),f.setAttribute("value",b[e]),d.appendChild(f)}document.body.appendChild(d),d.submit()}')
                browser.execute_script('window.doRequest("{}", `{}`, "{}");'.format(queue_item.request.url, quote(json.dumps(queue_item.request.data)), queue_item.request.method));
            else:
                browser.get(queue_item.request.url)

            return browser
        except Exception as e:
            return None

    @staticmethod
    def javascript(queue_item, command):
        """Execute a JavaScript command on the given queue item.

        Args:
            queue_item (:class:`nyawc.QueueItem`): The queue item to execute the JavaScript on.
            command (str): The JavaScript command.

        Returns:
            str: The response of the JavaScript command.

        """

        try:
            browser = BrowserHelper.request(queue_item)
            response = browser.execute_script(command)
            browser.quit()
        except Exception as e:
            response = None

        return response

    @staticmethod
    def __get_browser(queue_item=None):
        """Get the PhantomJS browser.

        Args:
            queue_item (:class:`nyawc.QueueItem`): Use authentication/headers/cookies etc from this queue item (if given).

        Returns:
            obj: The PhantomJS Selenium object.

        """

        capabilities = dict(DesiredCapabilities.PHANTOMJS)
        service = []

        if queue_item:

            # Add authentication header to request
            if queue_item.request.auth:
                queue_item.request.auth(queue_item.request)

            # Add cookie header to request
            if queue_item.request.cookies:
                cookie_string = HTTPRequestHelper.get_cookie_header(queue_item)
                queue_item.request.headers["Cookie"] = cookie_string

            # Add headers to PhantomJS
            if queue_item.request.headers:
                default_headers = requests.utils.default_headers()
                for (key, value) in queue_item.request.headers.items():
                    if key.lower() == "user-agent":
                        capabilities["phantomjs.page.settings.userAgent"] = value
                    else:

                        # PhantomJS has issues with executing JavaScript on pages with GZIP encoding.
                        # See link for more information (https://github.com/detro/ghostdriver/issues/489).
                        if key == "Accept-Encoding" and "gzip" in value:
                            continue

                        capabilities["phantomjs.page.customHeaders." + key] = value

            # Proxies
            if queue_item.request.proxies:
                service.extend(BrowserHelper.__proxies_to_service_args(queue_item.request.proxies))

        driver_path = BrowserHelper.__get_phantomjs_driver()
        return webdriver.PhantomJS(
            executable_path=driver_path,
            desired_capabilities=capabilities,
            service_args=service
        )

    @staticmethod
    def __proxies_to_service_args(proxies):
        """Get the proxy details in a service args array.

        Args:
            proxies (obj): An `requests` proxies object.

        Returns:
            list: The service args containing proxy details

        Note:
            The `ignore-ssl-errors` argument is also added because
            all SSL checks are handled by Python's requests module.
            Python's requests module is also able to allow certain
            custom certificates (e.g. if a proxy is used).

        """

        service_args = []

        parsed = urlparse(list(proxies.values())[0])

        # Proxy type
        if parsed.scheme.startswith("http"):
            service_args.append("--proxy-type=http")
        else:
            service_args.append("--proxy-type=" + parsed.scheme)

        # Proxy
        host_and_port = parsed.netloc.split("@")[-1]
        service_args.append("--proxy=" + host_and_port)

        # Proxy auth
        if len(parsed.netloc.split("@")) == 2:
            user_pass = parsed.netloc.split("@")[0]
            service_args.append("--proxy-auth=" + user_pass)

        # Ignore SSL (please see note in this method).
        service_args.append("--ignore-ssl-errors=true")

        return service_args

    @staticmethod
    def __get_phantomjs_driver():
        """Get the path to the correct PhantomJS driver.

        Returns:
            str: The location of the driver.

        """

        if BrowserHelper.__phantomjs_driver:
            return BrowserHelper.__phantomjs_driver

        path = os.path.dirname(os.path.abspath(__file__))
        bits = ctypes.sizeof(ctypes.c_voidp)
        x = "32" if bits == 4 else "64"

        if sys.platform == "linux" or sys.platform == "linux2":
            file = path + "/../phantomjs/linux" + x + "-2.1.1"
        elif sys.platform == "darwin":
            file =  path + "/../phantomjs/mac-2.1.1"
        elif sys.platform == "win32":
            file =  path + "/../phantomjs/win-2.1.1.exe"

        st = os.stat(file)
        os.chmod(file, st.st_mode | stat.S_IEXEC)

        BrowserHelper.__phantomjs_driver = file
        return BrowserHelper.__phantomjs_driver


text:
package org.kuali.kra.committee.service;

import org.kuali.coeus.common.committee.impl.service.CommitteeScheduleAttendanceServiceBase;

public interface CommitteeScheduleAttendanceService extends CommitteeScheduleAttendanceServiceBase {

}


text:
//------------------------------------------------------------------------------
// <auto-generated>
//     Dieser Code wurde von einem Tool generiert.
//     Laufzeitversion:4.0.30319.18034
//
//     Änderungen an dieser Datei können falsches Verhalten verursachen und gehen verloren, wenn
//     der Code erneut generiert wird.
// </auto-generated>
//------------------------------------------------------------------------------

namespace PressureTool.Properties {

    [global::System.Runtime.CompilerServices.CompilerGeneratedAttribute()]
    [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.VisualStudio.Editors.SettingsDesigner.SettingsSingleFileGenerator", "11.0.0.0")]
    internal sealed partial class Settings : global::System.Configuration.ApplicationSettingsBase {

        private static Settings defaultInstance = ((Settings)(global::System.Configuration.ApplicationSettingsBase.Synchronized(new Settings())));

        public static Settings Default {
            get {
                return defaultInstance;
            }
        }

        [global::System.Configuration.UserScopedSettingAttribute()]
        [global::System.Diagnostics.DebuggerNonUserCodeAttribute()]
        [global::System.Configuration.DefaultSettingValueAttribute("")]
        public string ComPort {
            get {
                return ((string)(this["ComPort"]));
            }
            set {
                this["ComPort"] = value;
            }
        }

        [global::System.Configuration.UserScopedSettingAttribute()]
        [global::System.Diagnostics.DebuggerNonUserCodeAttribute()]
        [global::System.Configuration.DefaultSettingValueAttribute("9600")]
        public string BaudRate {
            get {
                return ((string)(this["BaudRate"]));
            }
            set {
                this["BaudRate"] = value;
            }
        }

        [global::System.Configuration.UserScopedSettingAttribute()]
        [global::System.Diagnostics.DebuggerNonUserCodeAttribute()]
        [global::System.Configuration.DefaultSettingValueAttribute("1")]
        public string LogSpeed {
            get {
                return ((string)(this["LogSpeed"]));
            }
            set {
                this["LogSpeed"] = value;
            }
        }

        [global::System.Configuration.UserScopedSettingAttribute()]
        [global::System.Diagnostics.DebuggerNonUserCodeAttribute()]
        [global::System.Configuration.DefaultSettingValueAttribute("1")]
        public string DisplaySpeed {
            get {
                return ((string)(this["DisplaySpeed"]));
            }
            set {
                this["DisplaySpeed"] = value;
            }
        }

        [global::System.Configuration.UserScopedSettingAttribute()]
        [global::System.Diagnostics.DebuggerNonUserCodeAttribute()]
        [global::System.Configuration.DefaultSettingValueAttribute("False")]
        public bool ConnectOnStart {
            get {
                return ((bool)(this["ConnectOnStart"]));
            }
            set {
                this["ConnectOnStart"] = value;
            }
        }

        [global::System.Configuration.UserScopedSettingAttribute()]
        [global::System.Diagnostics.DebuggerNonUserCodeAttribute()]
        [global::System.Configuration.DefaultSettingValueAttribute("10")]
        public string RefreshSpeed {
            get {
                return ((string)(this["RefreshSpeed"]));
            }
            set {
                this["RefreshSpeed"] = value;
            }
        }
    }
}


text:
'use strict';

import Base from './base';
import Constants from './constants';
import Immutable from 'immutable';

export default class Chord extends Base {
  constructor(fns) {
    super();
    this.__fns = Array.prototype.slice.call(fns);
    this.__doneFns = new Immutable.Set();
    this.__currentFn = -1;
    this.__changeEvent = 'chord-change';
  }

  __doStep(step) {
    this.__emit(Constants.StepStatus.STARTED, null, step);
    let stepNum = this.__currentFn;
    if (step instanceof Base) {
      step.on(Constants.States.FINISHED, () => {
        this.finishStep(step, stepNum);
      });
      step.on(Constants.States.FAILED, () => {
        let error = step.getState('error');
        if (error == null) {
          error = step.getState('errors', `step ${step.name} failed`);
        }
        this.finishStep(step, stepNum, error);
      });
      // Going to the next step is safer than calling start
      // because the Flow could have already started.
      step.gotoNextStep();
    }
    else {
      try {
        step(
          this,
          () => this.finishStep(step, stepNum),
          (e) => this.finishStep(step, stepNum, e)
        );
      }
      catch (e) {
        this.finishStep(step, stepNum, e);
      }
    }
    this.gotoNextStep();
  }

  __handleError(step, error) {
    let errors = this.getState('errors', new Immutable.List());
    errors = errors.push(error);
    this.setState({errors});
    this.failStep(step);
  }

  __gotoNextStep() {
    if (this.hasNextStep()) {
      this.__currentFn = this.__currentFn + 1;
    }
  }

  addStep(step) {
    this.__fns.push(step);
  }

  failStep(step) {
    this.__emit(Constants.StepStatus.FAILED, null, step);

    if (this.isFinished() && this.getState('errors').size === this.__fns.length) {
      this.__readyState = this.__readyState.add(
        Constants.States.FAILED
      );
      this.__emit(Constants.States.FAILED, Constants.States.FAILED, step);
    }
  }

  finishStep(step, stepNum, opt_error) {
    if (this.__fns[stepNum] !== step) {
      throw `Got incorrect step num '${stepNum}' for step`;
    }
    this.__doneFns = this.__doneFns.add(stepNum);

    if (opt_error != null) {
      this.__handleError(step, opt_error);
    }
    else {
      this.__emit(Constants.StepStatus.FINISHED, null, step);
    }

    let isFinished = this.__fns.every((_, i) => {
      return this.__doneFns.has(i);
    });

    if (isFinished) {
      this.finish();
    }
  }

  getCurrentFn() {
    if (this.__currentFn > -1 && this.__currentFn < this.__fns.length) {
      return this.__fns[this.__currentFn];
    }
    return null;
  }

  gotoNextStep() {
    if (!this.isStarted()) {
      this.start();
      return;
    }

    if(this.hasNextStep()) {
      this.__gotoNextStep();
      // The naming here really sucks.
      // With a Chord there is no concept of a "current function" because
      // functions could be async. This needs a better name.
      let step = this.getCurrentFn();
      this.__doStep(step);
    }
  }

  hasNextStep() {
    return (!this.isFinished() &&
            !this.isLastStep() &&
            this.__currentFn < this.__fns.length);
  }

  isFinished() {
    let isFinished = this.__fns.every((_, i) => {
      return this.__doneFns.has(i);
    });
    return isFinished;
  }

  isLastStep() {
    return this.__currentFn === this.__fns.length -1;
  }
}


text:
require("#{__dir__}/../lib/avalon/build_utils.rb")
utils = Avalon::BuildUtils.new
version = utils.detect_version
puts version


text:
    <java-class-file name="D:\Experiments\Analisi di Sopravvivenza\Progetto16715\ProgettiDaAnalizzare\jhotdraw\JHotDraw 7.4.1\JHotDraw 7.4.1\Source\jhotdraw7\src\main\java\org\jhotdraw\xml\NanoXMLDOMOutput.java">
        <package-decl name="org.jhotdraw.xml"/>
        <class name="NanoXMLDOMOutput" visibility="public">
            <constructor visibility="public" name="NanoXMLDOMOutput">
            </constructor>
            <method name="save" visibility="public">
            </method>
            <method name="save" visibility="public">
            </method>
            <method name="print" visibility="public">
            </method>
            <method name="openElement" visibility="public">
            </method>
            <method name="closeElement" visibility="public">
            </method>
            <method name="addComment" visibility="public">
            </method>
            <method name="addText" visibility="public">
            </method>
            <method name="addAttribute" visibility="public">
            </method>
            <method name="addAttribute" visibility="public">
            </method>
            <method name="addAttribute" visibility="public">
            </method>
            <method name="addAttribute" visibility="public">
            </method>
            <method name="addAttribute" visibility="public">
            </method>
            <method name="writeObject" visibility="public">
            </method>
            <method name="writeStorable" visibility="private">
            </method>
            <method name="addAttribute" visibility="public">
            </method>
            <method name="addAttribute" visibility="public">
            </method>
            <method name="addAttribute" visibility="public">
            </method>
            <method name="addAttribute" visibility="public">
            </method>
            <method name="addAttribute" visibility="public">
            </method>
            <method name="getPrototype" visibility="public">
            </method>
            <method name="setDoctype" visibility="public">
            </method>
            <method name="dispose" visibility="public">
            </method>
        </class>
    </java-class-file>


text:
from varcode.effects.effect_prediction_coding_frameshift import (
    cdna_codon_sequence_after_insertion_frameshift,
    cdna_codon_sequence_after_deletion_or_substitution_frameshift,
)

from nose.tools import eq_

def test_cdna_codon_sequence_after_insertion_frameshift_before_codon():
    # insertion: T_ATGCCCTAG
    i, s = cdna_codon_sequence_after_insertion_frameshift(
        sequence_from_start_codon="ATGCCCTAG",
        cds_offset_before_insertion=-1,
        inserted_nucleotides="T")
    eq_(i, 0)
    eq_(s, "TATGCCCTAG")

def test_cdna_codon_sequence_after_insertion_frameshift_in_middle_of_codon():
    # insertion: A_T_TGCCCTAG
    i, s = cdna_codon_sequence_after_insertion_frameshift(
        sequence_from_start_codon="ATGCCCTAG",
        cds_offset_before_insertion=0,
        inserted_nucleotides="T")
    eq_(i, 0)
    eq_(s, "ATTGCCCTAG")

def test_cdna_codon_sequence_after_insertion_frameshift_at_end_of_codon():
    # insertion: AT_T_GCCCTAG
    i, s = cdna_codon_sequence_after_insertion_frameshift(
        sequence_from_start_codon="ATGCCCTAG",
        cds_offset_before_insertion=1,
        inserted_nucleotides="T")
    eq_(i, 0)
    eq_(s, "ATTGCCCTAG")

def test_cdna_codon_sequence_after_insertion_frameshift_after_codon():
    # insertion: ATG_T_CCCTAG
    i, s = cdna_codon_sequence_after_insertion_frameshift(
        sequence_from_start_codon="ATGCCCTAG",
        cds_offset_before_insertion=2,
        inserted_nucleotides="T")
    eq_(i, 1)
    eq_(s, "TCCCTAG")

def test_cdna_codon_sequence_after_deletion_or_substitution_frameshift_delA():
    i, s = cdna_codon_sequence_after_deletion_or_substitution_frameshift(
        sequence_from_start_codon="ATGCCCTAG",
        cds_offset=0,
        trimmed_cdna_ref="A",
        trimmed_cdna_alt="")
    eq_(i, 0)
    eq_(s, "TGCCCTAG")

def test_cdna_codon_sequence_after_deletion_or_substitution_frameshift_AT_to_C():
    i, s = cdna_codon_sequence_after_deletion_or_substitution_frameshift(
        sequence_from_start_codon="ATGCCCTAG",
        cds_offset=0,
        trimmed_cdna_ref="AT",
        trimmed_cdna_alt="C")
    eq_(i, 0)
    eq_(s, "CGCCCTAG")


text:
<?xml version='1.0' encoding='UTF-8'?>
<scriptApproval plugin="script-security@1.25">
  <approvedScriptHashes/>
  <approvedSignatures>
	<string>staticMethod org.codehaus.groovy.runtime.DefaultGroovyMethods toURL java.lang.String</string>
    <string>staticMethod org.codehaus.groovy.runtime.DefaultGroovyMethods getText java.net.URL</string>
  </approvedSignatures>
  <aclApprovedSignatures/>
  <approvedClasspathEntries/>
  <pendingScripts/>
  <pendingSignatures/>
  <pendingClasspathEntries/>
</scriptApproval>


text:
class AgregarCamposAResultados < ActiveRecord::Migration
  def change
  	add_column :resultado_tratamientos, :atendido, :boolean, default: false
  	add_column :resultado_tratamientos, :razon_editado, :string
   	add_reference :resultado_tratamientos,:asignar_horario,  index: true
  end
end


text:
package autodispose2.sample;

public interface CustomScope {}


text:
using Microsoft.VisualStudio.TestTools.UnitTesting;
namespace BinaryTrees
{
    using System.Numerics;
    using Microsoft.VisualStudio.TestTools.UnitTesting;

    [Microsoft.VisualStudio.TestTools.UnitTesting.TestClass]
    public class test
    {
        // TREES()

        [TestMethod]
        public void Trees()
        {
            Program.memo = new BigInteger[4];
            var res = Program.Trees(2);

            Assert.AreEqual(2, res);
        }

        [TestMethod]
        public void Trees2()
        {
            Program.memo = new BigInteger[4];
            var res = Program.Trees(3);

            Assert.AreEqual(5, res);
        }

        [TestMethod]
        public void Trees3()
        {
            Program.memo = new BigInteger[5];
            var res = Program.Trees(4);

            Assert.AreEqual(15, res);
        }
    }
}


text:
<?php
defined('BASEPATH') OR exit('No direct script access allowed');

class Editar_proyecto_ctrl extends CI_Controller {
	public function __construct(){
		parent::__construct();
		$this->load->model('Proyecto');
		$this->load->model('Cliente');
	}

	public function index(){
		$data = $this->cargaInicial();
		$data['menu'] = $this->load->view('Menu_principal', null, true);
		$this->load->view('Editar_proyecto_vw', $data);
	}

	public function cargaInicial(){
		$result['clientes'] = $this->Cliente->traerTodo();
		$result['proyectos'] = $this->Proyecto->traerAsociados_cliente(1);

		return $result;
	}

	public function actualizarProyecto($id, $data){
		foreach($data as $key => $value)
			$data[$key] = htmlentities($value, ENT_QUOTES, 'UTF-8');

		if($this->Proyecto->actualizar($data))
			echo "Proyecto actualizado correctamente.";
		else
			echo "Ha ocurrido un error al intentar actualizar el proyecto. Intente de nuevo, por favor.";
	}
}

?>


text:
tones
=====

The Web Audio API is pretty amazing. You can actually synthesize audio with JavaScript right in the browser. The only problem is that it's pretty low level and not exactly intuitive to work with. This library is meant to make it as simple as humanly possible to create pleasant sounding musical tones.

See a few demos of tones in action here:

http://bit101.github.io/tones/

The tones api is drop dead simple. One main method: `play`.

The play method can be used in a few different ways:

1. Play a tone at a specific frequency.
2. Play a named note in the default 4th octave.
3. Play a named note in a specific octave.

Examples:

	tones.play(440);		// plays a 440 hz tone
	tones.play("c");		// plays a C note in the 4th octave.
	tones.play("c#");		// plays a C sharp note in the 4th octave.
	tones.play("eb");		// plays an E flat note in the 4th octave.
	tones.play("c", 2);		// plays a C note in the 2nd octave.

Named notes are case insensitive. "c" is the same as "C".

There are also a few properties that affect the sound of the tone played. Set these before playing a tone and they will affect all future tones played.

	type		// this is the wave form, a string of one of the following: "sine", "square", "sawtooth" or "triangle"
	attack 		// sets the attack of the envelope, or the time that the sound takes to reach full volume.
	release		// sets the release of the envelope, or the time it takes for the sound to fade out.

Attack and release are numbers which should generally be in the range of around 1 to 300. A low release, and mid-range release will give a bell sound. A long attack and release will sound more like a flute. Combined with different wave form types, this allows you to create all kinds of unique sounds.

Note that attack and release values do not represent discrete times. But roughly speaking your sound will last about 10 times the total of these two in milliseconds. For example, an attack of 100 and release of 200 totals 300, so the tone will last around 3000 milliseconds or 3 seconds before completely fading out.

There is also a `getTimeMS` function. This returns the current time reported by the audio context, which keeps a very accurate internal timer. Some of the examples use this to set up a sort of sequencer.

There's a whole lot more that could be done to this, and I'll probably add features to this, while trying to make sure that the core functionality remains as simple as possible.

It goes without saying that this library will only work in browsers that support the Web Audio API, which includes Chrome, Firefox and Safari (I think), but not Internet Explorer.


text:
import {Injectable} from '@angular/core';
import {AlertController} from 'ionic-angular';
import {TranslateService} from '@ngx-translate/core';

@Injectable()
export class AlertProvider {

    constructor(private alertCtrl: AlertController, private translate: TranslateService) {

    }

    showWalletNotSelectedAlert() {
        this.translate
            .get(['ALERT_NOT_WALLET_SELECTED', 'OK'], {})
            .subscribe((res) => {
                let alert = this.alertCtrl.create({
                    title: res['ALERT_NOT_WALLET_SELECTED'],
                    buttons: [res['OK']]
                });
                alert.present();
        }), err => console.log(err);
    }

    showInvalidPasswordAlert() {
        this.translate.
        get(['ALERT_PROVIDED_PASSWORD_INVALID', 'OK'], {})
            .subscribe((res) => {
                let alert = this.alertCtrl.create({
                    title: res['ALERT_PROVIDED_PASSWORD_INVALID'],
                    buttons: [res['OK']]
                });

                alert.present();
        }), err => console.log(err);
    }

    showPasswordDoNotMatch() {
        this.translate
            .get(['ALERT_PASSWORDS_DO_NOT_MATCH', 'OK'], {})
            .subscribe((res) => {
                let alert = this.alertCtrl.create({
                    title: res['ALERT_PASSWORDS_DO_NOT_MATCH'],
                    buttons: [res['OK']]
                });

                alert.present();
            }), err => console.log(err);
    }

    showWalletNameAlreadyExists() {
        this.translate
            .get(['ALERT_WALLET_NAME_ALREADY_EXISTS', 'OK'], {})
            .subscribe((res) => {
                let alert = this.alertCtrl.create({
                    title: res['ALERT_WALLET_NAME_ALREADY_EXISTS'],
                    buttons: [res['OK']]
                });

                alert.present();
            }), err => console.log(err);
    }

    showAlertDoesNotBelongToNetwork() {
        this.translate
            .get(['ALERT_WALLET_IS_NOT_VALID_FOR_THIS_NETWORK', 'OK'], {})
            .subscribe((res) => {
                let alert = this.alertCtrl.create({
                    title: res['ALERT_WALLET_IS_NOT_VALID_FOR_THIS_NETWORK'],
                    buttons: [res['OK']]
                });

                alert.present();
            }), err => console.log(err);
    }

    showDoesNotHaveEnoughFunds() {
        this.translate
            .get(['ALERT_ACCOUNT_DOES_NOT_HAVE_ENOUGH_FUNDS', 'OK'], {})
            .subscribe((res) => {
                let alert = this.alertCtrl.create({
                    title: res['ALERT_ACCOUNT_DOES_NOT_HAVE_ENOUGH_FUNDS'],
                    buttons: [res['OK']]
                });
                alert.present();
            }), err => console.log(err);
    }

    showMessageTooLarge() {
        this.translate
            .get(['ALERT_SHOW_ATTACHED_MESSAGE_IS_TOO_LARGE', 'OK'], {})
            .subscribe((res) => {
                let alert = this.alertCtrl.create({
                    title: res['ALERT_SHOW_ATTACHED_MESSAGE_IS_TOO_LARGE'],
                    buttons: [res['OK']]
                });

                alert.present();
            }), err => console.log(err);
    }

    showMosaicNotTransferable() {
        this.translate
            .get(['ALERT_MOSAIC_IS_NOT_TRANSFERABLE', 'OK'], {})
            .subscribe((res) => {
                let alert = this.alertCtrl.create({
                    title: res['ALERT_MOSAIC_IS_NOT_TRANSFERABLE'],
                    buttons: [res['OK']]
                });

                alert.present();
            }), err => console.log(err);
    }

    showInvalidPrivateKey() {
        this.translate
            .get(['ALERT_INVALID_PRIVATE_KEY', 'OK'], {})
            .subscribe((res) => {
                let alert = this.alertCtrl.create({
                    title: res['ALERT_INVALID_PRIVATE_KEY'],
                    buttons: [res['OK']]
                });

                alert.present();
            }), err => console.log(err);
    }

    showWeakPassword() {
        this.translate
            .get(['ALERT_WEAK_PASSWORD', 'OK'], {})
            .subscribe((res) => {
                let alert = this.alertCtrl.create({
                    title: res['ALERT_WEAK_PASSWORD'],
                    buttons: [res['OK']]
                });

                alert.present();
            }), err => console.log(err);
    }

     showFunctionalityOnlyAvailableInMobileDevices() {
        this.translate
            .get(['ALERT_ONLY_MOBILE_DEVICE', 'OK'], {})
            .subscribe((res) => {
                let alert = this.alertCtrl.create({
                    title: res['ALERT_ONLY_MOBILE_DEVICE'],
                    buttons: [res['OK']]
                });

                alert.present();
            }), err => console.log(err);
    }

    showContactAlreadyExists() {
        this.translate
            .get(['ALERT_CONTACT_ALREADY_EXISTS', 'OK'], {})
            .subscribe((res) => {
                let alert = this.alertCtrl.create({
                    title: res['ALERT_CONTACT_ALREADY_EXISTS'],
                    buttons: [res['OK']]
                });

                alert.present();
            }), err => console.log(err);
    }

    showOnPhoneDisconnected() {
        this.translate
            .get(['ALERT_PHONE_DISCONNECTED', 'ALERT_SUBTITLE_PHONE_DISCONNECTED', 'OK'], {})
            .subscribe((res) => {
                let alert = this.alertCtrl.create({
                    title: res['ALERT_PHONE_DISCONNECTED'],
                    subTitle: res['ALERT_SUBTITLE_PHONE_DISCONNECTED'],
                    buttons: [res['OK']]
                });
                alert.present();
            }), err => console.log(err);
    }

    showError(error) {
        this.translate
            .get('OK', {})
            .subscribe((res) => {
                let alert = this.alertCtrl.create({
                    title: error,
                    buttons: [res]
                });
                alert.present();
            }), err => console.log(err);
    }
}


text:
// This file is automatically generated.

package adila.db;

/*
 * Oppo N3
 *
 * DEVICE: N3
 * MODEL: N5207
 */
final class n3_n5207 {
    public static final String DATA = "Oppo|N3|";
}


text:
package com.mix.activity;

import com.example.mixtest.R;

import android.app.Activity;
import android.content.Context;
import android.content.Intent;
import android.graphics.Bitmap;
import android.os.Bundle;
import android.widget.ImageView;
import android.widget.TextView;

public class DiaryContentActivity extends Activity{

	private TextView titleTextView;
	private ImageView pictureImageView;
	private TextView contentTextView;

	public static void actionStart(Context context,String title,String content,Bitmap picture){
		Intent intent = new Intent(context,DiaryContentActivity.class);
		intent.putExtra("diary_title", title);
		intent.putExtra("diary_content", content);
		intent.putExtra("diary_picture", picture);
		context.startActivity(intent);
	}

	@Override
	protected void onCreate(Bundle savedInstanceState) {
		super.onCreate(savedInstanceState);
		setContentView(R.layout.diary_content);
		titleTextView = (TextView) findViewById(R.id.id_content_title);
		pictureImageView = (ImageView) findViewById(R.id.id_content_picture);
		contentTextView = (TextView) findViewById(R.id.id_content_content);
		titleTextView.setText(getIntent().getStringExtra("diary_title"));
		pictureImageView.setImageBitmap((Bitmap) getIntent().getParcelableExtra("diary_picture"));
		contentTextView.setText(getIntent().getStringExtra("diary_content"));
	}
}


text:
package softuniGallery.entity;

import javax.persistence.*;
import java.util.HashSet;
import java.util.Set;

@Entity
@Table(name = "links")
public class Link {

    private Integer id;

    private String link;

    private String title;

    private User author;

    private LinkCategory linkCategory;

    private Set<LinkTag> linkTags;

    @Transient
    private String linkSummary;

    public Link(String link, String title, User author, LinkCategory linkCategory, HashSet<LinkTag> linkTags) {
        this.link = link;
        this.title = title;
        this.author = author;
        this.linkCategory = linkCategory;
        this.linkTags = linkTags;
    }

    public Link() {

    }

    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    public Integer getId() {
        return this.id;
    }

    public void setId(Integer id) {
        this.id = id;
    }

    @Column(columnDefinition = "text", nullable = false)
    public String getLink() {
        return this.link;
    }

    public void setLink(String link) {
        this.link = link;
    }

    @Column(nullable = false)
    public String getTitle() {
        return this.title;
    }

    public void setTitle(String title) {
        this.title = title;
    }

    @ManyToOne()
    @JoinColumn(nullable = false, name = "authorId")
    public User getAuthor() {
        return this.author;
    }

    public void setAuthor(User author) {
        this.author = author;
    }

    @ManyToOne()
    @JoinColumn(nullable = false, name = "categoryId")
    public LinkCategory getLinkCategory() {
        return this.linkCategory;
    }

    public void setLinkCategory(LinkCategory linkCategory) {
        this.linkCategory = linkCategory;
    }

    @ManyToMany()
    @JoinColumn(table = "links_tags")
    public Set<LinkTag> getLinkTags() {
        return this.linkTags;
    }

    public void setLinkTags(Set<LinkTag> linkTags) {
        this.linkTags = linkTags;
    }

    @Transient
    public String getLinkSummary() {
        return this.linkSummary;
    }

    public void setLinkSummary(String linkSummary) {

        this.linkSummary = linkSummary;
    }
}


text:
#ifndef CSETRELATION_H_
#define CSETRELATION_H_

#include <string>
using std::string;

#include "Matrix.h"
#include "Module.h"
#include "Lattice.h"
#include "Flat.h"

#include "Hadron.h"
#include "Descriptor.h"

namespace AlgoTrans {
	template <class Y> class CSetRelation;
	template <class Y> CSetRelation<Y> operator + (CSetRelation<Y> a, CSetRelation<Y> b);
	template <class Y> CSetRelation<Y> operator * (CSetRelation<Y> a, CSetRelation<Y> b);

	/* A relation
	 * between a pair of sets P and Q of type Y
	 * specified by a subset of P x Q of type Y
	 */
	// XXX: May want to prefer to encapsulate Y instead of inheriting from it (or maybe not)
	template <class Y> class CSetRelation: public Y {
		template <class Z> friend bool isRelationSignatureCompatible(CSetRelation<Z>& a, CSetRelation<Z>& b);
		template <class Z> friend bool operator == (CSetRelation<Z> a, CSetRelation<Z> b);
		template <class Z> friend CSetRelation<Z> meet(const CSetRelation<Z>& a, const CSetRelation<Z>& b); // Meet
		template <class Z> friend CSetRelation<Z> join(const CSetRelation<Z>& a, const CSetRelation<Z>& b); // Join
	private:
		int pDim, qDim;
	protected:
	public:
		// SuperSpace dim is not adjusted by these methods!
		//void setPDimension(int newPDimension) { pDim = newPDimension; }
		//void setQDimension(int newQDimension) { qDim = newQDimension; }

		void copyRelationSignature(const CSetRelation<Y>& other);
		void copyCompatibleRelationSignature(CSetRelation<Y>& a, CSetRelation<Y>& b);

		//CSetRelation() { };
		CSetRelation(int iPDim, int iQDim, const Y& iSet) : Y(iSet), pDim(iPDim), qDim(iQDim) { };
		CSetRelation(const CSetRelation<Y>& other);

		/*template <class R>
		static CSetRelation<Y> fromConstraints(int iPDim, int iQDim, int iConstDim, const CMatrix<R>& constraintMatrix);
		template <class R>
		static CSetRelation<Y> fromGenerators(int iPDim, int iQDim, int iConstDim, const CMatrix<R>& generatorMatrix);
		*/

		virtual ~CSetRelation() { };

		int getPDimension() const { return pDim; }
		int getQDimension() const { return qDim; }

		CSetRelation& operator = (const CSetRelation& other);

		string toString(bool forceBothDescriptions = false);
		string toStringHtml(bool forceBothDescriptions = false);
		void print(bool forceBothDescriptions = false);

		template <class Z>
		Z getReflexiveTransitiveClosure();

		class ConjunctiveOperations {
		public:
			static CSetRelation calcTransition(CSetRelation& a, CSetRelation& b) { return transitionOperation(a, b); }
			static CSetRelation calcCombination(CSetRelation& a, CSetRelation& b) { return a * b; }
		};

		class DisjunctiveHullOperations {
		public:
			static CSetRelation calcTransition(CSetRelation& a, CSetRelation& b) { return transitionOperation(a, b); }
			static CSetRelation calcCombination(CSetRelation& a, CSetRelation& b) { return a + b; }
		};
	};

	template <class R> struct CLatticeRelation {
		typedef CSetRelation<CFlat<CLattice<R> > > T;
	};

	template <class R> struct CModuleRelation {
		typedef CSetRelation<CFlat<CModule<R> > > T;
	};

	template <class Y> CSetRelation<Y> operator + (CSetRelation<Y> a, CSetRelation<Y> b) {
		ASSERT(isRelationSignatureCompatible(a, b));

		return CSetRelation<Y>(a.getPDimension(), a.getQDimension(), ((Y) a) + ((Y) b));
	}

	template <class Y> CSetRelation<Y> operator * (CSetRelation<Y> a, CSetRelation<Y> b) {
		ASSERT(isRelationSignatureCompatible(a, b));

		return CSetRelation<Y>(a.getPDimension(), a.getQDimension(), ((Y) a) * ((Y) b));
	}

}

#include "SetRelation.cpp"
#include "Transitions.cpp"

#endif /* SETRELATION_H_ */


text:
require 'rib/test'
require 'rib/shell'

describe Rib::API do
  paste :rib

  Rib::API.instance_methods.delete_if{ |e| e[/=$/] }.each do |meth|
    would "##{meth} be accessible to plugins" do
      mod = Module.new do
        define_method meth do
          "pong_#{meth}"
        end
      end
      klass = Rib::Shell.dup
      klass.use(mod)

      expect(klass.new.send(meth)).eq "pong_#{meth}"
    end
  end

  would 'emit a warning whenever result is not a string' do
    object = Class.new{ alias_method :inspect, :object_id }.new

    mock(shell).get_input{'object'}
    mock(shell).loop_eval('object'){object}
    mock(shell).puts("=> #{object.object_id}"){}
    mock($stderr).puts(including("#{object.class}#inspect")){}

    shell.loop_once

    ok
  end

  describe '#warn' do
    would 'append a warning message to warnings' do
      shell.warn('test')

      expect(shell.warnings).eq ['test']
    end
  end

  describe '#flush_warnings' do
    before do
      shell.warn('test')

      mock($stderr).puts('rib: test'){}
    end

    would 'warn to $stderr from #warnings' do
      shell.send(:flush_warnings)

      ok
    end
  end
end


text:
/* ###
 * IP: GHIDRA
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
// Reports the percentage of bytes in any executable section that were disassembled into instructions,
// or turned into defined data.
// This can be an "indicator" of how well the initial analysis was at finding all code.
//
// Assumes a program is open.
//
//@category Examples

import ghidra.app.script.GhidraScript;
import ghidra.program.model.address.AddressSetView;
import ghidra.program.model.listing.*;
import ghidra.util.Msg;

public class ReportPercentDisassembled extends GhidraScript {

	@Override
	public void run() throws Exception {

		// find all the sections of memory marked as executable
		Program prog = currentProgram;
		AddressSetView execMemSet = prog.getMemory().getExecuteSet();
		/*int myExecSetLen = 0;
		MemoryBlock[] blocks = prog.getMemory().getBlocks();
		for (int i = 0; i < blocks.length; i++) {
			if (blocks[i].isExecute()) {
				myExecSetLen += blocks[i].getSize();
			}
		}*/

		// tally up all the bytes that have been marked as instructions
		//   (probably faster ways to do this, but it works)
		long numPossibleDis = execMemSet.getNumAddresses();
		InstructionIterator instIter = prog.getListing().getInstructions(execMemSet, true);
		int instCount = 0;
		while (instIter.hasNext()) {
			Instruction inst = instIter.next();
			instCount += inst.getLength();
		}
		DataIterator dataIter = prog.getListing().getData(execMemSet, true);
		int dataCount = 0;
		while (dataIter.hasNext()) {
			Data data = dataIter.next();
			if (data.isDefined()) {
				dataCount += data.getLength();
			}
		}

		// dump the info
		int total = instCount + dataCount;
		if (numPossibleDis != 0) {
			float coverage = (float) total / (float) numPossibleDis;
//	    	Msg.info(this,"execSetLen = " + numPossibleDis);
//	    	Msg.info(this,"MyExecSetLen = " + myExecSetLen);
//	    	Msg.info(this,"NumInsts = " + instCount);
//	    	Msg.info(this,"numData = " + dataCount);
//
//	    	Msg.info(this,"totalDis = " + total);
			float percentage = coverage * 100;
			Msg.info(this, "REPORT DISASSEMBLY EXTENT: " + prog.getName() + ": " + percentage +
				"% disassembled.");
		}
		return;

	}

}


text:
package thedemitrius.androidif.glk;

import java.io.IOException;

abstract class Stream implements GLKConstants
{
	private int id;
	private int rock;

	private Stream echoSource;

	protected int readCount,writeCount;

	Stream (int id,int rock)
	{
		this.id=id;
		this.rock=rock;

		echoSource=null;

		readCount=0;
		writeCount=0;
	}

	int getID()
	{
		return (id);
	}

	abstract void putString(byte[] s,int startPos) throws IOException;

	abstract void putChar(byte ch) throws IOException;

	int getReadCount()
	{
		return (readCount);
	}

	int getWriteCount()
	{
		return (writeCount);
	}

	abstract int getChar();

	Stream getEchoSource()
	{
		return (echoSource);
	}

	void setEchoSource(Stream echoSource)
	{
		this.echoSource=echoSource;
	}

	int getRock()
	{
		return (rock);
	}

	abstract void putBuffer(byte[] s,int startPos,int len) throws IOException;

	abstract int getPosition() throws IOException;

	abstract void setPosition(int offset,int seekMode) throws IOException;

	abstract int getBuffer(byte[] buf,int startPos,int len) throws IOException;

	abstract void putCharUni(int ch) throws IOException;

	void setHyperlink(int linkVal)
	{}
}


text:
package org.catechis;

import java.util.ResourceBundle;
import java.util.Locale;
import java.io.File;
import java.io.Reader;
import java.io.FileInputStream;
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.io.IOException;
import java.io.UnsupportedEncodingException;

// debugging
// import javax.servlet.ServletContext;
import java.lang.StringBuffer;

public class EncodeString
{
	private static String original;
	private static byte[] utf8Bytes;
	private static String tempString;
	private static Reader in;

	public EncodeString()
	{}

	public Reader encodeReader(File file)
	{
		try
		{
			FileInputStream fis = new FileInputStream(file);
			InputStreamReader isr = new InputStreamReader(fis, "euc-kr");
			in = new BufferedReader(isr);
		} catch (java.io.FileNotFoundException fnfe)
		{
			// this prints during FileUserOptionsTest.testGetJSPOptionsFail,
			// which fails on purpose, but we don't want to see a message in the prompt output...
			//System.err.println("EncodeString.encodeReader:fnf "+file.getAbsolutePath());
			//fnfe.printStackTrace();
		}catch (IOException e)
		{
			e.printStackTrace();
		}
		return in;
	}

	public Reader encodeReader(File file, String encoding)
	{
		try
		{
			FileInputStream fis = new FileInputStream(file);
			InputStreamReader isr = new InputStreamReader(fis, encoding);
			in = new BufferedReader(isr);
		} catch (java.io.FileNotFoundException fnfe)
		{
			// this prints during FileUserOptionsTest.testGetJSPOptionsFail,
			// which fails on purpose, but we dont want to see a message in the prompt output...
			//System.err.println("EncodeString.encodeReader:fnf "+file.getAbsolutePath());
			//fnfe.printStackTrace();
		}catch (IOException e)
		{
			e.printStackTrace();
		}
		return in;
	}

	/**

This method takes a string from the ResourceBundle to encode.

The errors, if any, are returned in the are returned in the String.

There are definitely better ways to do that, such as exceptions, etc.
	*/
	public static String encodeThis(String value, ResourceBundle messages)
	{
		try
		{
			original = messages.getString(value);
			utf8Bytes = original.getBytes("UTF8");
			tempString = new String(utf8Bytes, "UTF8");
			return tempString;
		} catch (UnsupportedEncodingException e)
		{
			e.printStackTrace();
			return "Unencoded";
		} catch (java.lang.NullPointerException n)
		{
			n.printStackTrace();
			return "Null";
		}
	}

	/**

This method will encode any string using a preset encoding.
	*/
	public static String encodeThis(String value)
	{
		try
		{
			original = value;
			utf8Bytes = original.getBytes("UTF8");
			tempString = new String(utf8Bytes, "UTF8");
			return tempString;
		} catch (UnsupportedEncodingException e)
		{
			e.printStackTrace();
			return "Unencoded";
		} catch (java.lang.NullPointerException n)
		{
			n.printStackTrace();
			return "Null";
		}
	}

	/**

This method will encode any string using a passed in encoding.
	*/
	public static String encodeThis(String value, String encoding)
	{
		try
		{
			original = value;
			utf8Bytes = original.getBytes("ISO-8859-1");
			tempString = new String(utf8Bytes, encoding);
			return tempString;
		} catch (UnsupportedEncodingException e)
		{
			e.printStackTrace();
			return "Unencoded";
		} catch (java.lang.NullPointerException n)
		{
			n.printStackTrace();
			return "Null";
		}
	}

	public Locale getKoreanLocale()
	{
		String language = new String("ko");
		String country = new String("KR");
		Locale current_locale = new Locale(language, country);
		return current_locale;
	}

	/**

This method came from the com.businessglue.excogit.Swing class.

It requires the org.xml.sax.InputSource class, which we don't
	use in this app, so this is just a reference to show us something that worked
	for us before.  In the header comments of the that class, the author wrote
	the following:

 Encoding a document in MS word with the Korean(EUC) format
	and then using the InputStreamReader(fis, "ms949") encoding works!
	However, Xerces only accepts the
	<?xml version="1.0" encoding="euc-kr"?> header, not ms949
	I guess nobody told me i18n was easy.  That's ok, because it's worthwhile.

The method signature is set to void for now, but to be useful, it should
	return the encoding, or file create, depending on what is needed.
	*/
	public void getFileEncoding(String file_name)
	{
		/*
		 try
		 {
			 FileInputStream fis = new FileInputStream(file_name);
			 InputStreamReader isr = new InputStreamReader(fis, "ms949");
		   	 Reader in = new BufferedReader(isr);
		   	 is =  new InputSource(in);
		   	 enc = is.getEncoding();
		   	 System.out.println("Encoding - " + enc);
			 int ch;
			 while ((ch = in.read()) > -1)
			 {
				 buffer.append((char)ch);
			 }
			 in.close();
		  } catch (IOException e)
		  {
			  e.printStackTrace();
		  }
		  */
	}

}


text:
<?php

class UserTest extends CDbTestCase
{
	public $fixtures=array(
		'users'=>'User',
	);

	public function testCreate()
	{

	}

	public function testDeleteSoft()
	{
		$countBeforeDelete = count(User::model()->findAllActive());
		User::model()->find()->softDelete();
		$countAfterDelete = count(User::model()->findAllActive());
		$this->assertEquals($countBeforeDelete -1, $countAfterDelete);
	}
}


text:
"""Module level wrapper for Goldmine."""
import goldmine


text:
<?php

require_once("BiotrackingAbstractController.php");
include_once("abstract/Biotracking.php");
include_once("custom/MyPatient.php");

class PatientController extends BiotrackingAbstractController
{

    public function actionGetListOfVisit($patientID)
    {
        try
        {
            if (!isset($patientID) || empty($patientID))
                throw new Exception("patient ID cannot be null");

            $patient=new MyPatient();
            echo CJSON::encode($patient->getVisit($patientID));
        }
        catch (Exception $e)
        {

        }
    }

    public function actionGetSampleType($patientID,$visitID)
    {
        try
        {
            if (empty($patientID) || empty($visitID))
                throw new Exception("patient ID OR visit ID cannot be empty");

            $patient=new MyPatient();
            echo CJSON::encode($patient->getSampleByVisit($patientID,$visitID));
        }
        catch (Exception $e)
        {

        }
    }

    public function actionGetListOfPatient()
    {
        $patient=new MyPatient();
        $patientJSON= $patient->getAllPatient($this->_studyID,$this->_userID);
        echo CJSON::encode($patientJSON);
    }
}


text:
.class Lcom/android/systemui/statusbar/policy/KeyguardUserSwitcher$3;
.super Landroid/animation/AnimatorListenerAdapter;
.source "KeyguardUserSwitcher.java"

# annotations
.annotation system Ldalvik/annotation/EnclosingMethod;
    value = Lcom/android/systemui/statusbar/policy/KeyguardUserSwitcher;->startAppearAnimation()V
.end annotation

.annotation system Ldalvik/annotation/InnerClass;
    accessFlags = 0x0
    name = null
.end annotation

# instance fields
.field final synthetic this$0:Lcom/android/systemui/statusbar/policy/KeyguardUserSwitcher;

# direct methods
.method constructor <init>(Lcom/android/systemui/statusbar/policy/KeyguardUserSwitcher;)V
    .locals 0

    iput-object p1, p0, Lcom/android/systemui/statusbar/policy/KeyguardUserSwitcher$3;->this$0:Lcom/android/systemui/statusbar/policy/KeyguardUserSwitcher;

    invoke-direct {p0}, Landroid/animation/AnimatorListenerAdapter;-><init>()V

    return-void
.end method

# virtual methods
.method public onAnimationEnd(Landroid/animation/Animator;)V
    .locals 2

    iget-object v0, p0, Lcom/android/systemui/statusbar/policy/KeyguardUserSwitcher$3;->this$0:Lcom/android/systemui/statusbar/policy/KeyguardUserSwitcher;

    const/4 v1, 0x0

    invoke-static {v0, v1}, Lcom/android/systemui/statusbar/policy/KeyguardUserSwitcher;->-set1(Lcom/android/systemui/statusbar/policy/KeyguardUserSwitcher;Landroid/animation/ObjectAnimator;)Landroid/animation/ObjectAnimator;

    iget-object v0, p0, Lcom/android/systemui/statusbar/policy/KeyguardUserSwitcher$3;->this$0:Lcom/android/systemui/statusbar/policy/KeyguardUserSwitcher;

    const/4 v1, 0x0

    invoke-static {v0, v1}, Lcom/android/systemui/statusbar/policy/KeyguardUserSwitcher;->-set0(Lcom/android/systemui/statusbar/policy/KeyguardUserSwitcher;Z)Z

    return-void
.end method


text:
* Fix query string issue in Client
* Fix Time Reports API for Freelancer

## 1.3.3
* Send Message to a Batch of Rooms API

## 1.3.2
* Add Room Messages API

## 1.3.1
* Add Specialties API
* Add Skills V2 API

## 1.3.0
* Stop supporting deprecated Teamrooms API
* Migrate Workdiaries, Workdays and Snapshots API to v3

## 1.2.1
* Applications API has moved from v3 to v4

## 1.2.0
* Added Messages API (new)
* Message API (V1) is now fully depricated

## 1.1.1
* Add optional parameter to support pagination in GetTrayByType

## 1.1.0
* Get Categories (V1) is now fully depricated
* Added new Activities API - Assign to specific engagement the list of activities

## 1.0.1
* added a possibility of usage a custom http client
* added basic tests
* bug fixes

## 1.0.0
* welcome to Upwork!


text:
import sys

from django.utils.translation import ugettext_lazy as _t, ugettext as _

from desktop.lib.conf import Config
from spark.settings import NICE_NAME

JOB_SERVER_URL = Config(
  key="server_url",
  help=_t("URL of the Spark Job Server."),
  default="http://localhost:8090/"
)

def get_spark_status(user):
  from spark.job_server_api import get_api
  status = None

  try:
    if not 'test' in sys.argv: # Avoid tests hanging
      status = str(get_api(user).get_status())
  except ValueError:
    # No json returned
    status = 'OK'
  except:
    pass

  return status

def config_validator(user):
  res = []

  status = get_spark_status(user)

  if status != 'OK':
    res.append((NICE_NAME, _("The app won't work without a running Job Server")))

  return res


text:
using UnityEngine;
using System.Collections;

public class DestroyForAbsorb : MonoBehaviour {

	void DestroyAbsorb ()
	{
		Destroy(gameObject); //destroys absorb prefab when right click is released.
	}

	void OnEnable()
	{
		InputManager.OnRelease += DestroyAbsorb;
	}

	void OnDisable()
	{
		InputManager.OnRelease -= DestroyAbsorb;
	}

}