text:
package com.keybackup.main.todo.adapter.viewholder;

import android.content.Context;
import android.view.View;
import android.widget.Button;
import android.widget.ImageView;
import android.widget.TextView;

import com.keybackup.R;
import com.keybackup.main.todo.adapter.item.TodoContactItem;

import butterknife.BindView;

public class ContactViewHolder extends BaseViewHolder<TodoContactItem> {
    @BindView(R.id.todo_item_contact_headline)
    TextView mHeadline;
    @BindView(R.id.todo_item_contact_subtitle)
    TextView mSubtitle;
    @BindView(R.id.todo_item_contact_image)
    ImageView mContactImage;
    @BindView(R.id.todo_item_contact_positive)
    Button mPositive;
    @BindView(R.id.todo_item_contact_show)
    Button mShow;
    @BindView(R.id.todo_item_contact_more)
    Button mMore;

    public ContactViewHolder(View itemView) {
        super(itemView);
    }

    @Override
    public void setDataOnView(Context context, int position, TodoContactItem item) {
        mHeadline.setText(item.getHeadline());
        mSubtitle.setText(item.getSubtitle());

        item.setContactImage(context, mContactImage);

        if (item.getPositiveButtonListener() != null) {
            mPositive.setVisibility(View.VISIBLE);
            mPositive.setOnClickListener(item.getPositiveButtonListener());
        } else {
            mPositive.setVisibility(View.GONE);
        }

        mShow.setText(item.getShowButtonTitle());
        mShow.setOnClickListener(item.getShowButtonListener());

        mMore.setText(item.getMoreButtonTitle());
        mMore.setOnClickListener(item.getMoreButtonListener());
    }
}


text:
<?php
namespace App\Controller;

use App\Lib\CakeboxCheck;
use App\Lib\CakeboxUtility;
use Cake\Log\Log;

class ApplicationsController extends AppController
{

    /**
     * Index page
     *
     * @return void
     */
    public function index()
    {
        $data = [
            'apps' => $this->Info->getApps()
        ];
        $this->set('data', $data);
    }
}

redpajama_set_name: RedPajamaGithub


text:
import {identifierModuleUrl, identifierName} from '../compile_metadata';
import {isBlank, isPresent} from '../facade/lang';

import {EmitterVisitorContext, OutputEmitter} from './abstract_emitter';
import {AbstractJsEmitterVisitor} from './abstract_js_emitter';
import * as o from './output_ast';
import {ImportResolver} from './path_util';

export class JavaScriptEmitter implements OutputEmitter {
  constructor(private _importGenerator: ImportResolver) {}
  emitStatements(moduleUrl: string, stmts: o.Statement[], exportedVars: string[]): string {
    const converter = new JsEmitterVisitor(moduleUrl);
    const ctx = EmitterVisitorContext.createRoot(exportedVars);
    converter.visitAllStatements(stmts, ctx);
    const srcParts: string[] = [];
    converter.importsWithPrefixes.forEach((prefix, importedModuleUrl) => {
      // Note: can't write the real word for import as it screws up system.js auto detection...
      srcParts.push(
          `var ${prefix} = req` +
          `uire('${this._importGenerator.fileNameToModuleName(importedModuleUrl, moduleUrl)}');`);
    });
    srcParts.push(ctx.toSource());
    return srcParts.join('\n');
  }
}

class JsEmitterVisitor extends AbstractJsEmitterVisitor {
  importsWithPrefixes = new Map<string, string>();

  constructor(private _moduleUrl: string) { super(); }

  visitExternalExpr(ast: o.ExternalExpr, ctx: EmitterVisitorContext): any {
    const name = identifierName(ast.value);
    const moduleUrl = identifierModuleUrl(ast.value);
    if (isBlank(name)) {
      console.error('>>>', ast.value);
      throw new Error(`Internal error: unknown identifier ${ast.value}`);
    }
    if (isPresent(moduleUrl) && moduleUrl != this._moduleUrl) {
      let prefix = this.importsWithPrefixes.get(moduleUrl);
      if (isBlank(prefix)) {
        prefix = `import${this.importsWithPrefixes.size}`;
        this.importsWithPrefixes.set(moduleUrl, prefix);
      }
      ctx.print(`${prefix}.`);
    }
    ctx.print(name);
    return null;
  }
  visitDeclareVarStmt(stmt: o.DeclareVarStmt, ctx: EmitterVisitorContext): any {
    super.visitDeclareVarStmt(stmt, ctx);
    if (ctx.isExportedVar(stmt.name)) {
      ctx.println(exportVar(stmt.name));
    }
    return null;
  }
  visitDeclareFunctionStmt(stmt: o.DeclareFunctionStmt, ctx: EmitterVisitorContext): any {
    super.visitDeclareFunctionStmt(stmt, ctx);
    if (ctx.isExportedVar(stmt.name)) {
      ctx.println(exportVar(stmt.name));
    }
    return null;
  }
  visitDeclareClassStmt(stmt: o.ClassStmt, ctx: EmitterVisitorContext): any {
    super.visitDeclareClassStmt(stmt, ctx);
    if (ctx.isExportedVar(stmt.name)) {
      ctx.println(exportVar(stmt.name));
    }
    return null;
  }
}

function exportVar(varName: string): string {
  return `Object.defineProperty(exports, '${varName}', { get: function() { return ${varName}; }});`;
}


text:
package tools

import (
	"bytes"
	"encoding/json"
	"errors"
	"fmt"
	"os"
	"path/filepath"
	"strings"
	"text/template"

	"github.com/FZambia/viper-lite"
	"github.com/google/uuid"
)

// pathExists returns whether the given file or directory exists or not
func pathExists(path string) (bool, error) {
	_, err := os.Stat(path)
	if err == nil {
		return true, nil
	}
	if os.IsNotExist(err) {
		return false, nil
	}
	return false, err
}

var jsonConfigTemplate = `{
  "token_hmac_secret_key": "{{.TokenSecret}}",
  "admin_password": "{{.AdminPassword}}",
  "admin_secret": "{{.AdminSecret}}",
  "api_key": "{{.APIKey}}",
  "allowed_origins": []
}
`

var tomlConfigTemplate = `token_hmac_secret_key = "{{.TokenSecret}}"
admin_password = "{{.AdminPassword}}"
admin_secret = "{{.AdminSecret}}"
api_key = "{{.APIKey}}"
allowed_origins = []
`

var yamlConfigTemplate = `token_hmac_secret_key: {{.TokenSecret}}
admin_password: {{.AdminPassword}}
admin_secret: {{.AdminSecret}}
api_key: {{.APIKey}}
allowed_origins: []
`

// GenerateConfig generates configuration file at provided path.
func GenerateConfig(f string) error {
	exists, err := pathExists(f)
	if err != nil {
		return err
	}
	if exists {
		return errors.New("output config file already exists: " + f)
	}
	ext := filepath.Ext(f)

	if len(ext) > 1 {
		ext = ext[1:]
	}

	supportedExtensions := []string{"json", "toml", "yaml", "yml"}

	var t *template.Template

	switch ext {
	case "json":
		t, err = template.New("config").Parse(jsonConfigTemplate)
	case "toml":
		t, err = template.New("config").Parse(tomlConfigTemplate)
	case "yaml", "yml":
		t, err = template.New("config").Parse(yamlConfigTemplate)
	default:
		return errors.New("output config file must have one of supported extensions: " + strings.Join(supportedExtensions, ", "))
	}
	if err != nil {
		return err
	}

	var output bytes.Buffer
	_ = t.Execute(&output, struct {
		TokenSecret   string
		AdminPassword string
		AdminSecret   string
		APIKey        string
	}{
		uuid.New().String(),
		uuid.New().String(),
		uuid.New().String(),
		uuid.New().String(),
	})

	return os.WriteFile(f, output.Bytes(), 0644)
}

// ErrorMessageFromConfigError tries building a more human-friendly error
// from a configuration error. At the moment we can additionally extract
// JSON syntax error line and column.
// Related issue: https://github.com/golang/go/issues/43513.
func ErrorMessageFromConfigError(err error, configPath string) string {
	var configParseError viper.ConfigParseError
	if ok := errors.As(err, &configParseError); ok {
		var syntaxErr *json.SyntaxError
		if ok := errors.As(configParseError.Err, &syntaxErr); ok {
			if content, readFileErr := os.ReadFile(configPath); readFileErr == nil {
				offset := int(syntaxErr.Offset)
				line := 1 + bytes.Count(content[:offset], []byte("\n"))
				column := offset - (bytes.LastIndex(content[:offset], []byte("\n")) + len("\n"))
				return fmt.Sprintf(
					"JSON syntax error around line %d, column %d: %s",
					line, column, syntaxErr.Error(),
				)
			}
		}
	}
	// Fallback if we can't construct a better one.
	return fmt.Sprintf("configuration error: %v", err)
}


text:
DOSBOX_EXAMPLE_DIR=${NACL_SRC}/ports/dosbox-0.74
EXECUTABLES=src/dosbox${NACL_EXEEXT}
MAKE_TARGETS="AR=${NACLAR}"

ConfigureStep() {
  SetupCrossEnvironment

  export LIBS="-L${NACLPORTS_LIBDIR} \
      -lm \
      -lpng \
      -lz"

  # --as-needed is needed during confgiure otherwise a lot of tests
  # will fail to link undefined 'SDLmain'
  export LDFLAGS="${NACLPORTS_LDFLAGS} -Wl,--as-needed"

  local conf_host=${NACL_CROSS_PREFIX}
  if [ ${NACL_ARCH} = "pnacl" ]; then
    # The PNaCl tools use "pnacl-" as the prefix, but config.sub
    # does not know about "pnacl".  It only knows about "le32-nacl".
    # Unfortunately, most of the config.subs here are so old that
    # it doesn't know about that "le32" either.  So we just say "nacl".
    conf_host="nacl"
  fi

  CONFIG_FLAGS="--host=${conf_host} \
      --prefix=${PREFIX} \
      --with-sdl-prefix=${NACL_TOOLCHAIN_ROOT} \
      --disable-shared \
      --with-sdl-exec-prefix=${NACL_TOOLCHAIN_ROOT}"

  # TODO(clchiou): Sadly we cannot export LIBS and LDFLAGS to configure, which
  # would fail due to multiple definitions of main and missing pp::CreateModule.
  # So we patch auto-generated Makefile after running configure.
  export PPAPI_LIBS=""
  export LIBS="-lnacl_io"
  LogExecute ${SRC_DIR}/configure ${CONFIG_FLAGS}

  SED_PREPEND_LIBS="s|^LIBS = \(.*$\)|LIBS = ${PPAPI_LIBS} \1|"
  SED_REPLACE_LDFLAGS="s|^LDFLAGS = .*$|LDFLAGS = ${NACLPORTS_LDFLAGS}|"

  find . -name Makefile -exec cp {} {}.bak \; \
      -exec sed -i.bak "${SED_PREPEND_LIBS}" {} \; \
      -exec sed -i.bak "${SED_REPLACE_LDFLAGS}" {} \;
}

InstallStep(){
  MakeDir ${PUBLISH_DIR}
  LogExecute install ${START_DIR}/dosbox.html ${PUBLISH_DIR}
  LogExecute install src/dosbox${NACL_EXEEXT} \
    ${PUBLISH_DIR}/dosbox_${NACL_ARCH}${NACL_EXEEXT}
  local CREATE_NMF="${NACL_SDK_ROOT}/tools/create_nmf.py"
  LogExecute ${CREATE_NMF} -s ${PUBLISH_DIR} ${PUBLISH_DIR}/dosbox_*${NACL_EXEEXT} -o ${PUBLISH_DIR}/dosbox.nmf

  if [ "${NACL_ARCH}" = "pnacl" ]; then
    sed -i.bak 's/x-nacl/x-pnacl/' ${PUBLISH_DIR}/dosbox.html
  fi
}


