text:
\documentclass[11pt]{article}
\usepackage{graphicx,amsmath,amsfonts,amssymb,graphicx}
\usepackage[varg]{txfonts}
\usepackage{enumerate}
\usepackage{hyperref}
\usepackage{listings}
\usepackage{color}
\urlstyle{tt}

\usepackage{geometry}
\geometry{%
  letterpaper,
  lmargin=2cm,
  rmargin=2cm,
  tmargin=2cm,
  bmargin=2cm,
  footskip=12pt,
  headheight=12pt}

\usepackage{lastpage}
\usepackage{fancyhdr}
%\pagestyle{fancy}
%\headheight 35pt

\def\squarebox#1{\hbox to #1{\hfill\vbox to #1{\vfill}}}
\def\qed{\hspace*{\fill}
        \vbox{\hrule\hbox{\vrule\squarebox{.667em}\vrule}\hrule}}
\newenvironment{solution}{\begin{trivlist}\item[]{\bf Solution:}}
                      {\textbf{//} \end{trivlist}}
\lstset{
	language=MATLAB,              % choose the language of the code ("language=Verilog" is popular as well)
   tabsize=3,							  % sets the size of the tabs in spaces (1 Tab is replaced with 3 spaces)
	basicstyle=\tiny,               % the size of the fonts that are used for the code
	numbers=left,                   % where to put the line-numbers
	numberstyle=\tiny,              % the size of the fonts that are used for the line-numbers
	stepnumber=2,                   % the step between two line-numbers. If it's 1 each line will be numbered
	numbersep=5pt,                  % how far the line-numbers are from the code
	%backgroundcolor=\color{mygrey}, % choose the background color. You must add \usepackage{color}
	%showspaces=false,              % show spaces adding particular underscores
	%showstringspaces=false,        % underline spaces within strings
	%showtabs=false,                % show tabs within strings adding particular underscores
	frame=single,	                 % adds a frame around the code
	tabsize=3,	                    % sets default tabsize to 2 spaces
	captionpos=b,                   % sets the caption-position to bottom
	breaklines=true,                % sets automatic line breaking
	breakatwhitespace=false,        % sets if automatic breaks should only happen at whitespace
	%escapeinside={\%*}{*)},        % if you want to add a comment within your code
	%commentstyle=\color{BrickRed}   % sets the comment style
}
\begin{document}

\title{\bf{CSE397: Assignment \#4}}
\author{Nicholas Malaya \\ Department of Mechanical Engineering \\
Institute for Computational Engineering and Sciences \\ University of
Texas at Austin} \date{}
\maketitle
\newpage

\subsection*{ Problem 1}
\textbf{Frequency-domain inverse wave problem.}

\begin{enumerate}
\item[(a)]
\begin{solution}
The weak form of the state equation is given by:
\begin{displaymath}
\int_{\Omega}\nabla u \cdot \nabla p - k^2mup - fp\hspace{2 mm}dx -
 \int_{\Gamma}p\nabla u \cdot n\hspace{2 mm}ds \hspace{1 cm} \forall p
 \in H^1_0(\Omega)
\end{displaymath}
However since p = 0 on the boundary then the boundary term is zero. The
 Lagragian is therefore:
\begin{displaymath}
\mathcal{L}(u,p,m) := \int_{\Omega}\nabla u \cdot \nabla p - k^2mup -
 fp\hspace{2 mm}dx + \int_{\Omega}\left(u - u^{obs}\right)^2 dx +
 \frac{\beta}{2}\int_{\Omega}\nabla m \cdot \nabla m dx
\end{displaymath}
We now take variations with respect to each of the parameters:
\begin{align}
\delta_u\mathcal{L}(\tilde{u}) &= \int_{\Omega}(u-u^{obs})\tilde{u} +
 \nabla\tilde{u}\cdot\nabla p - k^2m\tilde{u}p \hspace{2 mm} dx = 0
 \hspace{1 cm} \forall\tilde{u} \in H^1_0(\Omega) \nonumber \\
\delta_p\mathcal{L}(\tilde{p}) &= \int_{\Omega} \nabla u \cdot
 \nabla\tilde{p} - k^2mu\tilde{p} - f\tilde{p} \hspace{2 mm} dx = 0
 \hspace{1 cm} \forall\tilde{p} \in H^1_0(\Omega) \nonumber \\
\delta_m\mathcal{L}(\tilde{m}) &= \int_{\Omega} \beta \nabla m \cdot
 \nabla\tilde{m} - k^2\tilde{m}up \hspace{2 mm} dx = 0 \nonumber
\end{align}
The last of these equations is the gradient equation. It depends
 on both p and u which come from the adjoint and state
 equations. u is found to be the solution of the
 following:
\begin{align}
-\Delta u - k^2mu &= f\hspace{5 mm} \text{on } \Omega \nonumber \\
u &= 0 \hspace{5 mm} \text{on } \partial\Omega \nonumber
\end{align}
and $p$ is found to be the soultion to the adjoint equation:
\begin{align}
-\Delta p - k^2mp &= u^{obs} - u \hspace{5 mm} \text{on } \Omega \nonumber \\
p &= 0 \hspace{5 mm} \text{on } \partial\Omega \nonumber.
\end{align}
Using the solutions of these equations then gives the gradient with
 $\delta_m\mathcal{L}(\tilde{m}) = 0$.
\end{solution}

\item[(b)] Derive an expression for the (infinite dimensional) action of
	   the Hessian in a direction m in the single source and frequency case.

\begin{solution}
To get the application of a Hessian on a vector, one needs the second
 variation of the three weak forms in the previous section. These are:
\begin{align}
\left(\delta_u+\delta_m+\delta_p\right)\left(\delta_u\mathcal{L}\right)
 &= \int_\Omega \hat{u}\tilde{u} - k^2\hat{m}\tilde{u}p -
 k^2m\tilde{u}\hat{p} + \nabla\tilde{u}\cdot\nabla\hat{p} \hspace{2 mm}
 dx \nonumber \\
\left(\delta_u+\delta_m+\delta_p\right)\left(\delta_p\mathcal{L}\right)
 &= \int_\Omega \nabla\hat{u}\cdot\nabla\tilde{p} - k^2m\hat{u}\tilde{p}
 - k^2\hat{m}u\tilde{p} \hspace{2 mm} dx \nonumber \\
\left(\delta_u+\delta_m+\delta_p\right)\left(\delta_m\mathcal{L}\right)
 &= \int_\Omega \beta\nabla\hat{m}\cdot\nabla\tilde{m} -
 k^2\tilde{m}\hat{u}p - k^2\tilde{m}u\hat{p} \hspace{2 mm} dx \nonumber
\end{align}
However this introduces two new variables $\hat{p}$ and $\hat{u}$
 which need to be solved for. From the second variation one gets
 $\hat{u}$. Its strong form is given by:
\begin{align}
-\Delta\hat{u}-k^2m\hat{u} &= k^2\hat{m}u \hspace{5 mm} \text{on }
 \Omega \nonumber \\
\hat{u} &= 0 \hspace{5 mm} \text{on } \partial\Omega \nonumber
\end{align}
Similarly $\hat{p}$ is given by the solution to the second variation of the adjoint equation:
\begin{align}
-\Delta\hat{p} - k^2m\hat{p} &= k^2\hat{m}p - \hat{u}\hspace{5 mm} \text{on } \Omega \nonumber \\
\hat{p} &= 0 \hspace{5 mm} \text{on } \partial\Omega \nonumber
\end{align}
Using the solution to the state equation ($u$), the solution to the
 adjoint equation ($p$), $m$, the solution to the second variation of
 the state equation ($\hat{u}$), the solution to the second variation of
 the adjoint equation ($\hat{p}$), and given a direction $\hat{m}$, the
 action of the Hessian in a direction $\hat{m}$ is given by:
\begin{displaymath}
\int_\Omega \beta\nabla\hat{m}\cdot\nabla\tilde{m} -
 k^2\tilde{m}\hat{u}p - k^2\tilde{m}u\hat{p} \hspace{2 mm} dx = 0
\end{displaymath}
\end{solution}

\item[(c)] Derive an expression for the (infinite dimensional) gradient
	   for an arbitrary number of sources and frequencies. How many
	   state and adjoint equations have to be solved for a single
	   gradient computation?

\begin{solution}
The gradient is still calculated in the same manner as in the previous
 case with a single source and frequency. Therefore it is the variation
 of the Lagrangian with respect to m. However, now for each $u_{ij}$
 there is a corresponding adjoint variable $p_{ij}$ and the Lagrangian
 takes a slightly different form than before. With all of the
 frequencies and sources the minimization problem is given as stated:
\begin{displaymath}
\min_m J(m) :=
 \frac{1}{2}\sum_{i=1}^{N_f}\sum_{j=1}^{N_s}\int_{\Omega}\left(u_{ij} -
 u_{ij}^{obs}\right)^2 dx + \frac{\beta}{2}\int_{\Omega}\nabla m \cdot
 \nabla m dx
\end{displaymath}
To form the Lagrangian this needs to be paired with the state equation. However the state equation for a single $u_{ij}$ is given by:
\begin{align}
-\Delta u_{ij} - k_i^2m(x)u_{ij}(x) &= f_j(x)\hspace{5 mm} \text{on }
 \Omega \hspace{5 mm} i = 1, 2, ..., N_f \hspace{5 mm} j = 1, 2, ...,
 N_s \nonumber \\
u_{ij} &= 0 \hspace{5 mm} \text{on } \partial\Omega \nonumber
\end{align}
Therefore one needs to carry all $N_sN_f$ of these into the
 Lagrangian. Note that in weak form, a single state equation looks like:
\begin{displaymath}
\int_{\Omega}\nabla u_{ij} \cdot \nabla p_{ij} - k_i^2mu_{ij}p_{ij} -
 f_jp_{ij}\hspace{2 mm}dx \hspace{1 cm} \forall p_{ij} \in H^1_0(\Omega)
\end{displaymath}
Again the boundary term is zero since $p_{ij} = 0$ on the boundary. With
 the weak forms for each of the $u_{ij}$, the Lagrangian is given by:
\begin{displaymath}
\mathcal{L} := \sum_{i=1}^{N_f}\sum_{j=1}^{N_s}\int_{\Omega}\left(\nabla
 u_{ij} \cdot \nabla p_{ij} - k_i^2mu_{ij}p_{ij} - f_jp_{ij}\right)dx +
 \frac{1}{2}\sum_{i=1}^{N_f}\sum_{j=1}^{N_s}\int_{\Omega}\left(u_{ij} -
 u_{ij}^{obs}\right)^2 dx + \frac{\beta}{2}\int_{\Omega}(\nabla m \cdot
 \nabla m) dx
\end{displaymath}
Taking a variation with respect to $m$ of this gives:
\begin{displaymath}
\int_{\Omega} \beta (\nabla m \cdot \nabla\tilde{m})dx -
 \sum_{i=1}^{N_f}\sum_{j=1}^{N_s}\int_{\Omega}(k_i^2\tilde{m}u_{ij}p_{ij})dx
\end{displaymath}
This will give the gradient for a point $m$, provided a solution is
 available for each of the $u_{ij}$ and the $p_{ij}$. Obtaining those
 solutions requires $N_sN_f$ solves of the state and adjoint equations
 for a total of $2N_sN_f$ PDE solves.
\end{solution}
\end{enumerate}

\newpage
\subsection*{Problem 2}

\begin{enumerate}
\item[(a)] Report the solution of the inverse problem and the number of
	  required iterations for the following cases:

%Report the reconstructions and the number of required
%	  iterations for the following cases:

\begin{enumerate}
 \item[$\bullet$] Noise level of 0.01 (roughly $1\%$ noise), and
	      regularization $\beta = 5 \cdot 10^{-10}$.
 \item[$\bullet$] Same, but with $\beta = 0$, i.e., no regularization.
 \item[$\bullet$] No noise, and use $m \equiv 4$ and $m \equiv 8$ as
	      initial guesses for the parameter. Do you find the same
	      solution? Explain the behavior.
\end{enumerate}
\begin{solution}
The following table summarizes the number of iterations for each of the
 desired start conditions:
\begin{center}
\begin{tabular}{| c | c | c | c |} \cline{1-4}
Noise & $\beta$ & $m$ & No. of Iterations \\ \cline{1-4}
0.01 & 5E-10 & 8 & 284 \\ \cline{1-4}
0.01 & 0.0 & 8 & 27 \\ \cline{1-4}
0.0 & 0.0 & 8 & 27 \\ \cline{1-4}
0.0 & 0.0 & 4 & 24 \\ \cline{1-4}
\end{tabular}
\end{center}
The results of these trials are can be quite different. The case with noise
 and regularization yields the following result:
\begin{center}
\includegraphics[width = 6 cm]{figs/prob2aNoiseRegM8.jpg}
\end{center}

The case with no regularization resulted in:
\begin{center}
\includegraphics[width = 6 cm]{figs/prob2aNoiseNoRegM8.jpg}
\end{center}

The case with no noise and no regularization and $m = 8$:
\begin{center}
\includegraphics[width = 6 cm]{figs/prob2aNoNoiseNoRegM8.jpg}
\end{center}

The case with no noise and no regularization and $m = 4$:
\begin{center}
\includegraphics[width = 6 cm]{figs/prob2aNoNoiseNoRegM4.jpg}
\end{center}

Note the difference in the final cases where the result for $m = 4$ ($a$
 in the image) is vastly different from the other results. This is a
 direct result of steepest descent being dependent on the start
 value. The case with no noise or regularization with $m = 8$ provides a
 solution close to the truth. Similarly
 the $m = 4$ solution is close to the true solution except for the
 diagonals. Note also that the $p$ values are also rather
 different. This is likely due to the adjoint being sensitive to
 $m$. $u$ should also be sensitive to $m$, but the end result look
 roughly the same because of the misfit penalization.
\end{solution}

\item[(b)] Add the advective term v = (30, 0) to the inverse problem and its COMSOL
	  implementation and plot the resulting reconstruction of m for
	  a noise level of 0.01 and for a reasonably chosen regularization parameter.

\begin{solution}
After adding the advective term, the result for a noise level of 0.01
 and regularization of 5e-10 is given by:
\begin{center}
\includegraphics[width = 6 cm]{figs/prob2bNoiseRegM8.jpg}
\end{center}
\end{solution}

\item[(c)] Since the coefficient m is discontinuous, a better choice of
	   regularization is total variation
	   rather than Tikhonov regularization, to prevent an overly smooth
	   reconstruction. Modify the implementation and plot the result
	   for a reasonably chosen regularization parameter

%Since the coefficient $m$ is discontinuous, a better choice is to use total variation
%regularization rather than Tikhonov regularization to prevent an overly smooth
%reconstruction. Modify the implementation and plot the result for a reasonably
%chosen regularization parameter.

\begin{solution}
 Since one is switching to a total variational regularization parameter,
 now two choices of parameters are needed. For the solution shown below,
 the calculation was done with the same advective term, regularization
 parameter beta, and noise level as before in part b, however it also
 uses a tau of 1e-1 as requested. The result found is:
\begin{center}
\includegraphics[width = 6 cm]{figs/prob2c.jpg}
\end{center}
Note that the drift from the advective term is not fully removed by this
 regularization, though the solution is much closer than with Tikhonov
 regularization.
\end{solution}
\end{enumerate}

\newpage
\subsection*{Code}
Here is the code for part c:
\lstinputlisting{code/elliptic_sd_ip_adv_TV.m}
\end{document}


text:
<?xml version="1.0" encoding="utf-8"?>
<parameters>
  <setParameter name="IIS Web Application Name" value="Default Web Site/Orchard.Themes_deploy" />
</parameters>

redpajama_set_name: RedPajamaGithub


text:
using Android.Util;
using Java.Lang;
using System;

namespace Yalla
{
    /// <summary>
    /// Android system logger.
    /// </summary>
	class SystemLogger : LoggerBase<LogPriority>
	{
        /// <summary>
        /// Initializes a new instance of the <see cref="Yalla.SystemLogger"/> class.
        /// </summary>
        /// <param name="name">Name.</param>
		public SystemLogger(string name)
			: base(name)
		{
		}

        /// <summary>
        /// Logs an entry.
        /// </summary>
        /// <param name="level">Log level.</param>
        /// <param name="entry">The entry.</param>
        /// <param name="message">The message.</param>
        /// <param name="provider">Format provider.</param>
        protected override void Log(LogPriority level, LogEntry entry, string message, IFormatProvider provider)
        {
            if (entry.Exception == null)
                global::Android.Util.Log.WriteLine(level, Name, message);
            else
                Log(level, entry.Exception, message);
        }

        /// <summary>
        /// Gets a value indicating whether logging of entries of the specified level is enabled.
        /// </summary>
        /// <param name="level">Log level.</param>
        /// <value><c>true</c> if logging of entries of the specified level is enabled.</value>
		protected override bool IsEnabled(LogPriority level)
		{
			return global::Android.Util.Log.IsLoggable(Name, level);
		}

        /// <summary>
        /// Gets the concrete log level.
        /// </summary>
        /// <param name="logLevel">Yalla log level.</param>
        /// <returns>Log priority.</returns>
		protected override LogPriority GetLevel(LogLevel logLevel)
		{
			switch (logLevel)
			{
				case LogLevel.Trace:
					return LogPriority.Verbose;
				case LogLevel.Debug:
					return LogPriority.Debug;
				case LogLevel.Info:
					return LogPriority.Info;
				case LogLevel.Warn:
					return LogPriority.Warn;
				case LogLevel.Error:
					return LogPriority.Error;
				case LogLevel.Fatal:
					return LogPriority.Assert;
				default:
					return LogPriority.Verbose;
			}
		}

        private void Log(LogPriority level, System.Exception exception, string message)
        {
            var throwable = Throwable.FromException(exception);
            switch (level)
            {
                case LogPriority.Verbose:
                    global::Android.Util.Log.Verbose(Name, throwable, message);
                    break;
                case LogPriority.Debug:
                    global::Android.Util.Log.Debug(Name, throwable, message);
                    break;
                case LogPriority.Info:
                    global::Android.Util.Log.Info(Name, throwable, message);
                    break;
                case LogPriority.Warn:
                    global::Android.Util.Log.Warn(Name, throwable, message);
                    break;
                case LogPriority.Error:
                    global::Android.Util.Log.Error(Name, throwable, message);
                    break;
                case LogPriority.Assert:
                    global::Android.Util.Log.Wtf(Name, throwable, message);
                    break;
                default:
                    break;
            }
        }
    }

    /// <summary>
    /// Android system logger factory adapter.
    /// </summary>
    public class SystemLoggerFactoryAdapter : LoggerFactoryAdapterBase
    {
        /// <summary>
        /// Initializes a new instance of the <see cref="Yalla.SystemLoggerFactoryAdapter"/> class.
        /// </summary>
        public SystemLoggerFactoryAdapter()
        {
        }

        /// <summary>
        /// Initializes the logging system.
        /// </summary>
        /// <param name="prologue">Prologue.</param>
        public override void Initialize(string prologue)
        {
        }

        /// <summary>
        /// Terminates the logging system.
        /// </summary>
        /// <param name="epilogue">Epilogue.</param>
        public override void Shutdown(string epilogue)
        {
        }

        /// <summary>
        /// Gets a logger instance by name.
        /// </summary>
        /// <param name="name">The name of the logger.</param>
        /// <returns>Logger.</returns>
        public override ILogger GetLogger(string name)
        {
            return new SystemLogger(name);
        }
    }
}


text:
<?php

Loader::load('utility', 'crawler/rule/page/CrawlerRulePage');

abstract class CrawlerRulePageContentInternalLink extends CrawlerRulePage
{

	public function __construct() {}

	final protected function get_content_internal_links()
	{
		return $this->get_page()->getInternalLinks();
	}

}

?>


text:
ACCEPTED

#### According to
Index Fungorum

#### Published in
J. gen. appl. Microbiol. , Tokyo 32(2): 152 (1986)

#### Original name
Sporobolomyces oryzicola Nakase & M. Suzuki

### Remarks
null


text:
using System;
using Microsoft.EntityFrameworkCore;
using Web.Models;

namespace WebTests.ViewModels
{
    public class BaseViewModelTest
    {
        protected ApplicationDbContext CreateDbContext()
        {
            var optionsBuilder = new DbContextOptionsBuilder<ApplicationDbContext>();

            optionsBuilder.UseInMemoryDatabase();

            var db = new ApplicationDbContext(optionsBuilder.Options);

            db.Libraries.Add(new Library
            {
                CreatedByUserId = "dbo",
                CreatedOn = DateTimeOffset.Now,
                ModifiedOn = DateTimeOffset.Now,
                Name = "Test Library",
                Status = StatusTypes.Active
            });

            db.SaveChanges();

            return db;
        }
    }
}


text:
/*
 * The Plaid API
 *
 * The Plaid REST API. Please see https://plaid.com/docs/api for more details.
 *
 * API version: 2020-09-14_1.205.3
 */

// Code generated by OpenAPI Generator (https://openapi-generator.tech); DO NOT EDIT.

package plaid

import (
	"encoding/json"
)

// BankTransferGetResponse Defines the response schema for `/bank_transfer/get`
type BankTransferGetResponse struct {
	BankTransfer BankTransfer `json:"bank_transfer"`
	// A unique identifier for the request, which can be used for troubleshooting. This identifier, like all Plaid identifiers, is case sensitive.
	RequestId string `json:"request_id"`
	AdditionalProperties map[string]interface{}
}

type _BankTransferGetResponse BankTransferGetResponse

// NewBankTransferGetResponse instantiates a new BankTransferGetResponse object
// This constructor will assign default values to properties that have it defined,
// and makes sure properties required by API are set, but the set of arguments
// will change when the set of required properties is changed
func NewBankTransferGetResponse(bankTransfer BankTransfer, requestId string) *BankTransferGetResponse {
	this := BankTransferGetResponse{}
	this.BankTransfer = bankTransfer
	this.RequestId = requestId
	return &this
}

// NewBankTransferGetResponseWithDefaults instantiates a new BankTransferGetResponse object
// This constructor will only assign default values to properties that have it defined,
// but it doesn't guarantee that properties required by API are set
func NewBankTransferGetResponseWithDefaults() *BankTransferGetResponse {
	this := BankTransferGetResponse{}
	return &this
}

// GetBankTransfer returns the BankTransfer field value
func (o *BankTransferGetResponse) GetBankTransfer() BankTransfer {
	if o == nil {
		var ret BankTransfer
		return ret
	}

	return o.BankTransfer
}

// GetBankTransferOk returns a tuple with the BankTransfer field value
// and a boolean to check if the value has been set.
func (o *BankTransferGetResponse) GetBankTransferOk() (*BankTransfer, bool) {
	if o == nil  {
		return nil, false
	}
	return &o.BankTransfer, true
}

// SetBankTransfer sets field value
func (o *BankTransferGetResponse) SetBankTransfer(v BankTransfer) {
	o.BankTransfer = v
}

// GetRequestId returns the RequestId field value
func (o *BankTransferGetResponse) GetRequestId() string {
	if o == nil {
		var ret string
		return ret
	}

	return o.RequestId
}

// GetRequestIdOk returns a tuple with the RequestId field value
// and a boolean to check if the value has been set.
func (o *BankTransferGetResponse) GetRequestIdOk() (*string, bool) {
	if o == nil  {
		return nil, false
	}
	return &o.RequestId, true
}

// SetRequestId sets field value
func (o *BankTransferGetResponse) SetRequestId(v string) {
	o.RequestId = v
}

func (o BankTransferGetResponse) MarshalJSON() ([]byte, error) {
	toSerialize := map[string]interface{}{}
	if true {
		toSerialize["bank_transfer"] = o.BankTransfer
	}
	if true {
		toSerialize["request_id"] = o.RequestId
	}

	for key, value := range o.AdditionalProperties {
		toSerialize[key] = value
	}

	return json.Marshal(toSerialize)
}

func (o *BankTransferGetResponse) UnmarshalJSON(bytes []byte) (err error) {
	varBankTransferGetResponse := _BankTransferGetResponse{}

	if err = json.Unmarshal(bytes, &varBankTransferGetResponse); err == nil {
		*o = BankTransferGetResponse(varBankTransferGetResponse)
	} else {
		return err
	}

	additionalProperties := make(map[string]interface{})

	if err = json.Unmarshal(bytes, &additionalProperties); err == nil {
		delete(additionalProperties, "bank_transfer")
		delete(additionalProperties, "request_id")
		o.AdditionalProperties = additionalProperties
	}

	return err
}

type NullableBankTransferGetResponse struct {
	value *BankTransferGetResponse
	isSet bool
}

func (v NullableBankTransferGetResponse) Get() *BankTransferGetResponse {
	return v.value
}

func (v *NullableBankTransferGetResponse) Set(val *BankTransferGetResponse) {
	v.value = val
	v.isSet = true
}

func (v NullableBankTransferGetResponse) IsSet() bool {
	return v.isSet
}

func (v *NullableBankTransferGetResponse) Unset() {
	v.value = nil
	v.isSet = false
}

func NewNullableBankTransferGetResponse(val *BankTransferGetResponse) *NullableBankTransferGetResponse {
	return &NullableBankTransferGetResponse{value: val, isSet: true}
}

func (v NullableBankTransferGetResponse) MarshalJSON() ([]byte, error) {
	return json.Marshal(v.value)
}

func (v *NullableBankTransferGetResponse) UnmarshalJSON(src []byte) error {
	v.isSet = true
	return json.Unmarshal(src, &v.value)
}


text:
package captcha

import "testing"

type byteCounter struct {
	n int64
}

func (bc *byteCounter) Write(b []byte) (int, error) {
	bc.n += int64(len(b))
	return len(b), nil
}

func BenchmarkNewImage(b *testing.B) {
	b.StopTimer()
	d := RandomDigits(DefaultLen)
	b.StartTimer()
	for i := 0; i < b.N; i++ {
		NewImage(d, StdWidth, StdHeight)
	}
}

func BenchmarkImageWriteTo(b *testing.B) {
	b.StopTimer()
	d := RandomDigits(DefaultLen)
	b.StartTimer()
	counter := &byteCounter{}
	for i := 0; i < b.N; i++ {
		img := NewImage(d, StdWidth, StdHeight)
		img.WriteTo(counter)
		b.SetBytes(counter.n)
		counter.n = 0
	}
}


text:
import logging
from api.core.signals.events import   EventController

__author__ = 'Michael Pryor'

logger = logging.getLogger(__name__)

class Analysis(EventController):
    def __init__(self, resultKey, dataSignalers=None, displayHandlers=None):
        """ @param resultKey key to identify resulting analysis.
            @param dataSignalers data source signalers.
            @param displayHandlers display handlers. """
        EventController.__init__(self, resultKey, self.processDataChange, signalers=dataSignalers, handlers=displayHandlers)

    def processDataChange(self, signaler, data):
        raise NotImplementedError


text:
from __future__ import  absolute_import

from bokeh.models.annotations import Legend, BoxAnnotation, Span
from bokeh.enums import (
    NamedColor as Color, LineJoin, LineCap, FontStyle, TextAlign,
    TextBaseline)

FILL = ["fill_color", "fill_alpha"]
BACKGROUND = ['background_fill_color', 'background_fill_alpha']
BORDER = ["border_line_color", "border_line_width", "border_line_alpha",
    "border_line_join", "border_line_cap", "border_line_dash",
    "border_line_dash_offset"]
LINE = ["line_color", "line_width", "line_alpha", "line_join", "line_cap",
    "line_dash", "line_dash_offset"]
LABEL = ["label_text_font", "label_text_font_size", "label_text_font_style",
    "label_text_color", "label_text_alpha", "label_text_align",
    "label_text_baseline"]
PROPS = ["session", "name", "tags"]

def check_border(annotation):
    assert annotation.border_line_color == Color.black
    assert annotation.border_line_width == 1
    assert annotation.border_line_alpha == 1.0
    assert annotation.border_line_join == LineJoin.miter
    assert annotation.border_line_cap == LineCap.butt
    assert annotation.border_line_dash == []
    assert annotation.border_line_dash_offset == 0

def check_label(annotation):
    assert annotation.label_text_font == "Helvetica"
    assert annotation.label_text_font_size == "12pt"
    assert annotation.label_text_font_style == FontStyle.normal
    assert annotation.label_text_color == "#444444"
    assert annotation.label_text_alpha == 1.0
    assert annotation.label_text_align == TextAlign.left
    assert annotation.label_text_baseline == TextBaseline.bottom

def check_props(annotation, *props):
    expected = set(sum((PROPS,) + props, []))
    found = set(annotation.properties())
    missing = expected.difference(found)
    extra = found.difference(expected)
    assert len(missing) == 0, "Properties missing: {0}".format(", ".join(sorted(missing)))
    assert len(extra) == 0, "Extra properties: {0}".format(", ".join(sorted(extra)))

def check_fill(annotation):
    assert annotation.fill_color == Color.gray
    assert annotation.fill_alpha == 1.0

def check_background(annotation):
    assert annotation.background_fill_color == Color.gray
    assert annotation.background_fill_alpha == 1.0

def check_line(annotation):
    assert annotation.line_color == Color.black
    assert annotation.line_width == 1
    assert annotation.line_alpha == 1.0
    assert annotation.line_join == LineJoin.miter
    assert annotation.line_cap == LineCap.butt
    assert annotation.line_dash == []
    assert annotation.line_dash_offset == 0

def test_Legend():
    legend = Legend()
    assert legend.plot is None
    assert legend.orientation == 'top_right'
    assert legend.label_standoff == 15
    assert legend.label_height == 20
    assert legend.label_width == 50
    assert legend.glyph_height == 20
    assert legend.glyph_width == 20
    assert legend.legend_padding == 10
    assert legend.legend_spacing == 3
    assert legend.legends == []
    yield check_border, legend
    yield check_label, legend
    yield check_background, legend
    yield (check_props, legend, [
        "plot",
        "orientation",
        "label_standoff",
        "label_height",
        "label_width",
        "glyph_height",
        "glyph_width",
        "legend_padding",
        "legend_spacing",
        "legends"
    ], LABEL, BORDER, BACKGROUND)

def test_BoxAnnotation():
    box = BoxAnnotation()
    assert box.plot is None
    assert box.left == 'auto'
    assert box.left_units == 'data'
    assert box.right == 'auto'
    assert box.right_units == 'data'
    assert box.bottom == 'auto'
    assert box.bottom_units == 'data'
    assert box.top == 'auto'
    assert box.top_units == 'data'
    assert box.x_range_name == 'default'
    assert box.y_range_name == 'default'
    assert box.level == 'annotation'
    yield check_line, box
    yield check_fill, box
    yield (check_props, box, [
        "plot",
        "left",
        "left_units",
        "right",
        "right_units",
        "bottom",
        "bottom_units",
        "top",
        "top_units",
        "x_range_name",
        "y_range_name",
        "level",
    ], LINE, FILL)

def test_Span():
    line = Span()
    assert line.plot is None
    assert line.location is None
    assert line.location_units == 'data'
    assert line.dimension == 'width'
    assert line.x_range_name == 'default'
    assert line.y_range_name == 'default'
    assert line.level == 'annotation'
    assert line.render_mode == 'canvas'
    yield check_line, line
    yield (check_props, line, [
        "plot",
        "location",
        "location_units",
        "dimension",
        "x_range_name",
        "y_range_name",
        "level",
        "render_mode"
    ], LINE)


text:
var app = app || {};

(function ($) {
  'use strict';

  app.HelloWorld = Vigor.ComponentBase.extend({
    $el: undefined,
    _helloWorldViewModel: undefined,
    _helloWorldView: undefined,

    constructor: function (options) {
      var viewModelId = 'dummy';
      Vigor.ComponentBase.prototype.constructor.call(this, options);
      this._helloWorldViewModel = new app.HelloWorldViewModel(viewModelId);
      this._helloWorldView = new app.HelloWorldView({viewModel: this._helloWorldViewModel});
    },

    render: function () {
      this.$el = this._helloWorldView.render().$el;
      return this;
    },

    dispose: function () {
      this._helloWorldView.dispose();
      this._helloWorldViewModel.dispose();
      this._helloWorldView = undefined;
      this._helloWorldViewModel = undefined;
    }

  });
})(jQuery);


text:
export class Config {
    api: any;
    apiBaseUrl: string;
    editors: any = {
        text: './editors/text-editor',
        boolean: './editors/boolean-editor',
        dropdown: './editors/dropdown-editor',
    };
    onSetEditor: any = null;
}


text:
/**
 *
 */
package com.zimbra.qa.selenium.projects.desktop.ui.search;

import com.zimbra.qa.selenium.framework.ui.AbsApplication;
import com.zimbra.qa.selenium.framework.ui.AbsPage;
import com.zimbra.qa.selenium.framework.ui.AbsTab;
import com.zimbra.qa.selenium.framework.ui.Action;
import com.zimbra.qa.selenium.framework.ui.Button;
import com.zimbra.qa.selenium.framework.util.HarnessException;

/**
 * @author Matt Rhoades
 *
 */
public class PageAdvancedSearch extends AbsTab {

	public static class Locators {
		public static final String TOOLBAR="css=div[id='skin_container_search_builder_toolbar']";
		public static final String PANEL="css=div[id='skin_container_search_builder']";

		//TODO
		//Fill in non-dynamic ID after bug 57628 fixed.
		public static final String CLOSE="css=div[id='WAIT_FOR_BUG_57628_TO_GET_THE_ID_FOR_CLOSE_BUTTON";
	}

	public PageAdvancedSearch(AbsApplication application) {
		super(application);

		logger.info("new " + PageAdvancedSearch.class.getCanonicalName());

	}

	/* (non-Javadoc)
	 * @see projects.admin.ui.AbsPage#isActive()
	 */
	@Override
	public boolean zIsActive() throws HarnessException {

		// Should it really wait?  Maybe the caller just
		// wants to know that it is not visible?

		try {
			zWaitForElementVisible(Locators.TOOLBAR);
		}
		catch (Exception e) {
			return false;
		}

		boolean toolbarVisible = sIsVisible(Locators.TOOLBAR);
		if ( !toolbarVisible ) {
			return false;
		}

		boolean panelVisible = sIsVisible(Locators.PANEL);
		if ( !panelVisible ) {
			return false;
		}

		return (true);

	}

	/* (non-Javadoc)
	 * @see projects.admin.ui.AbsPage#myPageName()
	 */
	@Override
	public String myPageName() {
		return (this.getClass().getName());
	}

	/* (non-Javadoc)
	 * @see projects.admin.ui.AbsPage#navigateTo()
	 */
	@Override
	public void zNavigateTo() throws HarnessException {
		throw new HarnessException("implement me!");
	}

	@Override
	public AbsPage zToolbarPressButton(Button button) throws HarnessException {
		AbsPage page=null;
		tracer.trace("Press the "+ button +" button");

		if (button == Button.B_CLOSE) {
           zClick(Locators.CLOSE);
           throw new HarnessException("Wait for bug 57826 fixed");
		}
	 	zWaitForBusyOverlay();

		return page;
	}

	@Override
	public AbsPage zToolbarPressPulldown(Button pulldown, Button option) throws HarnessException {
		tracer.trace("Click pulldown "+ pulldown +" then "+ option);

		throw new HarnessException("implement me!");
	}

	@Override
	public AbsPage zListItem(Action action, String item) throws HarnessException {
		throw new HarnessException(myPageName() + " does not have a list view");
	}

	@Override
	public AbsPage zListItem(Action action, Button option, String item) throws HarnessException {
		throw new HarnessException(myPageName() + " does not have a list view");
	}

	@Override
	public AbsPage zListItem(Action action, Button option, Button subOption ,String item)  throws HarnessException {
	   throw new HarnessException(myPageName() + " does not have a list view");
    }

}


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

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

    <title>nmrglue.process.pipe_proc.ls — nmrglue v0.2 documentation</title>
    <link rel="stylesheet" href="../../_static/sphinxdoc.css" type="text/css" />
    <link rel="stylesheet" href="../../_static/pygments.css" type="text/css" />

    <link rel="top" title="nmrglue v0.2 documentation" href="../../index.html" />
    <link rel="up" title="nmrglue.pipe_proc" href="../pipe_proc.html" />
    <link rel="next" title="nmrglue.process.pipe_proc.cs" href="nmrglue.process.pipe_proc.cs.html" />
    <link rel="prev" title="nmrglue.process.pipe_proc.rs" href="nmrglue.process.pipe_proc.rs.html" />

Navigation

          index

          modules |

          next |

          previous |

nmrglue v0.2 documentation »

Reference Guide »

nmrglue.pipe_proc »

Previous topic

nmrglue.process.pipe_proc.rs

Next topic

nmrglue.process.pipe_proc.cs

This Page

Show Source

Quick search

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

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

nmrglue.process.pipe_proc.ls¶

<tt class="descclassname">nmrglue.process.pipe_proc.</tt><tt class="descname">ls</tt><big>(</big>dic, data, ls=0.0, sw=False<big>)</big>¶

Left Shift and Zero Pad

Parameters:

dic   Dictionary of NMRPipe parameters.

data  array of spectral data.

ls    Number of points to left shift.  Negative values are intepreted

as right shifting.

sw    True to update chemical shift calibration parameters.

Navigation

          index

          modules |

          next |

          previous |

nmrglue v0.2 documentation »

Reference Guide »

nmrglue.pipe_proc »

      © Copyright 2010, Jonathan J. Helmus.
      Last updated on Apr 06, 2011.
      Created using Sphinx 0.6.4.


text:
<NetConnectResponse xmlns="http://www.experian.com/NetConnectResponse">
  <CompletionCode>4000</CompletionCode>
  <ErrorMessage>System error. Call Experian Technical Support at 1-800-854-7201</ErrorMessage>
  <ReferenceId/>
</NetConnectResponse>


text:
<?php

namespace Phlexible\Bundle\TreeBundle\EventListener;

use Phlexible\Bundle\TreeBundle\Mediator\ViewableVoterInterface;
use Symfony\Component\EventDispatcher\EventSubscriberInterface;
use Symfony\Component\HttpFoundation\Request;
use Symfony\Component\HttpKernel\Event\GetResponseEvent;
use Symfony\Component\HttpKernel\KernelEvents;
use Symfony\Component\Routing\RequestContextAwareInterface;

/**
 * Preview listener.
 *
 * @author Stephan Wentz <sw@brainbits.net>
 */
class PreviewListener implements EventSubscriberInterface
{
    /**
     * @var RequestContextAwareInterface
     */
    private $router;

    /**
     * @var ViewableVoterInterface
     */
    private $viewableVoter;

    /**
     * @param RequestContextAwareInterface $router
     * @param ViewableVoterInterface       $viewableVoter
     */
    public function __construct(RequestContextAwareInterface $router, ViewableVoterInterface $viewableVoter)
    {
        $this->router = $router;
        $this->viewableVoter = $viewableVoter;
    }

    /**
     * {@inheritdoc}
     */
    public static function getSubscribedEvents()
    {
        return array(
            // must be registered after the Router to have access to the _locale
            KernelEvents::REQUEST => array(array('onKernelRequest', 14)),
        );
    }

    /**
     * @param GetResponseEvent $event
     */
    public function onKernelRequest(GetResponseEvent $event)
    {
        $request = $event->getRequest();

        $this->setRouterContext($request);
    }

    /**
     * @param Request $request
     */
    private function setRouterContext(Request $request)
    {
        if ($request->attributes->get('_preview')) {
            $this->router->getContext()->setParameter('_preview', $request->attributes->get('_preview'));
            $this->viewableVoter->disablePublishCheck();
        }
    }
}


text:
using System.Collections.Generic;

namespace MathSite.Common.FileFormats.Documents
{
    public class XlsbFileFormat : VendorFileFormatBase
    {
        public override string ContentType { get; } = "application/vnd.ms-excel.sheet.binary.macroEnabled.12";

        public override IEnumerable<string> Extensions { get; } = new[] {".xlsb"};
    }
}


text:
package com.sequenceiq.freeipa.flow.freeipa.user.handler;

import java.io.IOException;
import java.util.Optional;

import javax.inject.Inject;

import org.apache.commons.lang3.StringUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.stereotype.Component;

import com.sequenceiq.cloudbreak.auth.altus.EntitlementService;
import com.sequenceiq.cloudbreak.auth.crn.Crn;
import com.sequenceiq.cloudbreak.eventbus.Event;
import com.sequenceiq.cloudbreak.logger.MDCBuilder;
import com.sequenceiq.flow.event.EventSelectorUtil;
import com.sequenceiq.flow.reactor.api.handler.EventHandler;
import com.sequenceiq.freeipa.client.FreeIpaCapabilities;
import com.sequenceiq.freeipa.client.FreeIpaClient;
import com.sequenceiq.freeipa.client.FreeIpaClientException;
import com.sequenceiq.freeipa.client.model.User;
import com.sequenceiq.freeipa.entity.Stack;
import com.sequenceiq.freeipa.flow.freeipa.user.event.SetPasswordRequest;
import com.sequenceiq.freeipa.flow.freeipa.user.event.SetPasswordResult;
import com.sequenceiq.freeipa.service.freeipa.FreeIpaClientFactory;
import com.sequenceiq.freeipa.service.freeipa.WorkloadCredentialService;
import com.sequenceiq.freeipa.service.freeipa.user.conversion.UserMetadataConverter;
import com.sequenceiq.freeipa.service.freeipa.user.model.UserMetadata;
import com.sequenceiq.freeipa.service.freeipa.user.model.WorkloadCredential;
import com.sequenceiq.freeipa.service.freeipa.user.model.WorkloadCredentialUpdate;
import com.sequenceiq.freeipa.service.freeipa.user.ums.UmsCredentialProvider;
import com.sequenceiq.freeipa.service.stack.StackService;

@Component
public class SetPasswordHandler implements EventHandler<SetPasswordRequest> {

    private static final Logger LOGGER = LoggerFactory.getLogger(SetPasswordHandler.class);

    @Inject
    private StackService stackService;

    @Inject
    private FreeIpaClientFactory freeIpaClientFactory;

    @Inject
    private UmsCredentialProvider umsCredentialProvider;

    @Inject
    private WorkloadCredentialService workloadCredentialService;

    @Inject
    private EntitlementService entitlementService;

    @Inject
    private UserMetadataConverter userMetadataConverter;

    @Override
    public String selector() {
        return EventSelectorUtil.selector(SetPasswordRequest.class);
    }

    @Override
    public void accept(Event<SetPasswordRequest> setPasswordRequestEvent) {
        SetPasswordRequest request = setPasswordRequestEvent.getData();
        LOGGER.info("SetPasswordHandler accepting request {}", request);
        try {
            Stack stack = stackService.getStackById(request.getResourceId());
            MDCBuilder.buildMdcContext(stack);

            FreeIpaClient freeIpaClient = freeIpaClientFactory.getFreeIpaClientForStack(stack);
            if (FreeIpaCapabilities.hasSetPasswordHashSupport(freeIpaClient.getConfig())) {
                LOGGER.info("IPA has password hash support. Credentials information from UMS will be used.");
                WorkloadCredential workloadCredential = umsCredentialProvider.getCredentials(request.getUserCrn());
                setPasswordHash(stack, request, freeIpaClient, workloadCredential);

                if (StringUtils.isBlank(workloadCredential.getHashedPassword())) {
                    LOGGER.info("IPA has password hash support but user does not have a password set in UMS; using the provided password directly.");
                    freeIpaClient.userSetPasswordWithExpiration(
                            request.getUsername(), request.getPassword(), request.getExpirationInstant());
                }
            } else {
                LOGGER.info("IPA does not have password hash support; using the provided password directly.");
                freeIpaClient.userSetPasswordWithExpiration(
                        request.getUsername(), request.getPassword(), request.getExpirationInstant());
            }
            SetPasswordResult result = new SetPasswordResult(request);
            request.getResult().onNext(result);
        } catch (Exception e) {
            request.getResult().onError(e);
        }
    }

    private void setPasswordHash(Stack stack, SetPasswordRequest request, FreeIpaClient freeIpaClient, WorkloadCredential workloadCredential)
            throws IOException, FreeIpaClientException {
        String accountId = Crn.fromString(stack.getEnvironmentCrn()).getAccountId();
        boolean credentialsUpdateOptimizationEnabled = entitlementService.usersyncCredentialsUpdateOptimizationEnabled(accountId);
        LOGGER.info("Credentials update optimization is{} enabled for account {}", credentialsUpdateOptimizationEnabled ? "" : " not", accountId);

        if (credentialUpdateRequired(credentialsUpdateOptimizationEnabled, request.getUsername(), freeIpaClient, workloadCredential)) {
            workloadCredentialService.setWorkloadCredential(credentialsUpdateOptimizationEnabled, freeIpaClient,
                    new WorkloadCredentialUpdate(request.getUsername(), request.getUserCrn(), workloadCredential));
        } else {
            LOGGER.debug("Not setting workload credentials for user '{}' because credentials are already up to date", request.getUsername());
        }
    }

    private boolean credentialUpdateRequired(boolean credentialsUpdateOptimizationEnabled, String username, FreeIpaClient freeIpaClient,
            WorkloadCredential workloadCredential) throws FreeIpaClientException {
        if (credentialsUpdateOptimizationEnabled) {
            Optional<User> ipaUser = freeIpaClient.userFind(username);
            if (ipaUser.isPresent()) {
                Optional<UserMetadata> userMetadata = userMetadataConverter.toUserMetadata(ipaUser.get());
                if (userMetadata.isPresent() && userMetadata.get().getWorkloadCredentialsVersion() >= workloadCredential.getVersion()) {
                    return false;
                }
            }
        }

        return true;
    }
}


text:
/**
 * @author J. Santos <jamillo@gmail.com>
 * @date July 12, 2016
 */

#include <gtest/gtest.h>
#include <boost/thread.hpp>
#include <http/response.h>

#define HTTPRESPONSE_HEADER_NAME_1 "Content-Type"
#define HTTPRESPONSE_HEADER_VALUE_1 "text/html"
#define HTTPRESPONSE_HEADER_NAME_2 "User-Agent"
#define HTTPRESPONSE_HEADER_VALUE_2 "Pseudo Browser"

#define HTTPRESPONSE_CONTENT1 "
Header 1
"
#define HTTPRESPONSE_CONTENT2 "
Another content
"

#define HTTPRESPONSE_PACKET1 "HTTP/1.1 200 OK\r\n" \
	"Content-Length: 39\r\n" \
	"User-Agent: Pseudo Browser\r\n" \
	"Content-Type: text/html\r\n\r\n" \
	HTTPRESPONSE_CONTENT1 HTTPRESPONSE_CONTENT2

#define HTTPRESPONSE_PACKET1 "HTTP/1.1 200 OK\r\n" \
	"Content-Length: 39\r\n" \
	"User-Agent: Pseudo Browser\r\n" \
	"Content-Type: text/html\r\n\r\n" \
	HTTPRESPONSE_CONTENT1 HTTPRESPONSE_CONTENT2

#define HTTPRESPONSE_PACKET2 "HTTP/1.1 500 Internal Server Error\r\n\r\n" HTTPRESPONSE_CONTENT1 HTTPRESPONSE_CONTENT2

#define HTTPRESPONSE_CONTENT_TYPE_JSON "application/json"
#define HTTPRESPONSE_PACKET_JSON "HTTP/1.1 200 OK\r\nContent-Length: 29\r\nContent-Type: application/json\r\n\r\n{\"message\":\"This is a json.\"}"

GTEST_TEST(http_response, params)
{
	std::stringbuf sbuf;
	std::ostream originalResponse(&sbuf);
	mote::http::ResponseBase<SimpleWeb::HTTP> response(originalResponse);
	response.header(HTTPRESPONSE_HEADER_NAME_1, HTTPRESPONSE_HEADER_VALUE_1);
	response.header(HTTPRESPONSE_HEADER_NAME_2, HTTPRESPONSE_HEADER_VALUE_2);
	ASSERT_EQ(HTTPRESPONSE_HEADER_VALUE_1, response.header(HTTPRESPONSE_HEADER_NAME_1));
	ASSERT_EQ(HTTPRESPONSE_HEADER_VALUE_2, response.header(HTTPRESPONSE_HEADER_NAME_2));
}

GTEST_TEST(http_response, params_replace)
{
	std::stringbuf sbuf;
	std::ostream originalResponse(&sbuf);
	mote::http::ResponseBase<SimpleWeb::HTTP> response(originalResponse);
	response.header(HTTPRESPONSE_HEADER_NAME_1, HTTPRESPONSE_HEADER_VALUE_1);
	response.header(HTTPRESPONSE_HEADER_NAME_1, HTTPRESPONSE_HEADER_VALUE_2);
	ASSERT_EQ(HTTPRESPONSE_HEADER_VALUE_2, response.header(HTTPRESPONSE_HEADER_NAME_1));
}

GTEST_TEST(http_response, status)
{
	std::stringbuf sbuf;
	std::ostream originalResponse(&sbuf);
	mote::http::ResponseBase<SimpleWeb::HTTP> response(originalResponse);
	response.status(mote::http::Status::IM_A_TEAPOT);
	ASSERT_EQ(mote::http::Status::IM_A_TEAPOT.value, response.status().value);
	ASSERT_EQ(mote::http::Status::IM_A_TEAPOT.text, response.status().text);
}

GTEST_TEST(http_response, content_type)
{
	std::stringbuf sbuf;
	std::ostream originalResponse(&sbuf);
	mote::http::ResponseBase<SimpleWeb::HTTP> response(originalResponse);
	response.contentType(HTTPRESPONSE_HEADER_VALUE_1);
	ASSERT_EQ(HTTPRESPONSE_HEADER_VALUE_1, response.contentType());
	ASSERT_EQ(HTTPRESPONSE_HEADER_VALUE_1, response.header(HTTPRESPONSE_HEADER_NAME_1));
}

GTEST_TEST(http_response, flush_1)
{
	std::stringbuf sbuf;
	std::ostream originalResponse(&sbuf);
	{
		mote::http::ResponseBase<SimpleWeb::HTTP> response(originalResponse);
		response.status(mote::http::Status::OK);
		response.contentType(HTTPRESPONSE_HEADER_VALUE_1);
		response.header(HTTPRESPONSE_HEADER_NAME_2, HTTPRESPONSE_HEADER_VALUE_2);
		response << HTTPRESPONSE_CONTENT1;
		response << HTTPRESPONSE_CONTENT2;
	}
	std::string r = sbuf.str();
	ASSERT_EQ(HTTPRESPONSE_PACKET1, r);
}

GTEST_TEST(http_response, flush_2)
{
	std::stringbuf sbuf;
	std::ostream originalResponse(&sbuf);
	mote::http::ResponseBase<SimpleWeb::HTTP> response(originalResponse);
	response.status(mote::http::Status::INTERNAL_SERVER_ERROR);
	response << HTTPRESPONSE_CONTENT1;
	response << HTTPRESPONSE_CONTENT2;
	response.flush();
	std::string r = sbuf.str();
	ASSERT_EQ(HTTPRESPONSE_PACKET2, r);
}

GTEST_TEST(http_response, setting_header_already_flushed_error)
{
	std::stringbuf sbuf;
	std::ostream originalResponse(&sbuf);
	mote::http::ResponseBase<SimpleWeb::HTTP> response(originalResponse);
	response.status(mote::http::Status::INTERNAL_SERVER_ERROR);
	response << HTTPRESPONSE_CONTENT1;
	response.flush();
	ASSERT_THROW(response.header(HTTPRESPONSE_HEADER_NAME_1, HTTPRESPONSE_HEADER_VALUE_1), mote::http::AlreadyBeenFlushed);
}

GTEST_TEST(http_response, json_success)
{
	std::stringbuf sbuf;
	std::ostream originalResponse(&sbuf);
	{
		mote::http::ResponseBase<SimpleWeb::HTTP> response(originalResponse);
		Json::Value json;
		json["message"] = "This is a json.";
		response << json;
		ASSERT_EQ(HTTPRESPONSE_CONTENT_TYPE_JSON, response.contentType());
	}
	ASSERT_EQ(HTTPRESPONSE_PACKET_JSON, sbuf.str());
}


text:
class PngEncoder {
public:
	PngEncoder(unsigned char *d, int w, int h);
	~PngEncoder();

	unsigned char *data;
	         char *png;
	unsigned int   png_len, mem_len;
			 int   width, height;

	png_structp png_ptr;
	png_infop   info_ptr;

	void Encode();
	const char *get_png() const;
	int get_png_len() const;
private:
	static void PngWriteCallback(png_structp png_ptr, png_bytep data, png_size_t length);
};

PngEncoder::PngEncoder(unsigned char *d, int w, int h){
	width   = w;
	height  = h;
	data    = d;
	png     = NULL;
	png_len = 0;
	mem_len = 0;
}

PngEncoder::~PngEncoder() {
	free(png);
}

void PngEncoder::PngWriteCallback(png_structp png_ptr, png_bytep data, png_size_t length){
	PngEncoder *p = (PngEncoder *)png_get_io_ptr(png_ptr);

	if (!p->png) {
		p->png = (char *)malloc(sizeof(p->png) * 41); // from tests pngs are at least 41 bytes
		if (!p->png)
			throw "malloc failed in png (PngEncoder::png_chunk_producer)";
		p->mem_len = 41;
	}

	if (p->png_len + length > p->mem_len) {
		char *new_png = (char *)realloc(p->png, sizeof(char)*p->png_len + length);
		if (!new_png)
			throw "realloc failed in png (PngEncoder::png_chunk_producer).";
		p->png = new_png;
		p->mem_len += length;
	}
	memcpy(p->png + p->png_len, data, length);
	p->png_len += length;
}

void PngEncoder::Encode(){
	png_bytep *row_pointers;
	try {
		png_ptr = png_create_write_struct(PNG_LIBPNG_VER_STRING, NULL, NULL, NULL);
		if (png_ptr == NULL){
			throw "png_create_write_struct failed.";
		}
		info_ptr = png_create_info_struct(png_ptr);
		if (info_ptr == NULL) {
			png_destroy_write_struct(&png_ptr, (png_infopp)NULL);
			throw "png_create_info_struct failed.";
		}

		png_set_IHDR(png_ptr, info_ptr, width, height, 8,
			PNG_COLOR_TYPE_RGB,
			PNG_INTERLACE_NONE,
			PNG_COMPRESSION_TYPE_DEFAULT,
			PNG_FILTER_TYPE_DEFAULT);

		png_set_write_fn(png_ptr, (void *)this, PngWriteCallback, NULL);
		png_write_info(png_ptr, info_ptr);
		png_set_invert_alpha(png_ptr);

		row_pointers = (png_bytep *)malloc(sizeof(png_bytep) * height);
		if (!row_pointers)
			throw "malloc failed in node-png (PngEncoder::encode).";

		for (int i = 0; i < height; i++)
			row_pointers[i] = data + 3 * i*width;

		png_write_image(png_ptr, row_pointers);
		png_write_end(png_ptr, NULL);
		png_destroy_write_struct(&png_ptr, &info_ptr);
		free(row_pointers);
	}
	catch (const char *err) {
		png_destroy_write_struct(&png_ptr, &info_ptr);
		free(row_pointers);
	}
}

const char *PngEncoder::get_png() const {
	return png;
}

int PngEncoder::get_png_len() const {
	return png_len;
}


text:
layout: master
include: person
name: Christine O. Rasmussen
home: DTU
country: "DK"
photo:
email: cora@dtu.dk
phone:
on_contract: yes
has_been_on_contract: yes
groups:
  pari:
  pari-sg:
---


text:
package org.encuestame.utils.exception;

/**
 * EnMe generic exception.
 * @author Picado, Juan juanATencuestame.org
 * @since Jul 3, 2011
 */
public class EnMeGenericException extends Exception {

    /**
     *
     */
    private static final long serialVersionUID = 4773692936156441054L;

    /**
     * Constructor.
     */
    public EnMeGenericException() {
        super();
    }

    /**
    * Exception.
    * @param message message
    * @param cause cause
    */
   public EnMeGenericException(final String message, final Throwable cause) {
       super(message, cause);

   }
   /**
    * Exception.
    * @param message message
    */
   public EnMeGenericException(final String message) {
       super(message);

   }

   /**
    * Exception.
    * @param cause cause
    */
   public EnMeGenericException(final Throwable cause) {
       super(cause);
   }
}


text:
<?php
/**
 * Clase general para el tratamiento de excepciones.
 * @author lobo (mloobo@gmail.com)
 *
 */
class Excepcion{
	var $mensaje="";
	var $clase="";
	var $funcion="";
	var $nombre="Excepcion General";

	/**
	 * Constructor.
	 * @param string $clase Nombre de la clase donde ocurre la excepción.
	 * @param string $funcion Nombre de la función donde ocurre la excepción.
	 * @param string $mensaje El mensaje
	 */
	function Excepcion($clase, $funcion, $mensaje="Error general"){
		$this->clase=$clase;
		$this->funcion=$funcion;
		$this->mensaje=$mensaje;
	}

	/**
	 * Método toString() sobre-escrito.
	 * @Overrride
	 * @return string
	 */
	function __toString(){
		return '
'.$this->nombre.'; '.$this->clase.'::'.$this->funcion.': '.$this->mensaje.'
';
	}
}
?>


text:
"""
Assertion helpers for arithmetic tests.
"""
import numpy as np
import pytest

from pandas import DataFrame, Index, Series
import pandas._testing as tm

def assert_invalid_addsub_type(left, right, msg=None):
    """
    Helper to assert that left and right can be neither added nor subtracted.

    Parameters
    ----------
    left : object
    right : object
    msg : str or None, default None
    """
    with pytest.raises(TypeError, match=msg):
        left + right
    with pytest.raises(TypeError, match=msg):
        right + left
    with pytest.raises(TypeError, match=msg):
        left - right
    with pytest.raises(TypeError, match=msg):
        right - left

def get_upcast_box(box, vector):
    """
    Given two box-types, find the one that takes priority
    """
    if box is DataFrame or isinstance(vector, DataFrame):
        return DataFrame
    if box is Series or isinstance(vector, Series):
        return Series
    if box is Index or isinstance(vector, Index):
        return Index
    return box

def assert_invalid_comparison(left, right, box):
    """
    Assert that comparison operations with mismatched types behave correctly.

    Parameters
    ----------
    left : np.ndarray, ExtensionArray, Index, or Series
    right : object
    box : {pd.DataFrame, pd.Series, pd.Index, tm.to_array}
    """
    # Not for tznaive-tzaware comparison

    # Note: not quite the same as how we do this for tm.box_expected
    xbox = box if box is not Index else np.array

    result = left == right
    expected = xbox(np.zeros(result.shape, dtype=np.bool_))

    tm.assert_equal(result, expected)

    result = right == left
    tm.assert_equal(result, expected)

    result = left != right
    tm.assert_equal(result, ~expected)

    result = right != left
    tm.assert_equal(result, ~expected)

    msg = "|".join(
        [
            "Invalid comparison between",
            "Cannot compare type",
            "not supported between",
            "invalid type promotion",
        ]
    )
    with pytest.raises(TypeError, match=msg):
        left < right
    with pytest.raises(TypeError, match=msg):
        left <= right
    with pytest.raises(TypeError, match=msg):
        left > right
    with pytest.raises(TypeError, match=msg):
        left >= right
    with pytest.raises(TypeError, match=msg):
        right < left
    with pytest.raises(TypeError, match=msg):
        right <= left
    with pytest.raises(TypeError, match=msg):
        right > left
    with pytest.raises(TypeError, match=msg):
        right >= left


text:
<?php

namespace Google\Service\CloudDeploy;

class Strategy extends \Google\Model
{
  protected $standardType = Standard::class;
  protected $standardDataType = '';

  /**
   * @param Standard
   */
  public function setStandard(Standard $standard)
  {
    $this->standard = $standard;
  }
  /**
   * @return Standard
   */
  public function getStandard()
  {
    return $this->standard;
  }
}

// Adding a class alias for backwards compatibility with the previous class name.
class_alias(Strategy::class, 'Google_Service_CloudDeploy_Strategy');


text:
.class Lcom/android/server/PowerManagerService$SmartSleepNotificationTask;
.super Ljava/lang/Object;
.source "PowerManagerService.java"

# interfaces
.implements Ljava/lang/Runnable;

# annotations
.annotation system Ldalvik/annotation/EnclosingClass;
    value = Lcom/android/server/PowerManagerService;
.end annotation

.annotation system Ldalvik/annotation/InnerClass;
    accessFlags = 0x2
    name = "SmartSleepNotificationTask"
.end annotation

# instance fields
.field final synthetic this$0:Lcom/android/server/PowerManagerService;

# direct methods
.method private constructor <init>(Lcom/android/server/PowerManagerService;)V
    .locals 0
    .parameter

    .prologue
    .line 1798
    iput-object p1, p0, Lcom/android/server/PowerManagerService$SmartSleepNotificationTask;->this$0:Lcom/android/server/PowerManagerService;

    invoke-direct/range {p0 .. p0}, Ljava/lang/Object;-><init>()V

    return-void
.end method

.method synthetic constructor <init>(Lcom/android/server/PowerManagerService;Lcom/android/server/PowerManagerService$1;)V
    .locals 0
    .parameter "x0"
    .parameter "x1"

    .prologue
    .line 1798
    invoke-direct {p0, p1}, Lcom/android/server/PowerManagerService$SmartSleepNotificationTask;-><init>(Lcom/android/server/PowerManagerService;)V

    return-void
.end method

# virtual methods
.method public run()V
    .locals 2

    .prologue
    .line 1802
    iget-object v0, p0, Lcom/android/server/PowerManagerService$SmartSleepNotificationTask;->this$0:Lcom/android/server/PowerManagerService;

    const/4 v1, 0x0

    #setter for: Lcom/android/server/PowerManagerService;->mFaceDetected:Z
    invoke-static {v0, v1}, Lcom/android/server/PowerManagerService;->access$5202(Lcom/android/server/PowerManagerService;Z)Z

    .line 1803
    iget-object v0, p0, Lcom/android/server/PowerManagerService$SmartSleepNotificationTask;->this$0:Lcom/android/server/PowerManagerService;

    #getter for: Lcom/android/server/PowerManagerService;->mUserActivityAllowed:Z
    invoke-static {v0}, Lcom/android/server/PowerManagerService;->access$5300(Lcom/android/server/PowerManagerService;)Z

    move-result v0

    if-eqz v0, :cond_0

    iget-object v0, p0, Lcom/android/server/PowerManagerService$SmartSleepNotificationTask;->this$0:Lcom/android/server/PowerManagerService;

    invoke-virtual {v0}, Lcom/android/server/PowerManagerService;->isScreenOn()Z

    move-result v0

    if-eqz v0, :cond_0

    iget-object v0, p0, Lcom/android/server/PowerManagerService$SmartSleepNotificationTask;->this$0:Lcom/android/server/PowerManagerService;

    #getter for: Lcom/android/server/PowerManagerService;->mWakeLockState:I
    invoke-static {v0}, Lcom/android/server/PowerManagerService;->access$5400(Lcom/android/server/PowerManagerService;)I

    move-result v0

    and-int/lit8 v0, v0, 0x2

    if-nez v0, :cond_0

    .line 1804
    iget-object v0, p0, Lcom/android/server/PowerManagerService$SmartSleepNotificationTask;->this$0:Lcom/android/server/PowerManagerService;

    iget-object v1, p0, Lcom/android/server/PowerManagerService$SmartSleepNotificationTask;->this$0:Lcom/android/server/PowerManagerService;

    #calls: Lcom/android/server/PowerManagerService;->checkIntelligentSleep()Z
    invoke-static {v1}, Lcom/android/server/PowerManagerService;->access$5500(Lcom/android/server/PowerManagerService;)Z

    move-result v1

    #setter for: Lcom/android/server/PowerManagerService;->mFaceDetected:Z
    invoke-static {v0, v1}, Lcom/android/server/PowerManagerService;->access$5202(Lcom/android/server/PowerManagerService;Z)Z

    .line 1805
    iget-object v0, p0, Lcom/android/server/PowerManagerService$SmartSleepNotificationTask;->this$0:Lcom/android/server/PowerManagerService;

    #getter for: Lcom/android/server/PowerManagerService;->mFaceDetected:Z
    invoke-static {v0}, Lcom/android/server/PowerManagerService;->access$5200(Lcom/android/server/PowerManagerService;)Z

    move-result v0

    if-nez v0, :cond_0

    .line 1806
    iget-object v0, p0, Lcom/android/server/PowerManagerService$SmartSleepNotificationTask;->this$0:Lcom/android/server/PowerManagerService;

    #getter for: Lcom/android/server/PowerManagerService;->mContext:Landroid/content/Context;
    invoke-static {v0}, Lcom/android/server/PowerManagerService;->access$2300(Lcom/android/server/PowerManagerService;)Landroid/content/Context;

    move-result-object v0

    iget-object v1, p0, Lcom/android/server/PowerManagerService$SmartSleepNotificationTask;->this$0:Lcom/android/server/PowerManagerService;

    #getter for: Lcom/android/server/PowerManagerService;->mSmartSleepIntent:Landroid/content/Intent;
    invoke-static {v1}, Lcom/android/server/PowerManagerService;->access$5600(Lcom/android/server/PowerManagerService;)Landroid/content/Intent;

    move-result-object v1

    invoke-virtual {v0, v1}, Landroid/content/Context;->sendBroadcast(Landroid/content/Intent;)V

    .line 1807
    const-string v0, "PowerManagerService"

    const-string v1, "SmartSleepNotificationTask::SmartSleepNotification : sendBroadcast done."

    invoke-static {v0, v1}, Landroid/util/Slog;->d(Ljava/lang/String;Ljava/lang/String;)I

    .line 1810
    :cond_0
    return-void
.end method


text:
<?xml version="1.0" encoding="utf-8"?>

<resources xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
    <string name="proximity_title">"近距离传感器校准"</string>
    <string name="proximity_dlg_message">"请注意感应器20公分距离内不应有遮挡物,且避免阳光照射!"</string>
    <string name="proximity_dlg_title">"校准提示"</string>
    <string name="proximity_success">校准成功.</string>
    <string name="proximity_fail">校准失败.</string>
    <string name="proximity_fail_busy">校准失败.设备忙</string>
    <string name="proximity_dlg_yes">"是"</string>
    <string name="proximity_dlg_no">"否"</string>
    <string name="gsensor_ok">确定</string>
    <string name="gsensor_title">G-Sensor 校准</string>
    <string name="gsensor_calibration">校准</string>
    <string name="gsensor_hint1">请将电话放置在</string>
    <string name="gsensor_hint2">平直表面上</string>
    <string name="gsensor_hint3">正在校准...</string>
    <string name="gsensor_hint4">请勿移动电话</string>
    <string name="gsensor_hint5">校准完成</string>
    <!-- BIRD_TP_SMART_WAKE:wangfei 20131227 begin -->
    <string name="smart_wake">"智能唤醒"</string>
    <!-- BIRD_TP_SMART_WAKE:wangfei 20131227 end -->
    <!-- show direct menu in accessibility,chengting,@20140918,begin-->
    <string name="smart_sensor">智能体感</string>
    <!-- show direct menu in accessibility,chengting,@20140918,end-->
    <!-- add by kelinxi begin 20150320 -->
    <string name="battery_percent">电量百分比</string>
    <!-- add by kelinxi end 20150320 -->
    <!--sim toolkit add by meifangting 20150417 begin -->
    <string name="sim_toolkit">SIM卡应用</string>
    <!--sim toolkit add by meifangting 20150417 end -->

    <string name="memory_system">系统数据</string>
    <string name="cooee_nf_str">本应用免费,是否试用?</string>

    <string name="phone_total_memory_title">机身内存总量</string>
    <string name="phone_system_memory_title">运行内存总量</string>
    <string name="zzz_bird_cpu_model_title">CPU 型号</string>
    <string name="zzz_bird_cpu_frequency_title">CPU 主频</string>
    <string name="zzz_bird_cpu_core_title">CPU 核心</string>
    <string name="zzz_bird_cpu_model_summary">MTK6592</string>
    <string name="zzz_bird_cpu_frequency_summary">四核__1.5GHz</string>
    <string name="zzz_bird_cpu_model_Quad">四核</string>
    <string name="zzz_bird_cpu_model_Octuple">八核</string>

    <string name="bird_hardware_title">硬件参数</string>
    <string name="bird_hardware_model_title">平台硬件芯片</string>
    <string name="bird_hardware_model_summary">MT6752,8核</string>
    <string name="bird_front_camera_title">前摄像头</string>
    <string name="bird_back_camera_title">后摄像头</string>
    <string name="bird_screen_resolution_title">分辨率</string>
    <string name="bird_battery_capability_title">电池容量</string>

    <string name="ali_phone_memory_used_summary"><xliff:g id="VALUE">%s</xliff:g> 已使用</string>
    <!--update by liuzhiling 20160707 begin-->
    <string name="zzz_common_settings">常用设置</string>
    <string name="zzz_complete_settings">全部设置</string>
    <string name="zzz_speech_settings">语音播报设置</string>
    <!--update by liuzhilng 20160707 end -->
    <string name="memory_used_size">已使用容量</string>

    <string name="total_storage_title">手机总容量</string>
    <string name="system_storage_title">系统空间</string>

<!-- BIRD_MULTI_TOUCH, add start by shenzhiwang, 20151009 -->
    <string name="bird_3p_touch_screenshot_title">三指截屏</string>
    <string name="bird_3p_touch_screenshot_summary">三指同时上滑或者下滑,截取屏幕</string>
<!-- BIRD_MULTI_TOUCH, add end by shenzhiwang, 20151009 -->

    <!--BIRD_RENAME_ALI_EXPERIENCE add by qinzhifeng 20151225 begin-->
    <string name="bird_aboutphone_user_experience_program">同意用户体验改进计划</string>
    <!--BIRD_RENAME_ALI_EXPERIENCE add by qinzhifeng 20151225 end-->
	<!-- add by caizhaohui for BIRD_SHARE_SDCARD_SHOW_INTERNAL_STORAGE 20160301 -->
	<string name="bird_memory_internal_sdcard_usage">内部存储</string>
	<!-- add by caizhaohui for BIRD_SHARE_SDCARD_SHOW_INTERNAL_STORAGE 20160301 -->
	<!--add by lichengfeng for fix TASK #7676 Silent model call remainder @20160321 begin -->
	<string name="silent_model_call_remainder_enable_title">"静音模式来电提醒"</string>
	<string name="silent_model_call_remainder_enable_summary">"三分钟内同一号码第二次来电不会被静音"</string>
	<!--add by lichengfeng for fix TASK #7676 Silent model call remainder @20160321 end -->

    <string name="roam_reboot">请重启手机!</string>
    <string name="roam_select_error">请选择RAM和ROM!</string>
    <string name="roam_model_error">请输入正确的产品型号!</string>
    <!--BIRD_DOOV_BREATHLED task 7688 add by qinzhifeng 20160425 begin-->
    <string name="bird_breath_led_time_title">呼吸灯仅提示15分钟</string>
    <string name="bird_breath_led_time_summary">低电量/充电状态呼吸灯,不受该开关影响</string>
    <!--BIRD_DOOV_BREATHLED task 7688 add by qinzhifeng 20160425 end-->

    <!--[BIRD] [BIRD_PRESS_FP_SUPPORT] lichengfeng @20160425 for fps1196 begin-->
    <string name="bird_goodx_finger_title">指纹识别</string>
    <!--[BIRD] [BIRD_PRESS_FP_SUPPORT] lichengfeng @20160425 for fps1196 end-->

	<!--add by lichengfeng add microarray fingerprint sensor calibration @20160503 begin-->
	<string name="bird_fingerprint_calibration_titile">指纹校准</string>
	<string name="bird_fingerprint_reset_titile">重置指纹</string>
	<string name="bird_fingerprint_reset_dialog_content">确定重置指纹?</string>
	<string name="bird_fingerprint_calibration_dialog_attention">指纹校准中...\n请勿触摸指纹器!</string>
	<string name="bird_fingerprint_reset_dialog_attention">重置指纹中...\n请勿触摸指纹器!</string>

	<string name="fingerprint_reset_succeeded">重置指纹成功!</string>
	<string name="fingerprint_reset_failed">重置指纹失败!</string>
	<!--add by lichengfeng add microarray fingerprint sensor calibration @20160503 end-->
	<!--BIRD_POWER_SAVING add by ludaxu 20160618 begin-->
    <string name="powersaving_settings">省电</string>
    <string name="keywords_powersaving">"省电 电量"</string>

    <string name="powersaving_wifi_title">Wifi</string>
    <string name="powersaving_wifi_summary">省电时关闭Wifi</string>
    <string name="powersaving_autobrightness_title">自动亮度</string>
    <string name="powersaving_autobrightness_summary">省电时关闭自动亮度</string>
    <string name="powersaving_bluetooth_title">蓝牙</string>
    <string name="powersaving_bluetooth_summary">省电时关闭蓝牙</string>
    <string name="powersaving_data_connection_title">数据连接</string>
    <string name="powersaving_data_connection_summary">省电时关闭数据连接</string>
    <string name="powersaving_gps_title">位置信息</string>
    <string name="powersaving_gps_summary">省电时关闭位置信息</string>
    <string name="powersaving_battery_saver_title">节电助手</string>
    <string name="powersaving_battery_saver_summary">省电时打开节电助手,否则关闭</string>
    <string name="power_saving_category">设置</string>
    <!--BIRD_POWER_SAVING add by ludaxu 20160618 end-->

    <!-- BIRD_A200_CUSTOM add by qinzhifeng 20160415 begin -->
    <string name="arrange_show_settings">查看方式</string>
    <string name="arrange_show_grid">网格视图</string>
    <string name="arrange_show_list">列表视图</string>
    <!-- BIRD_A200_CUSTOM add by qinzhifeng 20160415 end -->
	 <!--add by liuzhiling for Smartstay-->
	     <string name="ic_settings_smart_stay">视频眼球控制</string>
<!-- @{ BIRD_SYSTEM_SPACE, add by shenzhiwang, @20160707 -->
    <string name="storage_detail_systemspace" >"系统空间"</string>
<!-- @} -->
    <!--sim toolkit add by meifangting 20150417 begin -->
    <string name="sim_toolkit">SIM卡应用</string>
    <!--sim toolkit add by meifangting 20150417 end -->

    <!-- bird add by liuzhenting 20160815 begin -->
    <string name="phone_total_title">总容量</string>
    <string name="new_storage_settings">存储</string>
    <!-- bird add by liuzhenting 20160815 end -->
</resources>