text:
[![Build Status](https://img.shields.io/travis/erento/angular-api-client.svg?style=flat-square)](https://travis-ci.org/erento/angular-api-client)
![License](https://img.shields.io/github/license/erento/angular-api-client.svg?style=flat-square)

Easy to use API client based on the [Command pattern](https://en.wikipedia.org/wiki/Command_pattern) for [Angular framework](https://github.com/angular/angular).

This module works with Angular 2.4 and higher.

## Installation
```sh
npm install --save ng2-api-client
```

## Quick start
Import __API client module__ to your `app.module.ts`
```ts
// ...
import {HttpClient, HttpClientModule} from '@angular/common/http';
import {ApiClientHttpClient, ApiClientModule} from 'ng2-api-client';
import {HttpClient} from 'ng2-api-client';
// ...

@NgModule({
  declarations: [AppComponent],
  imports: [
    // ...
    HttpClientModule,
    // ...
    ApiClientModule.forRoot({httpClient: {
        provide: ApiClientHttpClient,
        useClass: HttpClient,
    }}),
  ],
  bootstrap: [AppComponent]
})
export class AppModule {}
```

Inject it to your class (could be Component, Service, etc...)
- `app.component.ts`:
  ```ts
  import {Component, OnInit} from '@angular/core';
  import {ApiClient} from 'ng2-api-client';

  @Component({
    selector: 'app-root',
    templateUrl: './app.component.html',
  })
  export class AppComponent implements OnInit {
    constructor(private readonly apiClient: ApiClient) {}

    ngOnInit() {
      this.apiClient
        .executeRequest<User>(new FetchUserCommand('u-u-i-d'))
        .subscribe((user: User) => {
          console.log('My user data is: ', user);
        });
    }
  }
  ```

- `fetch-user.command.ts`:
  ```ts
  import {ApiBaseCommand, RequestMethod, UrlPathParameters} from 'ng2-api-client';

  export class FetchUserCommand implements ApiBaseCommand {
    public headers: Headers = {'X-Forwarded-For': 'proxy1'};
    public method: RequestMethod = RequestMethod.Get;
    public url: string = '/api/user/:uuid';
    public urlPathParameters: UrlPathParameters;

    constructor (userUuid: string) {
      this.urlPathParameters = {uuid: userUuid};
    }
  }
  ```

## How to retry an request?
`ApiClient.executeRequest` has a second parameter where you can pass an amount
of required retries and the ApiClient will take care of it.

## Documentation

### Command
#### Required properties:

- __method__

  The property method defines the HTTP method. It requires the string enum value of `RequestMethod`.

- __url__

  The url path without a scheme. Url can include wildcards starting with `:`.

  Examples: `/api/user/:id` or `/api/user/:name/:lastname` ...

  If the url includes the wildcard it will be validated with an input defined in the property
  `urlPathParameters` and replaced by the provided value.

#### Optional properties:

- __urlPathParameters__

  This value is required when the wildcard is included in the url.

  Example: `{role: 'admin'}` with the url: `/user/:role` will generate: `/user/admin`

- __queryParameters__

  An object defining query parameters.

  _Examples:_

   `{search: 'neymar', team: 'psg'}` will generate: `?search=neymar&team=psg`

- __headers__

  Used to set the headers of your request.

- __body__

  Used to set the body of your request.

- __withCredential__

  Boolean value that indicates whether or not requests should be made using credentials
  such as cookies, authorization headers or TLS client certificates.

  Default value: `false`.

- __responseType__

  Used to set the response type of your request. Can be one of:
  `'arraybuffer' | 'blob' | 'json' | 'text'`.

  Default value: `json`.

- __reportProgress__

  Boolean value that indicates whether or not requests should report about progress.

  Default value: `false`.

## Testing
Run `npm test` to execute tests.

## License
The MIT License (see the [LICENSE](LICENSE.md) file for the full text)

## Publishing
Always run `npm run build` before.

To publish a package run: `npm publish ./dist/lib`

If you want only to run it locally use `npm pack` as follows:
1. `npm pack ./dist/lib`
2. In your project `npm i ../PATH_TO_TAR/ng2-api-client-X.X.X.tgz` where X.X.X is the current version of a library.


text:
// Copyright (c) Microsoft Corporation. All rights reserved.
// Licensed under the MIT License.
// Code generated by Microsoft (R) AutoRest Code Generator.

package com.azure.resourcemanager.mobilenetwork.fluent.models;

import com.azure.core.annotation.Fluent;
import com.azure.core.management.SubResource;
import com.azure.resourcemanager.mobilenetwork.models.ProvisioningState;
import com.fasterxml.jackson.annotation.JsonProperty;
import java.util.List;

/** Site properties. */
@Fluent
public final class SitePropertiesFormat {
    /*
     * The provisioning state of the site resource.
     */
    @JsonProperty(value = "provisioningState", access = JsonProperty.Access.WRITE_ONLY)
    private ProvisioningState provisioningState;

    /*
     * An array of IDs of the network functions deployed on the site,
     * maintained by the user.
     */
    @JsonProperty(value = "networkFunctions")
    private List<SubResource> networkFunctions;

    /**
     * Get the provisioningState property: The provisioning state of the site resource.
     *
     * @return the provisioningState value.
     */
    public ProvisioningState provisioningState() {
        return this.provisioningState;
    }

    /**
     * Get the networkFunctions property: An array of IDs of the network functions deployed on the site, maintained by
     * the user.
     *
     * @return the networkFunctions value.
     */
    public List<SubResource> networkFunctions() {
        return this.networkFunctions;
    }

    /**
     * Set the networkFunctions property: An array of IDs of the network functions deployed on the site, maintained by
     * the user.
     *
     * @param networkFunctions the networkFunctions value to set.
     * @return the SitePropertiesFormat object itself.
     */
    public SitePropertiesFormat withNetworkFunctions(List<SubResource> networkFunctions) {
        this.networkFunctions = networkFunctions;
        return this;
    }

    /**
     * Validates the instance.
     *
     * @throws IllegalArgumentException thrown if the instance is not valid.
     */
    public void validate() {
    }
}


text:
#ifndef _BOARD_H_
#define _BOARD_H_

#include "sdkconfig.h"
#include "driver/gpio.h"
#include "esp_ble_mesh_defs.h"

#ifdef CONFIG_BLE_MESH_ESP_WROOM_32
#define LED_R GPIO_NUM_25
#define LED_G GPIO_NUM_26
#define LED_B GPIO_NUM_27
#elif defined(CONFIG_BLE_MESH_ESP_WROVER)
#define LED_R GPIO_NUM_0
#define LED_G GPIO_NUM_2
#define LED_B GPIO_NUM_4
#elif defined(CONFIG_BLE_MESH_ESP32C3_DEV)
#define LED_R GPIO_NUM_8
#define LED_G GPIO_NUM_8
#define LED_B GPIO_NUM_8
#elif defined(CONFIG_BLE_MESH_ESP32S3_DEV)
#define LED_R GPIO_NUM_47
#define LED_G GPIO_NUM_47
#define LED_B GPIO_NUM_47
#endif

struct _led_state {
    uint8_t current;
    uint8_t previous;
    uint8_t pin;
    char *name;
};

void board_output_number(esp_ble_mesh_output_action_t action, uint32_t number);

void board_prov_complete(void);

void board_led_operation(uint8_t pin, uint8_t onoff);

esp_err_t board_init(void);

#endif


text:
var ItineraryLegs = require('./itinerary-legs')
var utils = require('./utils')

var Backbone = require('backbone')
var moment = require('moment')

var Itinerary = Backbone.Model.extend({
  initialize: function (opts) {
    this.set('legs', this.processLegs())
  },

  defaults: {
    duration: null,
    startTime: null,
    endTime: null,
    walkTime: null,
    transitTime: null,
    elevationLost: null,
    locationLon: null,
    elevationGained: null,
    transfers: null,
    fare: [],
    legs: []
  },

  processLegs: function () {
    var processedLegs = []
    for (var i = 0; i < this.get('legs').length; i++) {
      var leg = this.get('legs')[i]

      // convert the encoded poly line to a latlng array
      leg.geomPoints = utils.decodePolyline(leg.legGeometry.points)

      // check for interlined-leg merge case (enabled via flag in config.js)
      if (i > 0) var prevLeg = this.get('legs')[i - 1]
      if (window.OTP_config.mergeInterlinedRouteLegs && leg.interlineWithPreviousLeg && prevLeg &&
        prevLeg.agencyId === leg.agencyId && prevLeg.routeId === leg.routeId) {
        // merge this leg with the previous leg
        leg.startTime = prevLeg.startTime
        leg.duration = (leg.endTime - leg.startTime) / 1000
        leg.distance += prevLeg.distance
        leg.from = prevLeg.from
        leg.headsign = prevLeg.headsign
        leg.geomPoints = prevLeg.geomPoints.concat(leg.geomPoints)

        // remove prevLeg from the processed legs array
        processedLegs.pop()
      }

      processedLegs.push(leg)
    }

    return new ItineraryLegs(processedLegs)
  },

  /* returns [[south, west], [north, east]] */

  getBoundsArray: function () {
    var legs = this.get('legs')
    var start = legs.at(0).get('from')
    var end = legs.at(legs.length - 1).get('to')
    return [
      [Math.min(start.lat, end.lat), Math.min(start.lon, end.lon)],
      [Math.max(start.lat, end.lat), Math.max(start.lon, end.lon)]
    ]
  },

  /* returns the 'full' duration of a trip, including the duration of the
   * trip itself plus any time between the trip and the requested departure/
   * arrival time. Requires the request model as a parameter.
   */

  getFullDuration: function (request, offset) {
    var queryDateTime = moment(request.get('date') + ' ' + request.get('time'), 'MM-DD-YYYY h:mma')
    var startTime = moment(this.get('startTime'))
    var endTime = moment(this.get('endTime'))

    if (offset) {
      startTime = startTime.add('hours', offset)
      endTime = endTime.add('hours', offset)
    }

    if (request.get('arriveBy') === 'true' || request.get('arriveBy') ===
      true) {
      return queryDateTime - startTime
    }
    return endTime - queryDateTime
  }

})

module.exports = Itinerary


text:
#pragma once
/**

Column Major Vector (4x1 Matrix) (NOT 1x4)

*/
#include <cassert>
#include <algorithm>
#include <immintrin.h>

class IEVector3;
class IEVector4
{
	private:
		static constexpr int	VectorW = 4;
		union
		{
			struct				{float x, y, z, w;};
			float				v[VectorW];
		};

	protected:

	public:
		// Constructors & Destructor
		constexpr				IEVector4();
		constexpr				IEVector4(float xyzw);
		constexpr				IEVector4(float x, float y, float z, float w);
		constexpr				IEVector4(const float v[VectorW]);
								IEVector4(const IEVector3&);
								IEVector4(const IEVector3&, float w);
								//IEVector4(const IEVector4&) = default;
								//~IEVector4() = default;

		// Statics
		static const IEVector4	ZeroVector;
		static const IEVector4	XAxis;
		static const IEVector4	YAxis;
		static const IEVector4	ZAxis;

		// Accessors
		float					getX() const;
		float					getY() const;
		float					getZ() const;
		float					getW() const;
		const float*			getData() const;

		// Mutators
		void					setX(float);
		void					setY(float);
		void					setZ(float);
		void					setW(float);
		void					setData(const float[VectorW]);
		IEVector4&				operator=(const IEVector4&) = default;
		float&					operator[](int);
		const float&			operator[](int) const;

		// Modify
		void					operator+=(const IEVector4&);
		void					operator-=(const IEVector4&);
		void					operator*=(const IEVector4&);
		void					operator*=(float);
		void					operator/=(const IEVector4&);
		void					operator/=(float);

		IEVector4				operator+(const IEVector4&) const;
		IEVector4				operator-(const IEVector4&) const;
		IEVector4				operator-() const;
		IEVector4				operator*(const IEVector4&) const;
		IEVector4				operator*(float) const;
		IEVector4				operator/(const IEVector4&) const;
		IEVector4				operator/(float) const;

		// Utilty
		float					DotProduct(const IEVector4&) const;
		float					Length() const;
		float					LengthSqr() const;
		IEVector4				Normalize() const;
		IEVector4&				NormalizeSelf();
		IEVector4				Clamp(const IEVector4&, const IEVector4&) const;
		IEVector4				Clamp(float min, float max) const;
		IEVector4&				ClampSelf(const IEVector4& min, const IEVector4& max);
		IEVector4&				ClampSelf(float min, float max);

		// Logic
		bool					operator==(const IEVector4&) const;
		bool					operator!=(const IEVector4&) const;
};

// Requirements of Vector4
static_assert(std::is_literal_type<IEVector4>::value == true, "IEVector4 has to be literal type");
static_assert(std::is_trivially_copyable<IEVector4>::value == true, "IEVector4 has to be trivially copyable");
static_assert(std::is_polymorphic<IEVector4>::value == false, "IEVector4 should not be polymorphic");
static_assert(sizeof(IEVector4) == sizeof(float) * 4, "IEVector4 size is not 16 bytes");

// Left Scalar operators
IEVector4 operator*(float, const IEVector4&);

// Inlines
inline float IEVector4::getX() const {return x;}
inline float IEVector4::getY() const { return y; }
inline float IEVector4::getZ() const { return z; }
inline float IEVector4::getW() const { return w; }
inline const float* IEVector4::getData() const { return v; }

inline void IEVector4::setX(float t) { x = t; }
inline void IEVector4::setY(float t) { y = t; }
inline void IEVector4::setZ(float t) { z = t; }
inline void IEVector4::setW(float t) { w = t; }
inline void IEVector4::setData(const float data[]) { std::copy(data, data + 4, v); }

inline float& IEVector4::operator[](int index)
{
	assert(index >= 0 && index < VectorW);
	return v[index];
}

inline const float& IEVector4::operator[](int index) const
{
	assert(index >= 0 && index < VectorW);
	return v[index];
}

constexpr IEVector4::IEVector4()
	: x(0.0f)
	, y(0.0f)
	, z(0.0f)
	, w(0.0f)
{}

constexpr IEVector4::IEVector4(float xyzw)
	: x(xyzw)
	, y(xyzw)
	, z(xyzw)
	, w(xyzw)
{}

constexpr IEVector4::IEVector4(float xx, float yy, float zz, float ww)
	: x(xx)
	, y(yy)
	, z(zz)
	, w(ww)
{}

constexpr IEVector4::IEVector4(const float v[])
	: x(v[0])
	, y(v[1])
	, z(v[2])
	, w(v[3])
{}


text:
package com.google.gerrit.server.query.change;

import com.google.gerrit.reviewdb.client.Account;
import com.google.gerrit.server.index.change.ChangeField;

public class HasDraftByPredicate extends ChangeIndexPredicate {
  protected final Account.Id accountId;

  public HasDraftByPredicate(Account.Id accountId) {
    super(ChangeField.DRAFTBY, accountId.toString());
    this.accountId = accountId;
  }

  @Override
  public boolean match(ChangeData cd) {
    return cd.draftsByUser().contains(accountId);
  }

  @Override
  public int getCost() {
    return 1;
  }
}


text:
package de.simu.decomap.component.polling.impl;

import java.io.BufferedReader;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;
import java.util.ArrayList;
import java.util.HashMap;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import de.simu.decomap.component.polling.FilePollingThread;
import de.simu.decomap.config.interfaces.GeneralConfig;

public class RadiusIpFolderPollingThread extends FilePollingThread {

	private final Logger logger = LoggerFactory.getLogger(this.getClass());

	private File detailsFile;
	private long detailsFileLastModified;
	private int detailsFileLastEntryNumber = 0;
	private boolean detailsFileChangesFound = false;

	private File replayFile;
	private long replayFileLastModified;
	private int replayFileLastEntryNumber = 0;
	private boolean replayFileChangesFound = false;

	/**
	 * Constructor
	 *
	 * @param folderPath
	 * 		Path of folder to monitor
	 * @param sleepTime
	 * 		Sleep Time between scans
	 */
	public RadiusIpFolderPollingThread(String folderPath, int sleepTime) {
		filePath = folderPath;
		this.sleepTime = sleepTime;
		isFirstStart = true;

		file = new File(filePath);
		if (!file.isDirectory()) {
			logger.warn("WARNING! File is not a valid folder!");
		}

		getLatestModified();
	}

	@Override
	public void run() {

		while (running) {
			// if (!pausing) {
			try {
				logger.info("Poll Rottation!");

				if (detailsFile != null && detailsFile.exists()) {
					if (detailsFileLastModified < detailsFile.lastModified()) {
						detailsFileChangesFound = true;
					}
				} else {
					logger.debug("File null or not found");
				}

				if (replayFile != null && replayFile.exists()) {
					if (replayFileLastModified < replayFile.lastModified()) {
						replayFileChangesFound = true;
					}
				} else {
					logger.debug("File null or not found");
				}

				if (replayFileChangesFound || detailsFileChangesFound) {
					logger.info("Changes found! Start reading!");
					putIntoMappingQueue(readFile());
				} else {
					logger.info("No changes in monitored files!");
				}

				if (!getLatestModified()) {
					Thread.sleep(sleepTime);
				}

			} catch (Exception e) {
				logger.error("Error while runnning!", e);
				running = false;
			}
			// }
		}

	}

	@Override
	protected ArrayList<HashMap<String, String>> readFile() {
		logger.info("Start reading file: " + file.getAbsolutePath());

		int newEntryNumber = 1;
		int currentCycleLineNumber = 0;

		ArrayList<HashMap<String, String>> result = new ArrayList<HashMap<String, String>>();
		HashMap<String, String> tempEventData = new HashMap<String, String>();

		BufferedReader logReader = null;
		String[] resultDetail = null;
		String line = null;

		try {
			// Reading DetailsFile
			if (detailsFileChangesFound) {
				detailsFileChangesFound = false;
				logger.info("Start reading file: "
						+ detailsFile.getAbsolutePath());
				logReader = new BufferedReader(new FileReader(detailsFile), 1);
				resultDetail = parseDetialInSingleLine(logReader);

				for (int j = 0; j < resultDetail.length; j++) {
					currentCycleLineNumber++;
					if (isFirstStart) {
						detailsFileLastEntryNumber++;
					} else if (currentCycleLineNumber > detailsFileLastEntryNumber) {
						if (logger.isDebugEnabled()) {
							logger.debug("Reading line "
									+ currentCycleLineNumber + ": " + line);
						}
						tempEventData.put(String.valueOf(newEntryNumber),
								resultDetail[j]);
						newEntryNumber++;
					}
				}
				detailsFileLastEntryNumber = currentCycleLineNumber;

				logReader.close();
			}

			// Reading replayFile
			if (replayFileChangesFound) {
				replayFileChangesFound = false;
				currentCycleLineNumber = 0;

				logger.info("Start reading file: "
						+ replayFile.getAbsolutePath());
				logReader = new BufferedReader(new FileReader(replayFile), 1);
				resultDetail = parseDetialInSingleLine(logReader);

				for (int j = 0; j < resultDetail.length; j++) {
					currentCycleLineNumber++;
					if (isFirstStart) {
						replayFileLastEntryNumber++;
					} else if (currentCycleLineNumber > replayFileLastEntryNumber) {
						if (logger.isDebugEnabled()) {
							logger.debug("Reading line "
									+ currentCycleLineNumber + ": " + line);
						}
						tempEventData.put(String.valueOf(newEntryNumber),
								resultDetail[j]);
						newEntryNumber++;
					}
				}
				replayFileLastEntryNumber = currentCycleLineNumber;

				logReader.close();
			}

			if (isFirstStart) {
				// first cycle finished
				isFirstStart = false;
			}

		} catch (FileNotFoundException ex) {
			logger.error("could not find  logfile.", ex);
			running = false;
		} catch (IOException ex) {
			logger.error("I/O error while reading logfile", ex);
			running = false;
		} catch (NullPointerException e) {
			logger.error("Nullpointer!", e);
			running = false;
		}
		result.add(tempEventData);
		return result;
	}

	/**
	 * Parse one entry into one line
	 *
	 * @param msg
	 *            reader to read from
	 * @return single line
	 * @throws IOException
	 */
	public String[] parseDetialInSingleLine(BufferedReader msg)
			throws IOException {
		String line = null;
		String temp = "";

		ArrayList<String> tempArray = new ArrayList<String>();
		while ((line = msg.readLine()) != null) {
			if (!line.equalsIgnoreCase("")) {
				temp += line + ",";
			} else if (temp != null) {
				tempArray.add(temp);
				temp = "";
			}
		}
		String result[] = new String[tempArray.size()];
		for (int i = 0; i < tempArray.size(); i++) {
			result[i] = tempArray.get(i);
		}

		return result;
	}

	/**
	 * Checks if there is a change in the folder and setting the newest file
	 * @return Is there a new modified file
	 */
	private boolean getLatestModified() {
		boolean change = false;
		if (file.isDirectory()) {
			if (lastModified < file.lastModified()) {
				logger.debug("Search in " + file.getAbsolutePath()
						+ " for newst files");

				File[] content = file.listFiles();

				for (int j = 0; j < content.length; j++) {
					if (content[j].getName().startsWith("reply-detail-")
							&& (replayFile == null || replayFile.lastModified() < content[j]
									.lastModified())) {
						replayFile = content[j];
						replayFileLastEntryNumber = 0;
						replayFileLastModified = replayFile.lastModified();
						replayFileChangesFound = true;
						change = true;
					} else if (content[j].getName().startsWith("detail-")
							&& (detailsFile == null || detailsFile
									.lastModified() < content[j].lastModified())) {
						detailsFile = content[j];
						detailsFileLastEntryNumber = 0;
						detailsFileLastModified = detailsFile.lastModified();
						detailsFileChangesFound = true;
						change = true;
					}
				}
				lastModified = file.lastModified();
			} else {
				logger.info("No changes found in " + file.getAbsolutePath());
			}
		} else {
			logger.warn("WARNING! File is not a valid folder!");
		}
		return change;
	}

	@Override
	@Deprecated
	/**
	 * Does nothing!
	 */
	public void init(GeneralConfig mainConfig) {
		// DO NOTHING!!!
	}

}


text:
namespace Microsoft.Azure.Management.Security.Models
{
    using Newtonsoft.Json;
    using System.Linq;

    /// <summary>
    /// The Log Analytics Workspace to which event data will be exported.
    /// Security alerts data will reside in the 'SecurityAlert' table and the
    /// assessments data will reside in the 'SecurityRecommendation' table
    /// (under the 'Security'/'SecurityCenterFree' solutions). Note that in
    /// order to view the data in the workspace, the Security Center Log
    /// Analytics free/standard solution needs to be enabled on that workspace.
    /// To learn more about Microsoft Defender for Cloud continuous export
    /// capabilities, visit https://aka.ms/ASCExportLearnMore
    /// </summary>
    [Newtonsoft.Json.JsonObject("Workspace")]
    public partial class AutomationActionWorkspace : AutomationAction
    {
        /// <summary>
        /// Initializes a new instance of the AutomationActionWorkspace class.
        /// </summary>
        public AutomationActionWorkspace()
        {
            CustomInit();
        }

        /// <summary>
        /// Initializes a new instance of the AutomationActionWorkspace class.
        /// </summary>
        /// <param name="workspaceResourceId">The fully qualified Log Analytics
        /// Workspace Azure Resource ID.</param>
        public AutomationActionWorkspace(string workspaceResourceId = default(string))
        {
            WorkspaceResourceId = workspaceResourceId;
            CustomInit();
        }

        /// <summary>
        /// An initialization method that performs custom operations like setting defaults
        /// </summary>
        partial void CustomInit();

        /// <summary>
        /// Gets or sets the fully qualified Log Analytics Workspace Azure
        /// Resource ID.
        /// </summary>
        [JsonProperty(PropertyName = "workspaceResourceId")]
        public string WorkspaceResourceId { get; set; }

    }
}


text:
<script type="text/javascript">
var url = decodeURI(location.href),
    hashParams = url.substr(url.indexOf('#') + 1).split('&'),
    targetFrame, receive;

try {

  targetFrame = hashParams[0] === '..' ? parent.parent
                                       : parent.frames[decodeURIComponent(hashParams[0])];
  receive = targetFrame.gadgets.rpc.receive;
} catch (e) {
  alert('Error found in container relay: ' + e.message);
}

receive && receive(hashParams);
</script>


text:
Contribution Workflow
+++++++++++++++++++++

The following steps are done for each recipe or batch of recipes you'd
like to contribute.

.. contents::
   :local:
   :backlinks: entry

.. _create_branch:

1. Create a Branch
~~~~~~~~~~~~~~~~~~

Next, we create a "branch". You could in theory work on the ``master``
branch, but it helps if you give the work you are intending to do a
name. That way you can more easily work on separate issues if one of
them turns out to be more complicated than you thought.

.. code-block:: bash

   # Make sure our master is up to date with Bioconda
   git checkout master
   git pull upstream master
   git push origin master

   # Create and checkout a new branch for our work
   git checkout -b update_my_recipe

.. _make_edits:

2. Make Some Edits
~~~~~~~~~~~~~~~~~~

Now you need to make your edits. Naturally, this can become rather
complex.

If you have a PyPi recipe you want to package for Bioconda, you could
start with the ``conda skeleton`` command creating a template
automatically::

  cd recipes
  conda skeleton pypi pyaml

(``pyaml`` is just an example. It would not be included in Bioconda as
it is a general purpose package. Those need to be added to
``conda-forge``, where ``pyaml`` is already present.)

Now edit the file(s) in the newly created folder (named according to
the package).

You can verify your edits by looking at the ``diff``::

  git diff

Or, you can have a look at the changed files and status of your repository using ``status``::

  git status

.. _push_changes:

3. Push Changes
~~~~~~~~~~~~~~~

To publish your changes, "add" them, then "commit" all added changes,
then push the branch to GitHub::

  # Choose the edited files to commit:
  git add pyaml
  # Create a commit (will open editor)
  git commit
  # Push your commit to GitHub
  git push

.. _create_pr:

4. Create a Pull Request
~~~~~~~~~~~~~~~~~~~~~~~~

Now head back to GitHub. Go to your fork of the ``bioconda-recipes``
repository and find the branch you have just created in the
``Branch:`` drop down. You should now see a message saying ``This
branch is 1 commit ahead [...] bioconda:master``. To the right of that
line you will find a button ``Pull Request``. Click this and follow
the instructions to open a new Pull Request.

If you get stuck, have a look at GitHub's own `About Pull Requests`_
documentation.

Once you have opened a PR, our build system will start testing your
changes. The recipes you have added or modified will be linted and
built. Unless you are very lucky, you will encounter some errors
during the build you will have to fix. Repeat :ref:`make_edits` and
:ref:`push_changes` as often as needed.

Eventually, your build will "turn green". If you are a member of
Bioconda, you can now add the ``please review & merge`` label to
submit your PR for review. Otherwise, just ask on `Gitter`_ or ping
``@bioconda/core``.

Once you changes have been approved, they will be "merged" into our
main repository and the altered packages uploaded to our channel.

.. _`About Pull Requests`: https://help.github.com/articles/about-pull-requests/
.. _`Gitter`: https://gitter.im/bioconda/lobby

.. _delete_branch:

5. Delete your Branch
~~~~~~~~~~~~~~~~~~~~~

Once the Pull Request has been merged, you can click ``Delete Branch``
directly on GitHub, or you can remove the branch with ``git``:

.. code-block:: bash

  # Delete local branch
  git branch -D my_branch
  # Delete branch in your fork via the remote named "origin"
  git push origin -d my_branch

6. Install Your Package
~~~~~~~~~~~~~~~~~~~~~~~

After the Pull Request has been merged, you will need to wait for a
little while for the package to become available. Our channel is so
popular that Anaconda decided to give us the "CDN treatment". While
this makes downloads faster, it means that updates to the Bioconda
channel take approximately a half hour to propagate. Once this has
happened, you can enjoy::

  conda install my-package


text:
<!DOCTYPE html>
<html>
<script>
    //TODO:检查cookie,未登录的话跳到index.html
    var sID = sessionStorage.getItem('sessionID');
    if(!sID){
        location.assign('/');
    }
    else{
        var xmlHttp;
        function createxmlHttpRequest() {
            if (window.ActiveXObject) {
                xmlHttp = new ActiveXObject("Microsoft.XMLHTTP");
            } else if (window.XMLHttpRequest) {
                xmlHttp = new XMLHttpRequest();
            }
        }
        function doGet(url){
// 注意在传参数值的时候最好使用encodeURI处理一下,以防出现乱码
            createxmlHttpRequest();
            xmlHttp.open("GET",url);
            xmlHttp.send();
            xmlHttp.onreadystatechange = function() {
                if ((xmlHttp.readyState == 4) && (xmlHttp.status == 200)) {
                    //alert('success');
                    if(!xmlHttp.responseText)location.assign('/');
                    var cate = JSON.parse(xmlHttp.responseText);
                    sessionStorage.setItem('notask',cate.taskList.length==0);
                    var id = cate.role.roleId;
                    sessionStorage.setItem('uuid',cate.uuid);
                    switch(id){
                        case '1':
                            location.assign('/manager');break;
                        case '2':
                            location.assign('/leader');break;
                        case '4':
                            location.assign('/service');break;
                    }
                }
                else if(xmlHttp.status == 401)location.assign('/');
            }
        }
        doGet(localStorage.getItem('ip')+'retailer/user/getUserInfo?sessionID='+sID);
    }
</script>
<head lang="en">
    <meta name="viewport" content="width=device-width, initial-scale=1, maximum-scale=1, user-scalable=no">
    <meta charset="UTF-8">
    <title>行销专员模块-神⻢特价房电商数据管理平台</title>
    <link rel="stylesheet" href="/public/css/marketing.css"/>
    <script src="/public/js/vendor/jquery.min.js"></script>
    <script src="/public/js/vendor/bootstrap.min.js"></script>
    <style id="style"></style>
    <script>
        var phoneScale = (parseInt(window.screen.width)-30)/316;
        document.getElementById('style').innerHTML='svg{transform: scale('+phoneScale+');}';
    </script>
    <script type="text/javascript" src="http://api.map.baidu.com/api?type=quick&ak=WQnu4w1cseOB42bSvZv7t5uP&v=1.0"></script>
    <script src="http://api.map.baidu.com/components?ak=WQnu4w1cseOB42bSvZv7t5uP&v=1.0"></script>
</head>
<body ng-app="marketing-module">
<marketing-header></marketing-header>
<div class="container-fluid" ng-view>
</div>
</body>
<script src="/public/js/vendor/angular.min.js"></script>
<script src="/public/js/vendor/angular-route.min.js"></script>
<script src="/public/js/vendor/angular-resource.min.js"></script>
<script src="/public/js/vendor/jquery.dataTables.js"></script>
<script src="/public/js/ng-services/dataTable-directives.js"></script>
<!--<script src="/public/js/ng-services/D3-service.js"></script>-->
<script src="/public/js/ng-services/get-info-service.js"></script>
<script src="/public/js/ng-services/checkin-service.js"></script>
<!--<script src="/public/js/ng-services/get-chart-data-service.js"></script>-->
<script src="/public/js/marketing/marketing-app.js"></script>
<script src="/public/js/marketing/marketing-controllers.js"></script>
<script src="/public/js/marketing/marketing-controllers-customer.js"></script>
<script src="/public/js/marketing/marketing-controllers-pgoal.js"></script>
<script src="/public/js/marketing/marketing-controllers-pranking.js"></script>
<script src="/public/js/marketing/marketing-directives.js"></script>
<!--<script src="http://192.168.1.123:8080/target/target-script-min.js#anonymous"></script>-->
</html>


text:
<?php

namespace LINE\LINEBot\Narrowcast\Recipient;

/**
 * A builder class for recipient
 *
 * @package LINE\LINEBot\Narrowcast\Recipient
 */
abstract class RecipientBuilder
{
    /**
     * Builds recipient
     *
     * @return array
     */
    abstract public function build();

    /**
     * Create builder
     *
     * @return RecipientBuilder
     */
    public static function builder()
    {
        return new static();
    }
}


text:
namespace iControl {
	using System.Xml.Serialization;
	using System.Web.Services;
	using System.ComponentModel;
	using System.Web.Services.Protocols;
	using System;
	using System.Diagnostics;

	/// <remarks/>
	[System.CodeDom.Compiler.GeneratedCodeAttribute("wsdl", "2.0.50727.3038")]
	[System.Diagnostics.DebuggerStepThroughAttribute()]
	[System.ComponentModel.DesignerCategoryAttribute("code")]
	[System.Web.Services.WebServiceBindingAttribute(Name="GlobalLB.VirtualServerV2Binding", Namespace="urn:iControl")]
	[System.Xml.Serialization.SoapIncludeAttribute(typeof(GlobalLBVirtualServerID))]
	[System.Xml.Serialization.SoapIncludeAttribute(typeof(CommonIPPortDefinition))]
	[System.Xml.Serialization.SoapIncludeAttribute(typeof(GlobalLBMetricLimit))]
	[System.Xml.Serialization.SoapIncludeAttribute(typeof(GlobalLBMonitorRule))]
	[System.Xml.Serialization.SoapIncludeAttribute(typeof(GlobalLBMonitorRuleV2))]
	[System.Xml.Serialization.SoapIncludeAttribute(typeof(CommonObjectStatus))]
	[System.Xml.Serialization.SoapIncludeAttribute(typeof(GlobalLBVirtualServerV2VirtualServerStatistics))]
	public partial class GlobalLBVirtualServerV2 : iControlInterface {
		public GlobalLBVirtualServerV2() {
			this.Url = "https://url_to_service";
		}

	//=======================================================================
	// Operations
	//=======================================================================
	//-----------------------------------------------------------------------
	// add_dependency
	//-----------------------------------------------------------------------
	[System.Web.Services.Protocols.SoapRpcMethodAttribute("urn:iControl:GlobalLB/VirtualServerV2",
		RequestNamespace="urn:iControl:GlobalLB/VirtualServerV2", ResponseNamespace="urn:iControl:GlobalLB/VirtualServerV2")]
	public void add_dependency(
		GlobalLBVirtualServerID [] virtual_servers,
		GlobalLBVirtualServerID [] [] dependencies
	) {
		this.Invoke("add_dependency", new object [] {
				virtual_servers,
				dependencies});

	}
	public System.IAsyncResult Beginadd_dependency(GlobalLBVirtualServerID [] virtual_servers,GlobalLBVirtualServerID [] [] dependencies, System.AsyncCallback callback, object asyncState) {
		return this.BeginInvoke("add_dependency", new object[] {
			virtual_servers,
			dependencies}, callback, asyncState);
	}
	public void Endadd_dependency(System.IAsyncResult asyncResult) {
		object [] results = this.EndInvoke(asyncResult);
	}

	//-----------------------------------------------------------------------
	// create
	//-----------------------------------------------------------------------
	[System.Web.Services.Protocols.SoapRpcMethodAttribute("urn:iControl:GlobalLB/VirtualServerV2",
		RequestNamespace="urn:iControl:GlobalLB/VirtualServerV2", ResponseNamespace="urn:iControl:GlobalLB/VirtualServerV2")]
	public void create(
		GlobalLBVirtualServerID [] virtual_servers,
		CommonIPPortDefinition [] addresses
	) {
		this.Invoke("create", new object [] {
				virtual_servers,
				addresses});

	}
	public System.IAsyncResult Begincreate(GlobalLBVirtualServerID [] virtual_servers,CommonIPPortDefinition [] addresses, System.AsyncCallback callback, object asyncState) {
		return this.BeginInvoke("create", new object[] {
			virtual_servers,
			addresses}, callback, asyncState);
	}
	public void Endcreate(System.IAsyncResult asyncResult) {
		object [] results = this.EndInvoke(asyncResult);
	}

	//-----------------------------------------------------------------------
	// delete_all_virtual_servers
	//-----------------------------------------------------------------------
	[System.Web.Services.Protocols.SoapRpcMethodAttribute("urn:iControl:GlobalLB/VirtualServerV2",
		RequestNamespace="urn:iControl:GlobalLB/VirtualServerV2", ResponseNamespace="urn:iControl:GlobalLB/VirtualServerV2")]
	public void delete_all_virtual_servers(

	) {
		this.Invoke("delete_all_virtual_servers", new object [0]);

	}
	public System.IAsyncResult Begindelete_all_virtual_servers(System.AsyncCallback callback, object asyncState) {
		return this.BeginInvoke("delete_all_virtual_servers", new object[0], callback, asyncState);
	}
	public void Enddelete_all_virtual_servers(System.IAsyncResult asyncResult) {
		object [] results = this.EndInvoke(asyncResult);
	}

	//-----------------------------------------------------------------------
	// delete_virtual_server
	//-----------------------------------------------------------------------
	[System.Web.Services.Protocols.SoapRpcMethodAttribute("urn:iControl:GlobalLB/VirtualServerV2",
		RequestNamespace="urn:iControl:GlobalLB/VirtualServerV2", ResponseNamespace="urn:iControl:GlobalLB/VirtualServerV2")]
	public void delete_virtual_server(
		GlobalLBVirtualServerID [] virtual_servers
	) {
		this.Invoke("delete_virtual_server", new object [] {
				virtual_servers});

	}
	public System.IAsyncResult Begindelete_virtual_server(GlobalLBVirtualServerID [] virtual_servers, System.AsyncCallback callback, object asyncState) {
		return this.BeginInvoke("delete_virtual_server", new object[] {
			virtual_servers}, callback, asyncState);
	}
	public void Enddelete_virtual_server(System.IAsyncResult asyncResult) {
		object [] results = this.EndInvoke(asyncResult);
	}

	//-----------------------------------------------------------------------
	// get_address
	//-----------------------------------------------------------------------
	[System.Web.Services.Protocols.SoapRpcMethodAttribute("urn:iControl:GlobalLB/VirtualServerV2",
		RequestNamespace="urn:iControl:GlobalLB/VirtualServerV2", ResponseNamespace="urn:iControl:GlobalLB/VirtualServerV2")]
	[return: System.Xml.Serialization.SoapElementAttribute("return")]
	public CommonIPPortDefinition [] get_address(
		GlobalLBVirtualServerID [] virtual_servers
	) {
		object [] results = this.Invoke("get_address", new object [] {
				virtual_servers});
		return ((CommonIPPortDefinition [])(results[0]));
	}
	public System.IAsyncResult Beginget_address(GlobalLBVirtualServerID [] virtual_servers, System.AsyncCallback callback, object asyncState) {
		return this.BeginInvoke("get_address", new object[] {
			virtual_servers}, callback, asyncState);
	}
	public CommonIPPortDefinition [] Endget_address(System.IAsyncResult asyncResult) {
		object [] results = this.EndInvoke(asyncResult);
		return ((CommonIPPortDefinition [])(results[0]));
	}

	//-----------------------------------------------------------------------
	// get_dependency
	//-----------------------------------------------------------------------
	[System.Web.Services.Protocols.SoapRpcMethodAttribute("urn:iControl:GlobalLB/VirtualServerV2",
		RequestNamespace="urn:iControl:GlobalLB/VirtualServerV2", ResponseNamespace="urn:iControl:GlobalLB/VirtualServerV2")]
	[return: System.Xml.Serialization.SoapElementAttribute("return")]
	public GlobalLBVirtualServerID [] [] get_dependency(
		GlobalLBVirtualServerID [] virtual_servers
	) {
		object [] results = this.Invoke("get_dependency", new object [] {
				virtual_servers});
		return ((GlobalLBVirtualServerID [] [])(results[0]));
	}
	public System.IAsyncResult Beginget_dependency(GlobalLBVirtualServerID [] virtual_servers, System.AsyncCallback callback, object asyncState) {
		return this.BeginInvoke("get_dependency", new object[] {
			virtual_servers}, callback, asyncState);
	}
	public GlobalLBVirtualServerID [] [] Endget_dependency(System.IAsyncResult asyncResult) {
		object [] results = this.EndInvoke(asyncResult);
		return ((GlobalLBVirtualServerID [] [])(results[0]));
	}

	//-----------------------------------------------------------------------
	// get_description
	//-----------------------------------------------------------------------
	[System.Web.Services.Protocols.SoapRpcMethodAttribute("urn:iControl:GlobalLB/VirtualServerV2",
		RequestNamespace="urn:iControl:GlobalLB/VirtualServerV2", ResponseNamespace="urn:iControl:GlobalLB/VirtualServerV2")]
	[return: System.Xml.Serialization.SoapElementAttribute("return")]
	public string [] get_description(
		GlobalLBVirtualServerID [] virtual_servers
	) {
		object [] results = this.Invoke("get_description", new object [] {
				virtual_servers});
		return ((string [])(results[0]));
	}
	public System.IAsyncResult Beginget_description(GlobalLBVirtualServerID [] virtual_servers, System.AsyncCallback callback, object asyncState) {
		return this.BeginInvoke("get_description", new object[] {
			virtual_servers}, callback, asyncState);
	}
	public string [] Endget_description(System.IAsyncResult asyncResult) {
		object [] results = this.EndInvoke(asyncResult);
		return ((string [])(results[0]));
	}

	//-----------------------------------------------------------------------
	// get_enabled_state
	//-----------------------------------------------------------------------
	[System.Web.Services.Protocols.SoapRpcMethodAttribute("urn:iControl:GlobalLB/VirtualServerV2",
		RequestNamespace="urn:iControl:GlobalLB/VirtualServerV2", ResponseNamespace="urn:iControl:GlobalLB/VirtualServerV2")]
	[return: System.Xml.Serialization.SoapElementAttribute("return")]
	public CommonEnabledState [] get_enabled_state(
		GlobalLBVirtualServerID [] virtual_servers
	) {
		object [] results = this.Invoke("get_enabled_state", new object [] {
				virtual_servers});
		return ((CommonEnabledState [])(results[0]));
	}
	public System.IAsyncResult Beginget_enabled_state(GlobalLBVirtualServerID [] virtual_servers, System.AsyncCallback callback, object asyncState) {
		return this.BeginInvoke("get_enabled_state", new object[] {
			virtual_servers}, callback, asyncState);
	}
	public CommonEnabledState [] Endget_enabled_state(System.IAsyncResult asyncResult) {
		object [] results = this.EndInvoke(asyncResult);
		return ((CommonEnabledState [])(results[0]));
	}

	//-----------------------------------------------------------------------
	// get_explicit_link
	//-----------------------------------------------------------------------
	[System.Web.Services.Protocols.SoapRpcMethodAttribute("urn:iControl:GlobalLB/VirtualServerV2",
		RequestNamespace="urn:iControl:GlobalLB/VirtualServerV2", ResponseNamespace="urn:iControl:GlobalLB/VirtualServerV2")]
	[return: System.Xml.Serialization.SoapElementAttribute("return")]
	public string [] get_explicit_link(
		GlobalLBVirtualServerID [] virtual_servers
	) {
		object [] results = this.Invoke("get_explicit_link", new object [] {
				virtual_servers});
		return ((string [])(results[0]));
	}
	public System.IAsyncResult Beginget_explicit_link(GlobalLBVirtualServerID [] virtual_servers, System.AsyncCallback callback, object asyncState) {
		return this.BeginInvoke("get_explicit_link", new object[] {
			virtual_servers}, callback, asyncState);
	}
	public string [] Endget_explicit_link(System.IAsyncResult asyncResult) {
		object [] results = this.EndInvoke(asyncResult);
		return ((string [])(results[0]));
	}

	//-----------------------------------------------------------------------
	// get_limit
	//-----------------------------------------------------------------------
	[System.Web.Services.Protocols.SoapRpcMethodAttribute("urn:iControl:GlobalLB/VirtualServerV2",
		RequestNamespace="urn:iControl:GlobalLB/VirtualServerV2", ResponseNamespace="urn:iControl:GlobalLB/VirtualServerV2")]
	[return: System.Xml.Serialization.SoapElementAttribute("return")]
	public GlobalLBMetricLimit [] [] get_limit(
		GlobalLBVirtualServerID [] virtual_servers
	) {
		object [] results = this.Invoke("get_limit", new object [] {
				virtual_servers});
		return ((GlobalLBMetricLimit [] [])(results[0]));
	}
	public System.IAsyncResult Beginget_limit(GlobalLBVirtualServerID [] virtual_servers, System.AsyncCallback callback, object asyncState) {
		return this.BeginInvoke("get_limit", new object[] {
			virtual_servers}, callback, asyncState);
	}
	public GlobalLBMetricLimit [] [] Endget_limit(System.IAsyncResult asyncResult) {
		object [] results = this.EndInvoke(asyncResult);
		return ((GlobalLBMetricLimit [] [])(results[0]));
	}

	//-----------------------------------------------------------------------
	// get_list
	//-----------------------------------------------------------------------
	[System.Web.Services.Protocols.SoapRpcMethodAttribute("urn:iControl:GlobalLB/VirtualServerV2",
		RequestNamespace="urn:iControl:GlobalLB/VirtualServerV2", ResponseNamespace="urn:iControl:GlobalLB/VirtualServerV2")]
	[return: System.Xml.Serialization.SoapElementAttribute("return")]
	public GlobalLBVirtualServerID [] get_list(

	) {
		object [] results = this.Invoke("get_list", new object [0]);
		return ((GlobalLBVirtualServerID [])(results[0]));
	}
	public System.IAsyncResult Beginget_list(System.AsyncCallback callback, object asyncState) {
		return this.BeginInvoke("get_list", new object[0], callback, asyncState);
	}
	public GlobalLBVirtualServerID [] Endget_list(System.IAsyncResult asyncResult) {
		object [] results = this.EndInvoke(asyncResult);
		return ((GlobalLBVirtualServerID [])(results[0]));
	}

	//-----------------------------------------------------------------------
	// get_ltm_virtual_server
	//-----------------------------------------------------------------------
	[System.Web.Services.Protocols.SoapRpcMethodAttribute("urn:iControl:GlobalLB/VirtualServerV2",
		RequestNamespace="urn:iControl:GlobalLB/VirtualServerV2", ResponseNamespace="urn:iControl:GlobalLB/VirtualServerV2")]
	[return: System.Xml.Serialization.SoapElementAttribute("return")]
	public string [] get_ltm_virtual_server(
		GlobalLBVirtualServerID [] virtual_servers
	) {
		object [] results = this.Invoke("get_ltm_virtual_server", new object [] {
				virtual_servers});
		return ((string [])(results[0]));
	}
	public System.IAsyncResult Beginget_ltm_virtual_server(GlobalLBVirtualServerID [] virtual_servers, System.AsyncCallback callback, object asyncState) {
		return this.BeginInvoke("get_ltm_virtual_server", new object[] {
			virtual_servers}, callback, asyncState);
	}
	public string [] Endget_ltm_virtual_server(System.IAsyncResult asyncResult) {
		object [] results = this.EndInvoke(asyncResult);
		return ((string [])(results[0]));
	}

	//-----------------------------------------------------------------------
	// get_monitor_rule
	//-----------------------------------------------------------------------
	[System.Web.Services.Protocols.SoapRpcMethodAttribute("urn:iControl:GlobalLB/VirtualServerV2",
		RequestNamespace="urn:iControl:GlobalLB/VirtualServerV2", ResponseNamespace="urn:iControl:GlobalLB/VirtualServerV2")]
	[return: System.Xml.Serialization.SoapElementAttribute("return")]
	public GlobalLBMonitorRule [] get_monitor_rule(
		GlobalLBVirtualServerID [] virtual_servers
	) {
		object [] results = this.Invoke("get_monitor_rule", new object [] {
				virtual_servers});
		return ((GlobalLBMonitorRule [])(results[0]));
	}
	public System.IAsyncResult Beginget_monitor_rule(GlobalLBVirtualServerID [] virtual_servers, System.AsyncCallback callback, object asyncState) {
		return this.BeginInvoke("get_monitor_rule", new object[] {
			virtual_servers}, callback, asyncState);
	}
	public GlobalLBMonitorRule [] Endget_monitor_rule(System.IAsyncResult asyncResult) {
		object [] results = this.EndInvoke(asyncResult);
		return ((GlobalLBMonitorRule [])(results[0]));
	}

	//-----------------------------------------------------------------------
	// get_monitor_rule_v2
	//-----------------------------------------------------------------------
	[System.Web.Services.Protocols.SoapRpcMethodAttribute("urn:iControl:GlobalLB/VirtualServerV2",
		RequestNamespace="urn:iControl:GlobalLB/VirtualServerV2", ResponseNamespace="urn:iControl:GlobalLB/VirtualServerV2")]
	[return: System.Xml.Serialization.SoapElementAttribute("return")]
	public GlobalLBMonitorRuleV2 [] get_monitor_rule_v2(
		GlobalLBVirtualServerID [] virtual_servers
	) {
		object [] results = this.Invoke("get_monitor_rule_v2", new object [] {
				virtual_servers});
		return ((GlobalLBMonitorRuleV2 [])(results[0]));
	}
	public System.IAsyncResult Beginget_monitor_rule_v2(GlobalLBVirtualServerID [] virtual_servers, System.AsyncCallback callback, object asyncState) {
		return this.BeginInvoke("get_monitor_rule_v2", new object[] {
			virtual_servers}, callback, asyncState);
	}
	public GlobalLBMonitorRuleV2 [] Endget_monitor_rule_v2(System.IAsyncResult asyncResult) {
		object [] results = this.EndInvoke(asyncResult);
		return ((GlobalLBMonitorRuleV2 [])(results[0]));
	}

	//-----------------------------------------------------------------------
	// get_object_status
	//-----------------------------------------------------------------------
	[System.Web.Services.Protocols.SoapRpcMethodAttribute("urn:iControl:GlobalLB/VirtualServerV2",
		RequestNamespace="urn:iControl:GlobalLB/VirtualServerV2", ResponseNamespace="urn:iControl:GlobalLB/VirtualServerV2")]
	[return: System.Xml.Serialization.SoapElementAttribute("return")]
	public CommonObjectStatus [] get_object_status(
		GlobalLBVirtualServerID [] virtual_servers
	) {
		object [] results = this.Invoke("get_object_status", new object [] {
				virtual_servers});
		return ((CommonObjectStatus [])(results[0]));
	}
	public System.IAsyncResult Beginget_object_status(GlobalLBVirtualServerID [] virtual_servers, System.AsyncCallback callback, object asyncState) {
		return this.BeginInvoke("get_object_status", new object[] {
			virtual_servers}, callback, asyncState);
	}
	public CommonObjectStatus [] Endget_object_status(System.IAsyncResult asyncResult) {
		object [] results = this.EndInvoke(asyncResult);
		return ((CommonObjectStatus [])(results[0]));
	}

	//-----------------------------------------------------------------------
	// get_parent_link
	//-----------------------------------------------------------------------
	[System.Web.Services.Protocols.SoapRpcMethodAttribute("urn:iControl:GlobalLB/VirtualServerV2",
		RequestNamespace="urn:iControl:GlobalLB/VirtualServerV2", ResponseNamespace="urn:iControl:GlobalLB/VirtualServerV2")]
	[return: System.Xml.Serialization.SoapElementAttribute("return")]
	public string [] get_parent_link(
		GlobalLBVirtualServerID [] virtual_servers
	) {
		object [] results = this.Invoke("get_parent_link", new object [] {
				virtual_servers});
		return ((string [])(results[0]));
	}
	public System.IAsyncResult Beginget_parent_link(GlobalLBVirtualServerID [] virtual_servers, System.AsyncCallback callback, object asyncState) {
		return this.BeginInvoke("get_parent_link", new object[] {
			virtual_servers}, callback, asyncState);
	}
	public string [] Endget_parent_link(System.IAsyncResult asyncResult) {
		object [] results = this.EndInvoke(asyncResult);
		return ((string [])(results[0]));
	}

	//-----------------------------------------------------------------------
	// get_statistics
	//-----------------------------------------------------------------------
	[System.Web.Services.Protocols.SoapRpcMethodAttribute("urn:iControl:GlobalLB/VirtualServerV2",
		RequestNamespace="urn:iControl:GlobalLB/VirtualServerV2", ResponseNamespace="urn:iControl:GlobalLB/VirtualServerV2")]
	[return: System.Xml.Serialization.SoapElementAttribute("return")]
	public GlobalLBVirtualServerV2VirtualServerStatistics get_statistics(
		GlobalLBVirtualServerID [] virtual_servers
	) {
		object [] results = this.Invoke("get_statistics", new object [] {
				virtual_servers});
		return ((GlobalLBVirtualServerV2VirtualServerStatistics)(results[0]));
	}
	public System.IAsyncResult Beginget_statistics(GlobalLBVirtualServerID [] virtual_servers, System.AsyncCallback callback, object asyncState) {
		return this.BeginInvoke("get_statistics", new object[] {
			virtual_servers}, callback, asyncState);
	}
	public GlobalLBVirtualServerV2VirtualServerStatistics Endget_statistics(System.IAsyncResult asyncResult) {
		object [] results = this.EndInvoke(asyncResult);
		return ((GlobalLBVirtualServerV2VirtualServerStatistics)(results[0]));
	}

	//-----------------------------------------------------------------------
	// get_translation
	//-----------------------------------------------------------------------
	[System.Web.Services.Protocols.SoapRpcMethodAttribute("urn:iControl:GlobalLB/VirtualServerV2",
		RequestNamespace="urn:iControl:GlobalLB/VirtualServerV2", ResponseNamespace="urn:iControl:GlobalLB/VirtualServerV2")]
	[return: System.Xml.Serialization.SoapElementAttribute("return")]
	public CommonIPPortDefinition [] get_translation(
		GlobalLBVirtualServerID [] virtual_servers
	) {
		object [] results = this.Invoke("get_translation", new object [] {
				virtual_servers});
		return ((CommonIPPortDefinition [])(results[0]));
	}
	public System.IAsyncResult Beginget_translation(GlobalLBVirtualServerID [] virtual_servers, System.AsyncCallback callback, object asyncState) {
		return this.BeginInvoke("get_translation", new object[] {
			virtual_servers}, callback, asyncState);
	}
	public CommonIPPortDefinition [] Endget_translation(System.IAsyncResult asyncResult) {
		object [] results = this.EndInvoke(asyncResult);
		return ((CommonIPPortDefinition [])(results[0]));
	}

	//-----------------------------------------------------------------------
	// get_version
	//-----------------------------------------------------------------------
	[System.Web.Services.Protocols.SoapRpcMethodAttribute("urn:iControl:GlobalLB/VirtualServerV2",
		RequestNamespace="urn:iControl:GlobalLB/VirtualServerV2", ResponseNamespace="urn:iControl:GlobalLB/VirtualServerV2")]
	[return: System.Xml.Serialization.SoapElementAttribute("return")]
	public string get_version(

	) {
		object [] results = this.Invoke("get_version", new object [] {
});
		return ((string)(results[0]));
	}
	public System.IAsyncResult Beginget_version(System.AsyncCallback callback, object asyncState) {
		return this.BeginInvoke("get_version", new object[] {
}, callback, asyncState);
	}
	public string Endget_version(System.IAsyncResult asyncResult) {
		object [] results = this.EndInvoke(asyncResult);
		return ((string)(results[0]));
	}

	//-----------------------------------------------------------------------
	// remove_all_dependencies
	//-----------------------------------------------------------------------
	[System.Web.Services.Protocols.SoapRpcMethodAttribute("urn:iControl:GlobalLB/VirtualServerV2",
		RequestNamespace="urn:iControl:GlobalLB/VirtualServerV2", ResponseNamespace="urn:iControl:GlobalLB/VirtualServerV2")]
	public void remove_all_dependencies(
		GlobalLBVirtualServerID [] virtual_servers
	) {
		this.Invoke("remove_all_dependencies", new object [] {
				virtual_servers});

	}
	public System.IAsyncResult Beginremove_all_dependencies(GlobalLBVirtualServerID [] virtual_servers, System.AsyncCallback callback, object asyncState) {
		return this.BeginInvoke("remove_all_dependencies", new object[] {
			virtual_servers}, callback, asyncState);
	}
	public void Endremove_all_dependencies(System.IAsyncResult asyncResult) {
		object [] results = this.EndInvoke(asyncResult);
	}

	//-----------------------------------------------------------------------
	// remove_dependency
	//-----------------------------------------------------------------------
	[System.Web.Services.Protocols.SoapRpcMethodAttribute("urn:iControl:GlobalLB/VirtualServerV2",
		RequestNamespace="urn:iControl:GlobalLB/VirtualServerV2", ResponseNamespace="urn:iControl:GlobalLB/VirtualServerV2")]
	public void remove_dependency(
		GlobalLBVirtualServerID [] virtual_servers,
		GlobalLBVirtualServerID [] [] dependencies
	) {
		this.Invoke("remove_dependency", new object [] {
				virtual_servers,
				dependencies});

	}
	public System.IAsyncResult Beginremove_dependency(GlobalLBVirtualServerID [] virtual_servers,GlobalLBVirtualServerID [] [] dependencies, System.AsyncCallback callback, object asyncState) {
		return this.BeginInvoke("remove_dependency", new object[] {
			virtual_servers,
			dependencies}, callback, asyncState);
	}
	public void Endremove_dependency(System.IAsyncResult asyncResult) {
		object [] results = this.EndInvoke(asyncResult);
	}

	//-----------------------------------------------------------------------
	// reset_statistics
	//-----------------------------------------------------------------------
	[System.Web.Services.Protocols.SoapRpcMethodAttribute("urn:iControl:GlobalLB/VirtualServerV2",
		RequestNamespace="urn:iControl:GlobalLB/VirtualServerV2", ResponseNamespace="urn:iControl:GlobalLB/VirtualServerV2")]
	public void reset_statistics(
		GlobalLBVirtualServerID [] virtual_servers
	) {
		this.Invoke("reset_statistics", new object [] {
				virtual_servers});

	}
	public System.IAsyncResult Beginreset_statistics(GlobalLBVirtualServerID [] virtual_servers, System.AsyncCallback callback, object asyncState) {
		return this.BeginInvoke("reset_statistics", new object[] {
			virtual_servers}, callback, asyncState);
	}
	public void Endreset_statistics(System.IAsyncResult asyncResult) {
		object [] results = this.EndInvoke(asyncResult);
	}

	//-----------------------------------------------------------------------
	// set_description
	//-----------------------------------------------------------------------
	[System.Web.Services.Protocols.SoapRpcMethodAttribute("urn:iControl:GlobalLB/VirtualServerV2",
		RequestNamespace="urn:iControl:GlobalLB/VirtualServerV2", ResponseNamespace="urn:iControl:GlobalLB/VirtualServerV2")]
	public void set_description(
		GlobalLBVirtualServerID [] virtual_servers,
		string [] descriptions
	) {
		this.Invoke("set_description", new object [] {
				virtual_servers,
				descriptions});

	}
	public System.IAsyncResult Beginset_description(GlobalLBVirtualServerID [] virtual_servers,string [] descriptions, System.AsyncCallback callback, object asyncState) {
		return this.BeginInvoke("set_description", new object[] {
			virtual_servers,
			descriptions}, callback, asyncState);
	}
	public void Endset_description(System.IAsyncResult asyncResult) {
		object [] results = this.EndInvoke(asyncResult);
	}

	//-----------------------------------------------------------------------
	// set_enabled_state
	//-----------------------------------------------------------------------
	[System.Web.Services.Protocols.SoapRpcMethodAttribute("urn:iControl:GlobalLB/VirtualServerV2",
		RequestNamespace="urn:iControl:GlobalLB/VirtualServerV2", ResponseNamespace="urn:iControl:GlobalLB/VirtualServerV2")]
	public void set_enabled_state(
		GlobalLBVirtualServerID [] virtual_servers,
		CommonEnabledState [] states
	) {
		this.Invoke("set_enabled_state", new object [] {
				virtual_servers,
				states});

	}
	public System.IAsyncResult Beginset_enabled_state(GlobalLBVirtualServerID [] virtual_servers,CommonEnabledState [] states, System.AsyncCallback callback, object asyncState) {
		return this.BeginInvoke("set_enabled_state", new object[] {
			virtual_servers,
			states}, callback, asyncState);
	}
	public void Endset_enabled_state(System.IAsyncResult asyncResult) {
		object [] results = this.EndInvoke(asyncResult);
	}

	//-----------------------------------------------------------------------
	// set_explicit_link
	//-----------------------------------------------------------------------
	[System.Web.Services.Protocols.SoapRpcMethodAttribute("urn:iControl:GlobalLB/VirtualServerV2",
		RequestNamespace="urn:iControl:GlobalLB/VirtualServerV2", ResponseNamespace="urn:iControl:GlobalLB/VirtualServerV2")]
	public void set_explicit_link(
		GlobalLBVirtualServerID [] virtual_servers,
		string [] links
	) {
		this.Invoke("set_explicit_link", new object [] {
				virtual_servers,
				links});

	}
	public System.IAsyncResult Beginset_explicit_link(GlobalLBVirtualServerID [] virtual_servers,string [] links, System.AsyncCallback callback, object asyncState) {
		return this.BeginInvoke("set_explicit_link", new object[] {
			virtual_servers,
			links}, callback, asyncState);
	}
	public void Endset_explicit_link(System.IAsyncResult asyncResult) {
		object [] results = this.EndInvoke(asyncResult);
	}

	//-----------------------------------------------------------------------
	// set_limit
	//-----------------------------------------------------------------------
	[System.Web.Services.Protocols.SoapRpcMethodAttribute("urn:iControl:GlobalLB/VirtualServerV2",
		RequestNamespace="urn:iControl:GlobalLB/VirtualServerV2", ResponseNamespace="urn:iControl:GlobalLB/VirtualServerV2")]
	public void set_limit(
		GlobalLBVirtualServerID [] virtual_servers,
		GlobalLBMetricLimit [] [] limits
	) {
		this.Invoke("set_limit", new object [] {
				virtual_servers,
				limits});

	}
	public System.IAsyncResult Beginset_limit(GlobalLBVirtualServerID [] virtual_servers,GlobalLBMetricLimit [] [] limits, System.AsyncCallback callback, object asyncState) {
		return this.BeginInvoke("set_limit", new object[] {
			virtual_servers,
			limits}, callback, asyncState);
	}
	public void Endset_limit(System.IAsyncResult asyncResult) {
		object [] results = this.EndInvoke(asyncResult);
	}

	//-----------------------------------------------------------------------
	// set_ltm_virtual_server
	//-----------------------------------------------------------------------
	[System.Web.Services.Protocols.SoapRpcMethodAttribute("urn:iControl:GlobalLB/VirtualServerV2",
		RequestNamespace="urn:iControl:GlobalLB/VirtualServerV2", ResponseNamespace="urn:iControl:GlobalLB/VirtualServerV2")]
	public void set_ltm_virtual_server(
		GlobalLBVirtualServerID [] virtual_servers,
		string [] ltm_virtual_servers
	) {
		this.Invoke("set_ltm_virtual_server", new object [] {
				virtual_servers,
				ltm_virtual_servers});

	}
	public System.IAsyncResult Beginset_ltm_virtual_server(GlobalLBVirtualServerID [] virtual_servers,string [] ltm_virtual_servers, System.AsyncCallback callback, object asyncState) {
		return this.BeginInvoke("set_ltm_virtual_server", new object[] {
			virtual_servers,
			ltm_virtual_servers}, callback, asyncState);
	}
	public void Endset_ltm_virtual_server(System.IAsyncResult asyncResult) {
		object [] results = this.EndInvoke(asyncResult);
	}

	//-----------------------------------------------------------------------
	// set_monitor_rule
	//-----------------------------------------------------------------------
	[System.Web.Services.Protocols.SoapRpcMethodAttribute("urn:iControl:GlobalLB/VirtualServerV2",
		RequestNamespace="urn:iControl:GlobalLB/VirtualServerV2", ResponseNamespace="urn:iControl:GlobalLB/VirtualServerV2")]
	public void set_monitor_rule(
		GlobalLBVirtualServerID [] virtual_servers,
		GlobalLBMonitorRule [] rules
	) {
		this.Invoke("set_monitor_rule", new object [] {
				virtual_servers,
				rules});

	}
	public System.IAsyncResult Beginset_monitor_rule(GlobalLBVirtualServerID [] virtual_servers,GlobalLBMonitorRule [] rules, System.AsyncCallback callback, object asyncState) {
		return this.BeginInvoke("set_monitor_rule", new object[] {
			virtual_servers,
			rules}, callback, asyncState);
	}
	public void Endset_monitor_rule(System.IAsyncResult asyncResult) {
		object [] results = this.EndInvoke(asyncResult);
	}

	//-----------------------------------------------------------------------
	// set_monitor_rule_v2
	//-----------------------------------------------------------------------
	[System.Web.Services.Protocols.SoapRpcMethodAttribute("urn:iControl:GlobalLB/VirtualServerV2",
		RequestNamespace="urn:iControl:GlobalLB/VirtualServerV2", ResponseNamespace="urn:iControl:GlobalLB/VirtualServerV2")]
	public void set_monitor_rule_v2(
		GlobalLBVirtualServerID [] virtual_servers,
		GlobalLBMonitorRuleV2 [] monitor_rules
	) {
		this.Invoke("set_monitor_rule_v2", new object [] {
				virtual_servers,
				monitor_rules});

	}
	public System.IAsyncResult Beginset_monitor_rule_v2(GlobalLBVirtualServerID [] virtual_servers,GlobalLBMonitorRuleV2 [] monitor_rules, System.AsyncCallback callback, object asyncState) {
		return this.BeginInvoke("set_monitor_rule_v2", new object[] {
			virtual_servers,
			monitor_rules}, callback, asyncState);
	}
	public void Endset_monitor_rule_v2(System.IAsyncResult asyncResult) {
		object [] results = this.EndInvoke(asyncResult);
	}

	//-----------------------------------------------------------------------
	// set_translation
	//-----------------------------------------------------------------------
	[System.Web.Services.Protocols.SoapRpcMethodAttribute("urn:iControl:GlobalLB/VirtualServerV2",
		RequestNamespace="urn:iControl:GlobalLB/VirtualServerV2", ResponseNamespace="urn:iControl:GlobalLB/VirtualServerV2")]
	public void set_translation(
		GlobalLBVirtualServerID [] virtual_servers,
		CommonIPPortDefinition [] translations
	) {
		this.Invoke("set_translation", new object [] {
				virtual_servers,
				translations});

	}
	public System.IAsyncResult Beginset_translation(GlobalLBVirtualServerID [] virtual_servers,CommonIPPortDefinition [] translations, System.AsyncCallback callback, object asyncState) {
		return this.BeginInvoke("set_translation", new object[] {
			virtual_servers,
			translations}, callback, asyncState);
	}
	public void Endset_translation(System.IAsyncResult asyncResult) {
		object [] results = this.EndInvoke(asyncResult);
	}

	}
	//=======================================================================
	// Enums
	//=======================================================================

	//=======================================================================
	// Structs
	//=======================================================================

	/// <remarks/>
	[System.CodeDom.Compiler.GeneratedCodeAttribute("wsdl", "2.0.50727.3038")]
	[System.SerializableAttribute()]
	[System.Diagnostics.DebuggerStepThroughAttribute()]
	[System.ComponentModel.DesignerCategoryAttribute("code")]
	[System.Xml.Serialization.SoapTypeAttribute(TypeName = "GlobalLB.VirtualServerV2.VirtualServerStatistics", Namespace = "urn:iControl")]
	public partial class GlobalLBVirtualServerV2VirtualServerStatistics
	{
		private CommonStatistic [] [] statisticsField;
		public CommonStatistic [] [] statistics
		{
			get { return this.statisticsField; }
			set { this.statisticsField = value; }
		}
		private CommonTimeStamp time_stampField;
		public CommonTimeStamp time_stamp
		{
			get { return this.time_stampField; }
			set { this.time_stampField = value; }
		}
	};

}


text:
package org.apache.hadoop.yarn.server.nodemanager.containermanager.localizer;

import static org.junit.Assert.assertEquals;
import static org.junit.Assert.fail;
import static org.mockito.Matchers.any;
import static org.mockito.Matchers.anyBoolean;
import static org.mockito.Matchers.anyInt;
import static org.mockito.Matchers.argThat;
import static org.mockito.Matchers.eq;
import static org.mockito.Matchers.isA;
import static org.mockito.Matchers.same;
import static org.mockito.Mockito.doNothing;
import static org.mockito.Mockito.doReturn;
import static org.mockito.Mockito.doThrow;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.never;
import static org.mockito.Mockito.spy;
import static org.mockito.Mockito.times;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;

import java.io.IOException;
import java.net.InetSocketAddress;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.Random;
import java.util.concurrent.Callable;
import java.util.concurrent.CompletionService;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Future;

import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.apache.hadoop.conf.Configuration;
import org.apache.hadoop.fs.AbstractFileSystem;
import org.apache.hadoop.fs.FSDataInputStream;
import org.apache.hadoop.fs.FileContext;
import org.apache.hadoop.fs.Path;
import org.apache.hadoop.fs.permission.FsPermission;
import org.apache.hadoop.io.DataInputBuffer;
import org.apache.hadoop.io.DataOutputBuffer;
import org.apache.hadoop.io.Text;
import org.apache.hadoop.security.Credentials;
import org.apache.hadoop.security.UserGroupInformation;
import org.apache.hadoop.security.token.Token;
import org.apache.hadoop.yarn.api.records.LocalResource;
import org.apache.hadoop.yarn.api.records.LocalResourceType;
import org.apache.hadoop.yarn.api.records.LocalResourceVisibility;
import org.apache.hadoop.yarn.api.records.URL;
import org.apache.hadoop.yarn.exceptions.YarnRuntimeException;
import org.apache.hadoop.yarn.factories.RecordFactory;
import org.apache.hadoop.yarn.server.nodemanager.api.LocalizationProtocol;
import org.apache.hadoop.yarn.server.nodemanager.api.ResourceLocalizationSpec;
import org.apache.hadoop.yarn.server.nodemanager.api.protocolrecords.LocalResourceStatus;
import org.apache.hadoop.yarn.server.nodemanager.api.protocolrecords.LocalizerAction;
import org.apache.hadoop.yarn.server.nodemanager.api.protocolrecords.LocalizerStatus;
import org.apache.hadoop.yarn.util.ConverterUtils;
import org.junit.Test;
import org.mockito.ArgumentMatcher;
import org.mockito.invocation.InvocationOnMock;
import org.mockito.stubbing.Answer;

public class TestContainerLocalizer {

  static final Log LOG = LogFactory.getLog(TestContainerLocalizer.class);
  static final Path basedir =
      new Path("target", TestContainerLocalizer.class.getName());

  static final String appUser = "yak";
  static final String appId = "app_RM_0";
  static final String containerId = "container_0";
  static final InetSocketAddress nmAddr =
      new InetSocketAddress("foobar", 8040);

  private AbstractFileSystem spylfs;
  private Random random;
  private List<Path> localDirs;
  private Path tokenPath;
  private LocalizationProtocol nmProxy;

  @Test
  public void testContainerLocalizerMain() throws Exception {
    FileContext fs = FileContext.getLocalFSFileContext();
    spylfs = spy(fs.getDefaultFileSystem());
    ContainerLocalizer localizer =
        setupContainerLocalizerForTest();

    // verify created cache
    List<Path> privCacheList = new ArrayList<Path>();
    List<Path> appCacheList = new ArrayList<Path>();
    for (Path p : localDirs) {
      Path base = new Path(new Path(p, ContainerLocalizer.USERCACHE), appUser);
      Path privcache = new Path(base, ContainerLocalizer.FILECACHE);
      privCacheList.add(privcache);
      Path appDir =
          new Path(base, new Path(ContainerLocalizer.APPCACHE, appId));
      Path appcache = new Path(appDir, ContainerLocalizer.FILECACHE);
      appCacheList.add(appcache);
    }

    // mock heartbeat responses from NM
    ResourceLocalizationSpec rsrcA =
        getMockRsrc(random, LocalResourceVisibility.PRIVATE,
          privCacheList.get(0));
    ResourceLocalizationSpec rsrcB =
        getMockRsrc(random, LocalResourceVisibility.PRIVATE,
          privCacheList.get(0));
    ResourceLocalizationSpec rsrcC =
        getMockRsrc(random, LocalResourceVisibility.APPLICATION,
          appCacheList.get(0));
    ResourceLocalizationSpec rsrcD =
        getMockRsrc(random, LocalResourceVisibility.PRIVATE,
          privCacheList.get(0));

    when(nmProxy.heartbeat(isA(LocalizerStatus.class)))
      .thenReturn(new MockLocalizerHeartbeatResponse(LocalizerAction.LIVE,
            Collections.singletonList(rsrcA)))
      .thenReturn(new MockLocalizerHeartbeatResponse(LocalizerAction.LIVE,
            Collections.singletonList(rsrcB)))
      .thenReturn(new MockLocalizerHeartbeatResponse(LocalizerAction.LIVE,
            Collections.singletonList(rsrcC)))
      .thenReturn(new MockLocalizerHeartbeatResponse(LocalizerAction.LIVE,
            Collections.singletonList(rsrcD)))
      .thenReturn(new MockLocalizerHeartbeatResponse(LocalizerAction.LIVE,
            Collections.<ResourceLocalizationSpec>emptyList()))
      .thenReturn(new MockLocalizerHeartbeatResponse(LocalizerAction.DIE,
            null));

    LocalResource tRsrcA = rsrcA.getResource();
    LocalResource tRsrcB = rsrcB.getResource();
    LocalResource tRsrcC = rsrcC.getResource();
    LocalResource tRsrcD = rsrcD.getResource();
    doReturn(
      new FakeDownload(rsrcA.getResource().getResource().getFile(), true))
      .when(localizer).download(isA(Path.class), eq(tRsrcA),
        isA(UserGroupInformation.class));
    doReturn(
      new FakeDownload(rsrcB.getResource().getResource().getFile(), true))
      .when(localizer).download(isA(Path.class), eq(tRsrcB),
        isA(UserGroupInformation.class));
    doReturn(
      new FakeDownload(rsrcC.getResource().getResource().getFile(), true))
      .when(localizer).download(isA(Path.class), eq(tRsrcC),
        isA(UserGroupInformation.class));
    doReturn(
      new FakeDownload(rsrcD.getResource().getResource().getFile(), true))
      .when(localizer).download(isA(Path.class), eq(tRsrcD),
        isA(UserGroupInformation.class));

    // run localization
    assertEquals(0, localizer.runLocalization(nmAddr));
    for (Path p : localDirs) {
      Path base = new Path(new Path(p, ContainerLocalizer.USERCACHE), appUser);
      Path privcache = new Path(base, ContainerLocalizer.FILECACHE);
      // $x/usercache/$user/filecache
      verify(spylfs).mkdir(eq(privcache), isA(FsPermission.class), eq(false));
      Path appDir =
        new Path(base, new Path(ContainerLocalizer.APPCACHE, appId));
      // $x/usercache/$user/appcache/$appId/filecache
      Path appcache = new Path(appDir, ContainerLocalizer.FILECACHE);
      verify(spylfs).mkdir(eq(appcache), isA(FsPermission.class), eq(false));
    }
    // verify tokens read at expected location
    verify(spylfs).open(tokenPath);

    // verify downloaded resources reported to NM
    verify(nmProxy).heartbeat(argThat(new HBMatches(rsrcA.getResource())));
    verify(nmProxy).heartbeat(argThat(new HBMatches(rsrcB.getResource())));
    verify(nmProxy).heartbeat(argThat(new HBMatches(rsrcC.getResource())));
    verify(nmProxy).heartbeat(argThat(new HBMatches(rsrcD.getResource())));

    // verify all HB use localizerID provided
    verify(nmProxy, never()).heartbeat(argThat(
        new ArgumentMatcher<LocalizerStatus>() {
          @Override
          public boolean matches(Object o) {
            LocalizerStatus status = (LocalizerStatus) o;
            return !containerId.equals(status.getLocalizerId());
          }
        }));
  }

  @Test
  @SuppressWarnings("unchecked")
  public void testLocalizerTokenIsGettingRemoved() throws Exception {
    FileContext fs = FileContext.getLocalFSFileContext();
    spylfs = spy(fs.getDefaultFileSystem());
    ContainerLocalizer localizer = setupContainerLocalizerForTest();
    doNothing().when(localizer).localizeFiles(any(LocalizationProtocol.class),
        any(CompletionService.class), any(UserGroupInformation.class));
    localizer.runLocalization(nmAddr);
    verify(spylfs, times(1)).delete(tokenPath, false);
  }

  @Test
  @SuppressWarnings("unchecked") // mocked generics
  public void testContainerLocalizerClosesFilesystems() throws Exception {
    // verify filesystems are closed when localizer doesn't fail
    FileContext fs = FileContext.getLocalFSFileContext();
    spylfs = spy(fs.getDefaultFileSystem());
    ContainerLocalizer localizer = setupContainerLocalizerForTest();
    doNothing().when(localizer).localizeFiles(any(LocalizationProtocol.class),
        any(CompletionService.class), any(UserGroupInformation.class));
    verify(localizer, never()).closeFileSystems(
        any(UserGroupInformation.class));
    localizer.runLocalization(nmAddr);
    verify(localizer).closeFileSystems(any(UserGroupInformation.class));

    spylfs = spy(fs.getDefaultFileSystem());
    // verify filesystems are closed when localizer fails
    localizer = setupContainerLocalizerForTest();
    doThrow(new YarnRuntimeException("Forced Failure")).when(localizer).localizeFiles(
        any(LocalizationProtocol.class), any(CompletionService.class),
        any(UserGroupInformation.class));
    verify(localizer, never()).closeFileSystems(
        any(UserGroupInformation.class));
    localizer.runLocalization(nmAddr);
    verify(localizer).closeFileSystems(any(UserGroupInformation.class));
  }

  @SuppressWarnings("unchecked") // mocked generics
  private ContainerLocalizer setupContainerLocalizerForTest()
      throws Exception {
    // don't actually create dirs
    doNothing().when(spylfs).mkdir(
        isA(Path.class), isA(FsPermission.class), anyBoolean());

    Configuration conf = new Configuration();
    FileContext lfs = FileContext.getFileContext(spylfs, conf);
    localDirs = new ArrayList<Path>();
    for (int i = 0; i < 4; ++i) {
      localDirs.add(lfs.makeQualified(new Path(basedir, i + "")));
    }
    RecordFactory mockRF = getMockLocalizerRecordFactory();
    ContainerLocalizer concreteLoc = new ContainerLocalizer(lfs, appUser,
        appId, containerId, localDirs, mockRF);
    ContainerLocalizer localizer = spy(concreteLoc);

    // return credential stream instead of opening local file
    random = new Random();
    long seed = random.nextLong();
    System.out.println("SEED: " + seed);
    random.setSeed(seed);
    DataInputBuffer appTokens = createFakeCredentials(random, 10);
    tokenPath =
      lfs.makeQualified(new Path(
            String.format(ContainerLocalizer.TOKEN_FILE_NAME_FMT,
                containerId)));
    doReturn(new FSDataInputStream(new FakeFSDataInputStream(appTokens))
        ).when(spylfs).open(tokenPath);
    nmProxy = mock(LocalizationProtocol.class);
    doReturn(nmProxy).when(localizer).getProxy(nmAddr);
    doNothing().when(localizer).sleep(anyInt());

    // return result instantly for deterministic test
    ExecutorService syncExec = mock(ExecutorService.class);
    CompletionService<Path> cs = mock(CompletionService.class);
    when(cs.submit(isA(Callable.class)))
      .thenAnswer(new Answer<Future<Path>>() {
          @Override
          public Future<Path> answer(InvocationOnMock invoc)
              throws Throwable {
            Future<Path> done = mock(Future.class);
            when(done.isDone()).thenReturn(true);
            FakeDownload d = (FakeDownload) invoc.getArguments()[0];
            when(done.get()).thenReturn(d.call());
            return done;
          }
        });
    doReturn(syncExec).when(localizer).createDownloadThreadPool();
    doReturn(cs).when(localizer).createCompletionService(syncExec);

    return localizer;
  }

  static class HBMatches extends ArgumentMatcher<LocalizerStatus> {
    final LocalResource rsrc;
    HBMatches(LocalResource rsrc) {
      this.rsrc = rsrc;
    }
    @Override
    public boolean matches(Object o) {
      LocalizerStatus status = (LocalizerStatus) o;
      for (LocalResourceStatus localized : status.getResources()) {
        switch (localized.getStatus()) {
        case FETCH_SUCCESS:
          if (localized.getLocalPath().getFile().contains(
                rsrc.getResource().getFile())) {
            return true;
          }
          break;
        default:
          fail("Unexpected: " + localized.getStatus());
          break;
        }
      }
      return false;
    }
  }

  static class FakeDownload implements Callable<Path> {
    private final Path localPath;
    private final boolean succeed;
    FakeDownload(String absPath, boolean succeed) {
      this.localPath = new Path("file:///localcache" + absPath);
      this.succeed = succeed;
    }
    @Override
    public Path call() throws IOException {
      if (!succeed) {
        throw new IOException("FAIL " + localPath);
      }
      return localPath;
    }
  }

  static RecordFactory getMockLocalizerRecordFactory() {
    RecordFactory mockRF = mock(RecordFactory.class);
    when(mockRF.newRecordInstance(same(LocalResourceStatus.class)))
      .thenAnswer(new Answer<LocalResourceStatus>() {
          @Override
          public LocalResourceStatus answer(InvocationOnMock invoc)
              throws Throwable {
            return new MockLocalResourceStatus();
          }
        });
    when(mockRF.newRecordInstance(same(LocalizerStatus.class)))
      .thenAnswer(new Answer<LocalizerStatus>() {
          @Override
          public LocalizerStatus answer(InvocationOnMock invoc)
              throws Throwable {
            return new MockLocalizerStatus();
          }
        });
    return mockRF;
  }

  static ResourceLocalizationSpec getMockRsrc(Random r,
      LocalResourceVisibility vis, Path p) {
    ResourceLocalizationSpec resourceLocalizationSpec =
      mock(ResourceLocalizationSpec.class);

    LocalResource rsrc = mock(LocalResource.class);
    String name = Long.toHexString(r.nextLong());
    URL uri = mock(org.apache.hadoop.yarn.api.records.URL.class);
    when(uri.getScheme()).thenReturn("file");
    when(uri.getHost()).thenReturn(null);
    when(uri.getFile()).thenReturn("/local/" + vis + "/" + name);

    when(rsrc.getResource()).thenReturn(uri);
    when(rsrc.getSize()).thenReturn(r.nextInt(1024) + 1024L);
    when(rsrc.getTimestamp()).thenReturn(r.nextInt(1024) + 2048L);
    when(rsrc.getType()).thenReturn(LocalResourceType.FILE);
    when(rsrc.getVisibility()).thenReturn(vis);

    when(resourceLocalizationSpec.getResource()).thenReturn(rsrc);
    when(resourceLocalizationSpec.getDestinationDirectory()).
      thenReturn(ConverterUtils.getYarnUrlFromPath(p));
    return resourceLocalizationSpec;
  }

  @SuppressWarnings({ "rawtypes", "unchecked" })
static DataInputBuffer createFakeCredentials(Random r, int nTok)
      throws IOException {
    Credentials creds = new Credentials();
    byte[] password = new byte[20];
    Text kind = new Text();
    Text service = new Text();
    Text alias = new Text();
    for (int i = 0; i < nTok; ++i) {
      byte[] identifier = ("idef" + i).getBytes();
      r.nextBytes(password);
      kind.set("kind" + i);
      service.set("service" + i);
      alias.set("token" + i);
      Token token = new Token(identifier, password, kind, service);
      creds.addToken(alias, token);
    }
    DataOutputBuffer buf = new DataOutputBuffer();
    creds.writeTokenStorageToStream(buf);
    DataInputBuffer ret = new DataInputBuffer();
    ret.reset(buf.getData(), 0, buf.getLength());
    return ret;
  }

}


text:
/* TEMPLATE GENERATED TESTCASE FILE
Filename: CWE121_Stack_Based_Buffer_Overflow__CWE131_loop_10.c
Label Definition File: CWE121_Stack_Based_Buffer_Overflow__CWE131.label.xml
Template File: sources-sink-10.tmpl.c
*/
/*
 * @description
 * CWE: 121 Stack Based Buffer Overflow
 * BadSource:  Allocate memory without using sizeof(int)
 * GoodSource: Allocate memory using sizeof(int)
 * Sink: loop
 *    BadSink : Copy array to data using a loop
 * Flow Variant: 10 Control flow: if(globalTrue) and if(globalFalse)
 *
 * */

#include "std_testcase.h"

#ifndef OMITBAD

void CWE121_Stack_Based_Buffer_Overflow__CWE131_loop_10_bad()
{
    int * data;
    data = NULL;
    if(globalTrue)
    {
        /* FLAW: Allocate memory without using sizeof(int) */
        data = (int *)ALLOCA(10);
    }
    {
        int source[10] = {0};
        size_t i;
        /* POTENTIAL FLAW: Possible buffer overflow if data was not allocated correctly in the source */
        for (i = 0; i < 10; i++)
        {
            data[i] = source[i];
        }
        printIntLine(data[0]);
    }
}

#endif /* OMITBAD */

#ifndef OMITGOOD

/* goodG2B1() - use goodsource and badsink by changing the globalTrue to globalFalse */
static void goodG2B1()
{
    int * data;
    data = NULL;
    if(globalFalse)
    {
        /* INCIDENTAL: CWE 561 Dead Code, the code below will never run */
        printLine("Benign, fixed string");
    }
    else
    {
        /* FIX: Allocate memory using sizeof(int) */
        data = (int *)ALLOCA(10*sizeof(int));
    }
    {
        int source[10] = {0};
        size_t i;
        /* POTENTIAL FLAW: Possible buffer overflow if data was not allocated correctly in the source */
        for (i = 0; i < 10; i++)
        {
            data[i] = source[i];
        }
        printIntLine(data[0]);
    }
}

/* goodG2B2() - use goodsource and badsink by reversing the blocks in the if statement */
static void goodG2B2()
{
    int * data;
    data = NULL;
    if(globalTrue)
    {
        /* FIX: Allocate memory using sizeof(int) */
        data = (int *)ALLOCA(10*sizeof(int));
    }
    {
        int source[10] = {0};
        size_t i;
        /* POTENTIAL FLAW: Possible buffer overflow if data was not allocated correctly in the source */
        for (i = 0; i < 10; i++)
        {
            data[i] = source[i];
        }
        printIntLine(data[0]);
    }
}

void CWE121_Stack_Based_Buffer_Overflow__CWE131_loop_10_good()
{
    goodG2B1();
    goodG2B2();
}

#endif /* OMITGOOD */

/* Below is the main(). It is only used when building this testcase on
 * its own for testing or for building a binary to use in testing binary
 * analysis tools. It is not used when compiling all the testcases as one
 * application, which is how source code analysis tools are tested.
 */

#ifdef INCLUDEMAIN

int main(int argc, char * argv[])
{
    /* seed randomness */
    srand( (unsigned)time(NULL) );
#ifndef OMITGOOD
    printLine("Calling good()...");
    CWE121_Stack_Based_Buffer_Overflow__CWE131_loop_10_good();
    printLine("Finished good()");
#endif /* OMITGOOD */
#ifndef OMITBAD
    printLine("Calling bad()...");
    CWE121_Stack_Based_Buffer_Overflow__CWE131_loop_10_bad();
    printLine("Finished bad()");
#endif /* OMITBAD */
    return 0;
}

#endif


text:
namespace Magnesium.Ktx
{
	public class TextureCatalog
	{
		#region ImageParameters
		public int MinFilter {get;set;}
		public int MagFilter { get; set; }
		/// <summary>
		/// horizontal
		/// </summary>
		public int TextureWrapS {get;set;}
		/// <summary>
		/// vertical
		/// </summary>
		public int TextureWrapT {get;set;}
		//public int TextureWrapR;
		#endregion
	}
}


text:
import { WorkReview } from './work-review';

const workReviews = new Array<WorkReview>();
// tslint:disable-next-line:max-line-length
workReviews.push(new WorkReview(1, 1, 2, 'Augustus Wallace', 3,  'Not bad, but lacks content to be good', 'Lorem ipsum', new Date(2019, 10, 29)));
workReviews.push(new WorkReview(2, 1, 3, 'Bill Riley', 5, 'Great work!', 'Lorem ipsum', new Date(2019, 10, 29)));

export const WorkReviewMock = workReviews;


text:
using System;
using System.Windows;
using EDEngineer.Localization;
using EDEngineer.Utils.System;

namespace EDEngineer.Views.Notifications
{
    /// <summary>
    /// Interaction logic for NotificationSettings.xaml
    /// </summary>
    public partial class NotificationSettingsWindow : System.Windows.Window
    {
        private readonly NotificationSettingsViewModel viewModel;
        public NotificationSettingsWindow(Languages languages)
        {
            viewModel = new NotificationSettingsViewModel(languages);
            DataContext = viewModel;
            InitializeComponent();
            BlueprintToastRadioButton.IsEnabled =
                Environment.OSVersion.Version >= new Version(6, 2, 9200, 0);
        }

        private void FavoriteBlueprintTestClicked(object sender, RoutedEventArgs e)
        {
            viewModel.TriggerFavoriteReady();
        }

        private void NotificationSettingsWindowClosed(object sender, EventArgs e)
        {
            viewModel.Dispose();
        }

        public static void InitNotifications()
        {
            if (string.IsNullOrEmpty(Properties.Settings.Default.NotificationKindBlueprintReady))
            {
                SettingsManager.NotificationKindBlueprintReady = NotificationKind.None;

                new NotificationSettingsWindow(Languages.Instance).ShowDialog();
            }
            else if(Environment.OSVersion.Version < new Version(6, 2, 9200, 0))
            {
                if (SettingsManager.NotificationKindBlueprintReady == NotificationKind.Toast)
                {
                    SettingsManager.NotificationKindBlueprintReady = NotificationKind.None;
                }
            }
        }

        private void OkButtonClicked(object sender, RoutedEventArgs e)
        {
            Close();
        }
    }
}