text:
import proto  # type: ignore

from google.cloud.automl_v1beta1.types import classification as gca_classification
from google.cloud.automl_v1beta1.types import detection
from google.cloud.automl_v1beta1.types import tables as gca_tables
from google.cloud.automl_v1beta1.types import text_extraction as gca_text_extraction
from google.cloud.automl_v1beta1.types import text_sentiment as gca_text_sentiment
from google.cloud.automl_v1beta1.types import translation as gca_translation

__protobuf__ = proto.module(
    package="google.cloud.automl.v1beta1",
    manifest={
        "AnnotationPayload",
    },
)

class AnnotationPayload(proto.Message):
    r"""Contains annotation information that is relevant to AutoML.

    This message has `oneof`_ fields (mutually exclusive fields).
    For each oneof, at most one member field can be set at the same time.
    Setting any member of the oneof automatically clears all other
    members.

    .. _oneof: https://proto-plus-python.readthedocs.io/en/stable/fields.html#oneofs-mutually-exclusive-fields

    Attributes:
        translation (google.cloud.automl_v1beta1.types.TranslationAnnotation):
            Annotation details for translation.

            This field is a member of `oneof`_ ``detail``.
        classification (google.cloud.automl_v1beta1.types.ClassificationAnnotation):
            Annotation details for content or image
            classification.

            This field is a member of `oneof`_ ``detail``.
        image_object_detection (google.cloud.automl_v1beta1.types.ImageObjectDetectionAnnotation):
            Annotation details for image object
            detection.

            This field is a member of `oneof`_ ``detail``.
        video_classification (google.cloud.automl_v1beta1.types.VideoClassificationAnnotation):
            Annotation details for video classification.
            Returned for Video Classification predictions.

            This field is a member of `oneof`_ ``detail``.
        video_object_tracking (google.cloud.automl_v1beta1.types.VideoObjectTrackingAnnotation):
            Annotation details for video object tracking.

            This field is a member of `oneof`_ ``detail``.
        text_extraction (google.cloud.automl_v1beta1.types.TextExtractionAnnotation):
            Annotation details for text extraction.

            This field is a member of `oneof`_ ``detail``.
        text_sentiment (google.cloud.automl_v1beta1.types.TextSentimentAnnotation):
            Annotation details for text sentiment.

            This field is a member of `oneof`_ ``detail``.
        tables (google.cloud.automl_v1beta1.types.TablesAnnotation):
            Annotation details for Tables.

            This field is a member of `oneof`_ ``detail``.
        annotation_spec_id (str):
            Output only . The resource ID of the
            annotation spec that this annotation pertains
            to. The annotation spec comes from either an
            ancestor dataset, or the dataset that was used
            to train the model in use.
        display_name (str):
            Output only. The value of
            [display_name][google.cloud.automl.v1beta1.AnnotationSpec.display_name]
            when the model was trained. Because this field returns a
            value at model training time, for different models trained
            using the same dataset, the returned value could be
            different as model owner could update the ``display_name``
            between any two model training.
    """

    translation = proto.Field(
        proto.MESSAGE,
        number=2,
        oneof="detail",
        message=gca_translation.TranslationAnnotation,
    )
    classification = proto.Field(
        proto.MESSAGE,
        number=3,
        oneof="detail",
        message=gca_classification.ClassificationAnnotation,
    )
    image_object_detection = proto.Field(
        proto.MESSAGE,
        number=4,
        oneof="detail",
        message=detection.ImageObjectDetectionAnnotation,
    )
    video_classification = proto.Field(
        proto.MESSAGE,
        number=9,
        oneof="detail",
        message=gca_classification.VideoClassificationAnnotation,
    )
    video_object_tracking = proto.Field(
        proto.MESSAGE,
        number=8,
        oneof="detail",
        message=detection.VideoObjectTrackingAnnotation,
    )
    text_extraction = proto.Field(
        proto.MESSAGE,
        number=6,
        oneof="detail",
        message=gca_text_extraction.TextExtractionAnnotation,
    )
    text_sentiment = proto.Field(
        proto.MESSAGE,
        number=7,
        oneof="detail",
        message=gca_text_sentiment.TextSentimentAnnotation,
    )
    tables = proto.Field(
        proto.MESSAGE,
        number=10,
        oneof="detail",
        message=gca_tables.TablesAnnotation,
    )
    annotation_spec_id = proto.Field(
        proto.STRING,
        number=1,
    )
    display_name = proto.Field(
        proto.STRING,
        number=5,
    )

__all__ = tuple(sorted(__protobuf__.manifest))


text:
<?php

namespace App\Http\Streamers;

use App\Models\Setting;

class XAccelRedirectStreamer extends Streamer implements StreamerInterface
{
    /**
     * Stream the current song using nginx's X-Accel-Redirect.
     */
    public function stream()
    {
        $relativePath = str_replace(Setting::get('media_path'), '', $this->song->path);

        // We send our media_path value as a 'X-Media-Root' header to downstream (nginx)
        // It will then be use as `alias` in X-Accel config location block.
        // See nginx.conf.example.
        header('X-Media-Root: '.Setting::get('media_path'));
        header('X-Accel-Redirect: /media/'.$relativePath);
        header("Content-Type: {$this->contentType}");
        header('Content-Disposition: inline; filename="'.basename($this->song->path).'"');

        exit;
    }
}

redpajama_set_name: RedPajamaGithub


text:
<!--
  ~ Copyright 2019 Google LLC
  ~
  ~ Licensed under the Apache License, Version 2.0 (the "License");
  ~ you may not use this file except in compliance with the License.
  ~ You may obtain a copy of the License at
  ~
  ~     https://www.apache.org/licenses/LICENSE-2.0
  ~
  ~ Unless required by applicable law or agreed to in writing, software
  ~ distributed under the License is distributed on an "AS IS" BASIS,
  ~ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  ~ See the License for the specific language governing permissions and
  ~ limitations under the License.
  -->

<vector xmlns:android="http://schemas.android.com/apk/res/android"
    android:width="96dp"
    android:height="54dp"
    android:viewportWidth="192"
    android:viewportHeight="108">
    <path
        android:fillColor="#FDE293"
        android:pathData="M150,-182.5v244.81c0,3.12,3.69,4.82,6.11,2.81l289.37,-241.14z" />
    <path
        android:pathData="M219.72,133.71a93.13,92.97,9,1,0,-185.94,0"
        android:strokeColor="#EE675C"
        android:strokeWidth="3.96" />
    <path
        android:pathData="M23,0V58.5H100,V108"
        android:strokeColor="#4285F4"
        android:strokeWidth="3.96" />

</vector>


text:
[![Build Status](https://travis-ci.org/ermanno-pirotta/grunt-file-convert.svg?branch=master)](https://travis-ci.org/ermanno-pirotta/grunt-file-convert)

[![Codacy Badge](https://api.codacy.com/project/badge/Grade/f09e3febfb8a46d7aab2e85574c2b0f8)](https://www.codacy.com/app/ermanno-pirotta/grunt-file-convert?utm_source=github.com&utm_medium=referral&utm_content=ermanno-pirotta/grunt-file-convert&utm_campaign=Badge_Grade)

# grunt-file-convert

> Parses a set of input files, applies some custom trasformation to each read line, and writes the result of the trasformation to a set of output files.

## Getting Started
This plugin requires Grunt `~0.4.5`

If you haven't used [Grunt](http://gruntjs.com/) before, be sure to check out the [Getting Started](http://gruntjs.com/getting-started) guide, as it explains how to create a [Gruntfile](http://gruntjs.com/sample-gruntfile) as well as install and use Grunt plugins. Once you're familiar with that process, you may install this plugin with this command:

```shell
npm install grunt-file-convert --save-dev
```

Once the plugin has been installed, it may be enabled inside your Gruntfile with this line of JavaScript:

```js
grunt.loadNpmTasks('grunt-file-convert');
```

## The "file_convert" task

### Overview
In your project's Gruntfile, add a section named `file_convert` to the data object passed into `grunt.initConfig()`.

```js
grunt.initConfig({
  file_convert: {
    options: {
      // Task-specific options go here.
    },
    your_target: {
      // Target-specific file lists and/or options go here.
    },
  },
});
```

### Options

#### options.skipRegex
Type: `String`
Default value: undefined

A string value that is used as a regex to check the lines to be skipped.

#### options.filePrefix
Type: `String`
Default value: ''

A string value that is prepended to the result file.

#### options.filePostfix
Type: `String`
Default value: ''

A string value that is appended to the result file.

#### options.transformer
Type: `Function`
Default value: `function(line, index){return line;}`

A function that applies a transformation to each line of the source file.

### Usage Examples

#### Skip lines with javascript comments
In this example, skipRegex option is used to skip all the lines which adheres to the javascript multiline comment format. So if the `source` file has the content `/* asdas */ \n abc` the generated result would be `abc`.

```js
grunt.initConfig({
  file_convert: {
    files: {
      'tmp/remove_lines': ['test/fixtures/input_file_with_lines_to_be_removed']
    },

    options: {
        skipRegex: '^\\/\\*.*\\*\/$'
    }
  },
});
```

#### Apply a custom transformer
In this example, a custom transformer is used. So if the `source` file has contains the string `TO BE TRANSFORMED` the generated result in this case would be `TRANSFORMED!!!`

```js
grunt.initConfig({
  file_convert: {
    files: {
      'tmp/trasform_lines': ['test/fixtures/input_file_to_be_transformed']
    },

    options: {
      transformer: function(line){
          var regex = new RegExp("TO BE TRANSFORMED");
          return line.replace(regex,'TRANSFORMED!!!');
      }
    }
  },
});
```

## Contributing
In lieu of a formal styleguide, take care to maintain the existing coding style. Add unit tests for any new or changed functionality. Lint and test your code using [Grunt](http://gruntjs.com/).

## Release History
_(Nothing yet)_


text:
package com.gsma.android.xoperatorapidemo.activity.payment;

import android.content.Intent;
import android.net.Uri;
import android.os.Bundle;
import android.util.Log;
import android.view.View;
import android.widget.Button;
import android.widget.TextView;

import com.gsma.android.xoperatorapidemo.R;
import com.gsma.android.xoperatorapidemo.activity.MainActivity;
import com.gsma.android.xoperatorapidemo.discovery.DiscoveryData;
import com.gsma.android.xoperatorapidemo.payment.AmountReservationTransaction;
import com.gsma.android.xoperatorapidemo.payment.AmountTransaction;
import com.gsma.android.xoperatorapidemo.payment.PaymentStates;
import com.gsma.android.xoperatorapidemo.utils.ParameterList;

public class PaymentConsentCompleteActivity extends PaymentAbstractActivity {
	private static final String TAG = "PaymentConsentCompleteActivity";

	PaymentConsentCompleteActivity paymentConsentCompleteActivityInstance = null;

	String transactionOperationStatus;
	String resourceURL;
	String transactionId;

	DiscoveryData discoveryData=null;

	TextView paymentConsentCompleteStatusValue=null;
	TextView paymentConsentCompleteTransactionIdValue=null;
	TextView paymentConsentCompleteServerReferenceValue=null;

	Button paymentConsentCompleteQuery=null;
	Button paymentConsentCompleteChargeReservation=null;

	public static AmountTransaction amountTransaction=null;
	public static AmountReservationTransaction amountReservationTransaction=null;

	boolean payment1Phase=false;
	boolean payment2Phase=false;

	@Override
	public void onCreate(Bundle savedInstanceState) {
		super.onCreate(savedInstanceState);
		paymentConsentCompleteActivityInstance = this;
		setContentView(R.layout.activity_payment_consent_complete);

		paymentConsentCompleteQuery = (Button) findViewById(R.id.paymentConsentCompleteQuery);
		paymentConsentCompleteChargeReservation = (Button) findViewById(R.id.paymentConsentCompleteChargeReservation);

		paymentConsentCompleteStatusValue = (TextView) findViewById(R.id.paymentConsentCompleteStatusValue);
		paymentConsentCompleteTransactionIdValue = (TextView) findViewById(R.id.paymentConsentCompleteTransactionIdValue);
		paymentConsentCompleteServerReferenceValue = (TextView) findViewById(R.id.paymentConsentCompleteServerReferenceValue);

	}

	@Override
	public void onStart() {
		super.onStart();
		Log.d(TAG, "onStart called ");

		discoveryData=MainActivity.getDiscoveryData();

		paymentConsentCompleteQuery.setVisibility(View.INVISIBLE);
		paymentConsentCompleteChargeReservation.setVisibility(View.INVISIBLE);

		Uri data = getIntent().getData();
		String queryPart=data.getQuery();

		Log.d(TAG, "Received "+queryPart);

		ParameterList parameters=ParameterList.getKeyValuesFromUrl(queryPart, 0);

		transactionOperationStatus = parameters.getValue("transactionOperationStatus");
		resourceURL = parameters.getValue("resourceURL");
		transactionId = parameters.getValue("transactionId");

		Log.d(TAG, "received transactionOperationStatus = " + transactionOperationStatus);
		Log.d(TAG, "received resourceURL = " + resourceURL);
		Log.d(TAG, "received transactionId = " + transactionId);

		paymentConsentCompleteStatusValue.setText(transactionOperationStatus);
		paymentConsentCompleteTransactionIdValue.setText(transactionId);

		if (transactionOperationStatus!=null && transactionId!=null) {
			String chargeEndpoint=discoveryData.getResponse().getApi("payment").getHref("charge");
			String reserveEndpoint=discoveryData.getResponse().getApi("payment").getHref("reserve");
			String expectedEndpoint=null;
			if (transactionOperationStatus.equalsIgnoreCase(PaymentStates.CHARGED) && chargeEndpoint!=null) {
				expectedEndpoint=chargeEndpoint+(!chargeEndpoint.endsWith("/")?"/":"")+transactionId;
				Log.d(TAG, "expectedEndpoint="+expectedEndpoint);
				payment1Phase=true;
			} else if (transactionOperationStatus.equalsIgnoreCase(PaymentStates.RESERVED) && reserveEndpoint!=null) {
				expectedEndpoint=reserveEndpoint+(!reserveEndpoint.endsWith("/")?"/":"")+transactionId;
				Log.d(TAG, "expectedEndpoint="+expectedEndpoint);
				payment2Phase=true;
			}
			if (expectedEndpoint==null) {
				//TODO
			} else if (resourceURL==null) {
				resourceURL=expectedEndpoint;
			} else if (!expectedEndpoint.equals(resourceURL)) {
				//TODO
				Log.d(TAG, expectedEndpoint+" <> "+resourceURL);
				resourceURL=expectedEndpoint;
			}
			if (resourceURL!=null) {
				paymentConsentCompleteQuery.setVisibility(View.VISIBLE);
			}
		}
	}

	/*
	 * go back to the main screen
	 */
	public void home(View view) {
		Intent intent = new Intent(paymentConsentCompleteActivityInstance,
				MainActivity.class);
		startActivity(intent);
	}

	public void claim(View view) {
		Log.d(TAG, "claim payment");
		ReservationClaimTask reservationClaimTask=new ReservationClaimTask(paymentConsentCompleteActivityInstance, discoveryData, resourceURL,
				payment2Phase, transactionOperationStatus, amountReservationTransaction);
		reservationClaimTask.execute();
	}

	public void query(View view) {
		Log.d(TAG, "query payment");
		PaymentQueryTask paymentQueryTask=new PaymentQueryTask(paymentConsentCompleteActivityInstance, discoveryData, resourceURL, payment1Phase, payment2Phase,
			 transactionOperationStatus);
		paymentQueryTask.execute();
	}

	@Override
	void processQueryResponse(Object response) {
		if (response!=null) {
			if (response instanceof AmountTransaction) {
				amountTransaction=(AmountTransaction) response;
        		paymentConsentCompleteServerReferenceValue.setText(amountTransaction.getServerReferenceCode());
			} else if (response instanceof AmountReservationTransaction) {
				amountReservationTransaction=(AmountReservationTransaction) response;
        		transactionOperationStatus=amountReservationTransaction.getTransactionOperationStatus();
        		paymentConsentCompleteServerReferenceValue.setText(amountReservationTransaction.getServerReferenceCode());

				if (transactionOperationStatus!=null && transactionOperationStatus.equalsIgnoreCase(PaymentStates.RESERVED)) {
					paymentConsentCompleteChargeReservation.setVisibility(View.VISIBLE);
				}
			}
		}
	}

	@Override
	void processClaimResponse(AmountReservationTransaction response) {
		if (response!=null) {
    		paymentConsentCompleteStatusValue.setText(response.getTransactionOperationStatus());
		}
	}

}


text:
package org.jgrades.logging.job;

public class XmlConfigurationUpdaterTest {

}


text:
@(resetUrl:String)

Did you forget your CFP @Messages("longName") access code?

Someone asked to reset your @Messages("longName") access code. If it was you, please read the instructions below. If it wasn't, you can disregard this emails and no evil will be done.

@Html(resetUrl)

Please visit this link to reset your access code.

We don't want to store your super secret password, that might be the same one as your Google Account. We prefer to generate
a random access code. We also encourage you to use one of our OpenID's providers like Github or Google+. Simpler, more secure, that just rocks!

The @Messages("longName") team

@if(ConferenceDescriptor.current().frLangEnabled) {

Mot de passe oublié sur le site du CFP de @Messages("longName") ?

Quelqu'un a demandé à modifier le mot de passe pour le site de l'appel aux conférenciers de @Messages("longName").
Si ce n'était pas vous, pas de soucis, ignorez simplement ce courrier.

Pour réinitialiser votre mot de passe, merci de visiter cette URL :

@Html(resetUrl)

Nous ne voulons pas stocker vos mots de passe et nous préférons les générer au hasard. Par ailleurs, nous vous encourageons à
utiliser votre profil Github ou Google+ pour vous authentifier. Plus simple, plus moderne.

L'équipe @Messages("longName")

}


text:
package Question4_2;

class Node {
    private Node adjacent[];
    public int adjacentCount;
    private String vertex;
    public Question.State state;
    public Node(String vertex, int adjacentLength) {
        this.vertex = vertex;
        adjacentCount = 0;
        adjacent = new Node[adjacentLength];
    }

    public void addAdjacent(Node x) {
        if (adjacentCount < 30) {
            this.adjacent[adjacentCount] = x;
            adjacentCount++;
        } else {
            System.out.print("No more adjacent can be added");
        }
    }
    public Node[] getAdjacent() {
        return adjacent;
    }
    public String getVertex() {
        return vertex;
    }
}


text:
module CNN.Image (
  Image
, Plain
, Class
, Trainer
, classNumToVec
) where

import qualified Data.Map as M
import Numeric.LinearAlgebra.Data

type Plain = Matrix R    -- 2D: X x Y pixels
type Image = [Plain]     -- n dimension

type Class = Vector R    -- teacher vector

type Trainer = (Image, Class)

-- FUNCTIONS

classNumToVec :: Int -> Int -> Class
classNumToVec n c = fromList ls
  where
    ls = take n (replicate c 0.0 ++ [1.0] ++ repeat 0.0)


text:
package com.amazonaws.services.logs.model.transform;

import static com.amazonaws.util.StringUtils.UTF8;
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.OutputStreamWriter;
import java.io.StringWriter;
import java.io.Writer;
import java.util.Map;
import java.util.List;

import com.amazonaws.AmazonClientException;
import com.amazonaws.services.logs.model.*;
import com.amazonaws.transform.Marshaller;
import com.amazonaws.util.BinaryUtils;
import com.amazonaws.util.StringUtils;
import com.amazonaws.util.StringInputStream;
import com.amazonaws.util.json.*;

/**
 * ExportTaskMarshaller
 */
public class ExportTaskJsonMarshaller {

    /**
     * Marshall the given parameter object, and output to a JSONWriter
     */
    public void marshall(ExportTask exportTask, JSONWriter jsonWriter) {
        if (exportTask == null) {
            throw new AmazonClientException(
                    "Invalid argument passed to marshall(...)");
        }

        try {
            jsonWriter.object();

            if (exportTask.getTaskId() != null) {
                jsonWriter.key("taskId").value(exportTask.getTaskId());
            }

            if (exportTask.getTaskName() != null) {
                jsonWriter.key("taskName").value(exportTask.getTaskName());
            }

            if (exportTask.getLogGroupName() != null) {
                jsonWriter.key("logGroupName").value(
                        exportTask.getLogGroupName());
            }

            if (exportTask.getFrom() != null) {
                jsonWriter.key("from").value(exportTask.getFrom());
            }

            if (exportTask.getTo() != null) {
                jsonWriter.key("to").value(exportTask.getTo());
            }

            if (exportTask.getDestination() != null) {
                jsonWriter.key("destination")
                        .value(exportTask.getDestination());
            }

            if (exportTask.getDestinationPrefix() != null) {
                jsonWriter.key("destinationPrefix").value(
                        exportTask.getDestinationPrefix());
            }

            if (exportTask.getStatus() != null) {
                jsonWriter.key("status");
                ExportTaskStatusJsonMarshaller.getInstance().marshall(
                        exportTask.getStatus(), jsonWriter);
            }

            if (exportTask.getExecutionInfo() != null) {
                jsonWriter.key("executionInfo");
                ExportTaskExecutionInfoJsonMarshaller.getInstance().marshall(
                        exportTask.getExecutionInfo(), jsonWriter);
            }

            jsonWriter.endObject();
        } catch (Throwable t) {
            throw new AmazonClientException(
                    "Unable to marshall request to JSON: " + t.getMessage(), t);
        }
    }

    private static ExportTaskJsonMarshaller instance;

    public static ExportTaskJsonMarshaller getInstance() {
        if (instance == null)
            instance = new ExportTaskJsonMarshaller();
        return instance;
    }

}


text:
var clone = require("clone");
var log = require("@node-red/util").log;
var util = require("@node-red/util").util;
var memory = require("./memory");
var flows;

var settings;

// A map of scope id to context instance
var contexts = {};

// A map of store name to instance
var stores = {};
var storeList = [];
var defaultStore;

// Whether there context storage has been configured or left as default
var hasConfiguredStore = false;

// Unknown Stores
var unknownStores = {};

function logUnknownStore(name) {
    if (name) {
        var count = unknownStores[name] || 0;
        if (count == 0) {
            log.warn(log._("context.unknown-store", {name: name}));
            count++;
            unknownStores[name] = count;
        }
    }
}

function init(_settings) {
    flows = require("../flows");
    settings = _settings;
    contexts = {};
    stores = {};
    storeList = [];
    hasConfiguredStore = false;
    var seed = settings.functionGlobalContext || {};
    contexts['global'] = createContext("global",seed);
    // create a default memory store - used by the unit tests that skip the full
    // `load()` initialisation sequence.
    // If the user has any stores configured, this will be disgarded
    stores["_"] = new memory();
    defaultStore = "memory";
}

function load() {
    return new Promise(function(resolve,reject) {
        // load & init plugins in settings.contextStorage
        var plugins = settings.contextStorage || {};
        var defaultIsAlias = false;
        var promises = [];
        if (plugins && Object.keys(plugins).length > 0) {
            var hasDefault = plugins.hasOwnProperty('default');
            var defaultName;
            for (var pluginName in plugins) {
                if (plugins.hasOwnProperty(pluginName)) {
                    // "_" is a reserved name - do not allow it to be overridden
                    if (pluginName === "_") {
                        continue;
                    }
                    if (!/^[a-zA-Z0-9_]+$/.test(pluginName)) {
                        return reject(new Error(log._("context.error-invalid-module-name", {name:pluginName})));
                    }

                    // Check if this is setting the 'default' context to be a named plugin
                    if (pluginName === "default" && typeof plugins[pluginName] === "string") {
                        // Check the 'default' alias exists before initialising anything
                        if (!plugins.hasOwnProperty(plugins[pluginName])) {
                            return reject(new Error(log._("context.error-invalid-default-module", {storage:plugins["default"]})));
                        }
                        defaultIsAlias = true;
                        continue;
                    }
                    if (!hasDefault && !defaultName) {
                        defaultName = pluginName;
                    }
                    var plugin;
                    if (plugins[pluginName].hasOwnProperty("module")) {
                        // Get the provided config and copy in the 'approved' top-level settings (eg userDir)
                        var config = plugins[pluginName].config || {};
                        copySettings(config, settings);

                        if (typeof plugins[pluginName].module === "string") {
                            // This config identifies the module by name - assume it is a built-in one
                            // TODO: check it exists locally, if not, try to require it as-is
                            try {
                                plugin = require("./"+plugins[pluginName].module);
                            } catch(err) {
                                return reject(new Error(log._("context.error-loading-module2", {module:plugins[pluginName].module,message:err.toString()})));
                            }
                        } else {
                            // Assume `module` is an already-required module we can use
                            plugin = plugins[pluginName].module;
                        }
                        try {
                            // Create a new instance of the plugin by calling its module function
                            stores[pluginName] = plugin(config);
                            var moduleInfo = plugins[pluginName].module;
                            if (typeof moduleInfo !== 'string') {
                                if (moduleInfo.hasOwnProperty("toString")) {
                                    moduleInfo = moduleInfo.toString();
                                } else {
                                    moduleInfo = "custom";
                                }
                            }
                            log.info(log._("context.log-store-init", {name:pluginName, info:"module="+moduleInfo}));
                        } catch(err) {
                            return reject(new Error(log._("context.error-loading-module2",{module:pluginName,message:err.toString()})));
                        }
                    } else {
                        // Plugin does not specify a 'module'
                        return reject(new Error(log._("context.error-module-not-defined", {storage:pluginName})));
                    }
                }
            }

            // Open all of the configured contexts
            for (var plugin in stores) {
                if (stores.hasOwnProperty(plugin)) {
                    promises.push(stores[plugin].open());
                }
            }
            // There is a 'default' listed in the configuration
            if (hasDefault) {
                // If 'default' is an alias, point it at the right module - we have already
                // checked that it exists. If it isn't an alias, then it will
                // already be set to a configured store
                if (defaultIsAlias) {
                    stores["_"] =  stores[plugins["default"]];
                    defaultStore = plugins["default"];
                } else {
                    stores["_"] = stores["default"];
                    defaultStore = "default";
                }
            } else if (defaultName) {
                // No 'default' listed, so pick first in list as the default
                stores["_"] = stores[defaultName];
                defaultStore = defaultName;
                defaultIsAlias = true;
            } else {
                // else there were no stores list the config object - fall through
                // to below where we default to a memory store
                storeList = ["memory"];
                defaultStore = "memory";
            }
            hasConfiguredStore = true;
            storeList = Object.keys(stores).filter(n=>!(defaultIsAlias && n==="default") && n!== "_");
        } else {
            // No configured plugins
            log.info(log._("context.log-store-init", {name:"default", info:"module=memory"}));
            promises.push(stores["_"].open())
            storeList = ["memory"];
            defaultStore = "memory";
        }
        return resolve(Promise.all(promises));
    }).catch(function(err) {
        throw new Error(log._("context.error-loading-module",{message:err.toString()}));
    });
}

function copySettings(config, settings){
    var copy = ["userDir"]
    config.settings = {};
    copy.forEach(function(setting){
        config.settings[setting] = clone(settings[setting]);
    });
}

function getContextStorage(storage) {
    if (stores.hasOwnProperty(storage)) {
        // A known context
        return stores[storage];
    } else if (stores.hasOwnProperty("_")) {
        // Not known, but we have a default to fall back to
        if (storage !== defaultStore) {
            // It isn't the default store either, so log it
            logUnknownStore(storage);
        }
        return stores["_"];
    }
}

function followParentContext(parent, key) {
    if (key === "$parent") {
        return [parent, undefined];
    }
    else if (key.startsWith("$parent.")) {
        var len = "$parent.".length;
        var new_key = key.substring(len);
        var ctx = parent;
        while (ctx && new_key.startsWith("$parent.")) {
            ctx = ctx.$parent;
            new_key = new_key.substring(len);
        }
        return [ctx, new_key];
    }
    return null;
}

function createContext(id,seed,parent) {
    // Seed is only set for global context - sourced from functionGlobalContext
    var scope = id;
    var obj = seed || {};
    var seedKeys;
    var insertSeedValues;
    if (seed) {
        seedKeys = Object.keys(seed);
        insertSeedValues = function(keys,values) {
            if (!Array.isArray(keys)) {
                if (values[0] === undefined) {
                    try {
                        values[0] = util.getObjectProperty(seed,keys);
                    } catch(err) {
                        if (err.code === "INVALID_EXPR") {
                            throw err;
                        }
                        values[0] = undefined;
                    }
                }
            } else {
                for (var i=0;i<keys.length;i++) {
                    if (values[i] === undefined) {
                        try {
                            values[i] = util.getObjectProperty(seed,keys[i]);
                        } catch(err) {
                            if (err.code === "INVALID_EXPR") {
                                throw err;
                            }
                            values[i] = undefined;
                        }
                    }
                }
            }
        }
    }
    Object.defineProperties(obj, {
        get: {
            value: function(key, storage, callback) {
                var context;

                if (!callback && typeof storage === 'function') {
                    callback = storage;
                    storage = undefined;
                }
                if (callback && typeof callback !== 'function'){
                    throw new Error("Callback must be a function");
                }

                if (!Array.isArray(key)) {
                    var keyParts = util.parseContextStore(key);
                    key = keyParts.key;
                    if (!storage) {
                        storage = keyParts.store || "_";
                    }
                    var result = followParentContext(parent, key);
                    if (result) {
                        var [ctx, new_key] = result;
                        if (ctx && new_key) {
                            return ctx.get(new_key, storage, callback);
                        }
                        else {
                            if (callback) {
                                return callback(undefined);
                            }
                            else {
                                return undefined;
                            }
                        }
                    }
                } else {
                    if (!storage) {
                        storage = "_";
                    }
                }
                context = getContextStorage(storage);

                if (callback) {
                    if (!seed) {
                        context.get(scope,key,callback);
                    } else {
                        context.get(scope,key,function() {
                            if (arguments[0]) {
                                callback(arguments[0]);
                                return;
                            }
                            var results = Array.prototype.slice.call(arguments,[1]);
                            try {
                                insertSeedValues(key,results);
                            } catch(err) {
                                callback.apply(err);
                                return
                            }
                            // Put the err arg back
                            results.unshift(undefined);
                            callback.apply(null,results);
                        });
                    }
                } else {
                    // No callback, attempt to do this synchronously
                    var results = context.get(scope,key);
                    if (seed) {
                        if (Array.isArray(key)) {
                            insertSeedValues(key,results);
                        } else if (results === undefined){
                            try {
                                results = util.getObjectProperty(seed,key);
                            } catch(err) {
                                if (err.code === "INVALID_EXPR") {
                                    throw err;
                                }
                                results = undefined;
                            }
                        }
                    }
                    return results;
                }
            }
        },
        set: {
            value: function(key, value, storage, callback) {
                var context;

                if (!callback && typeof storage === 'function') {
                    callback = storage;
                    storage = undefined;
                }
                if (callback && typeof callback !== 'function'){
                    throw new Error("Callback must be a function");
                }

                if (!Array.isArray(key)) {
                    var keyParts = util.parseContextStore(key);
                    key = keyParts.key;
                    if (!storage) {
                        storage = keyParts.store || "_";
                    }
                    var result = followParentContext(parent, key);
                    if (result) {
                        var [ctx, new_key] = result;
                        if (ctx && new_key) {
                            return ctx.set(new_key, value, storage, callback);
                        }
                        else {
                            if (callback) {
                                return callback();
                            }
                            return undefined;
                        }
                    }
                } else {
                    if (!storage) {
                        storage = "_";
                    }
                }
                context = getContextStorage(storage);

                context.set(scope, key, value, callback);
            }
        },
        keys: {
            value: function(storage, callback) {
                var context;
                if (!storage && !callback) {
                    context = stores["_"];
                } else {
                    if (typeof storage === 'function') {
                        callback = storage;
                        storage = "_";
                    }
                    if (callback && typeof callback !== 'function') {
                        throw new Error("Callback must be a function");
                    }
                    context = getContextStorage(storage);
                }
                if (seed && settings.exportGlobalContextKeys !== false) {
                    if (callback) {
                        context.keys(scope, function(err,keys) {
                            callback(err,Array.from(new Set(seedKeys.concat(keys)).keys()));
                        });
                    } else {
                        var keys = context.keys(scope);
                        return Array.from(new Set(seedKeys.concat(keys)).keys())
                    }
                } else {
                    return context.keys(scope, callback);
                }
            }
        }
    });
    if (parent) {
        Object.defineProperty(obj, "$parent", {
            value: parent
        });
    }
    return obj;
}

function createRootContext() {
    var obj = {};
    Object.defineProperties(obj, {
        get: {
            value: function(key, storage, callback) {
                return undefined;
            }
        },
        set: {
            value: function(key, value, storage, callback) {
            }
        },
        keys: {
            value: function(storage, callback) {
                return undefined;
            }
        }
    });
    return obj;
}

function getContext(localId,flowId,parent) {
    var contextId = localId;
    if (flowId) {
        contextId = localId+":"+flowId;
    }
    if (contexts.hasOwnProperty(contextId)) {
        return contexts[contextId];
    }
    var newContext = createContext(contextId,undefined,parent);
    if (flowId) {
        var node = flows.get(flowId);
        var parent = undefined;
        if (node && node.type.startsWith("subflow:")) {
            parent = node.context().flow;
        }
        else {
            parent = createRootContext();
        }
        var flowContext = getContext(flowId,undefined,parent);
        Object.defineProperty(newContext, 'flow', {
            value: flowContext
        });
    }
    Object.defineProperty(newContext, 'global', {
        value: contexts['global']
    })
    contexts[contextId] = newContext;
    return newContext;
}

function deleteContext(id,flowId) {
    if(!hasConfiguredStore){
        // only delete context if there's no configured storage.
        var contextId = id;
        if (flowId) {
            contextId = id+":"+flowId;
        }
        delete contexts[contextId];
        return stores["_"].delete(contextId);
    }else{
        return Promise.resolve();
    }
}

function clean(flowConfig) {
    var promises = [];
    for(var plugin in stores){
        if(stores.hasOwnProperty(plugin)){
            promises.push(stores[plugin].clean(Object.keys(flowConfig.allNodes)));
        }
    }
    for (var id in contexts) {
        if (contexts.hasOwnProperty(id) && id !== "global") {
            var idParts = id.split(":");
            if (!flowConfig.allNodes.hasOwnProperty(idParts[0])) {
                delete contexts[id];
            }
        }
    }
    return Promise.all(promises);
}

function close() {
    var promises = [];
    for(var plugin in stores){
        if(stores.hasOwnProperty(plugin)){
            promises.push(stores[plugin].close());
        }
    }
    return Promise.all(promises);
}

function listStores() {
    return {default:defaultStore,stores:storeList};
}

module.exports = {
    init: init,
    load: load,
    listStores: listStores,
    get: getContext,
    delete: deleteContext,
    clean: clean,
    close: close
};


text:
/* eslint-disable */

'use strict';

// @dataDrivenDependency RelayModernEnvironmentWithOperationTrackerTestFeedbackFragment.author.nameRenderer {"branches":{"MarkdownUserNameRenderer":{"component":"MarkdownUserNameRenderer.react","fragment":"RelayModernEnvironmentWithOperationTrackerTestMarkdownUserNameRenderer_name$normalization.graphql"},"PlainUserNameRenderer":{"component":"PlainUserNameRenderer.react","fragment":"RelayModernEnvironmentWithOperationTrackerTestPlainUserNameRenderer_name$normalization.graphql"}},"plural":false}
// @dataDrivenDependency RelayModernEnvironmentWithOperationTrackerTestFeedbackFragment.author.plainNameRenderer {"branches":{"PlainUserNameRenderer":{"component":"PlainUserNameRenderer.react","fragment":"RelayModernEnvironmentWithOperationTrackerTestPlainUserNameRenderer_name$normalization.graphql"}},"plural":false}

/*::
import type { Fragment, ReaderFragment } from 'relay-runtime';
import type { RelayModernEnvironmentWithOperationTrackerTestMarkdownUserNameRenderer_name$fragmentType } from "./RelayModernEnvironmentWithOperationTrackerTestMarkdownUserNameRenderer_name.graphql";
import type { RelayModernEnvironmentWithOperationTrackerTestPlainUserNameRenderer_name$fragmentType } from "./RelayModernEnvironmentWithOperationTrackerTestPlainUserNameRenderer_name.graphql";
import type { FragmentType } from "relay-runtime";
declare export opaque type RelayModernEnvironmentWithOperationTrackerTestFeedbackFragment$fragmentType: FragmentType;
export type RelayModernEnvironmentWithOperationTrackerTestFeedbackFragment$data = {|
  +author: ?{|
    +__typename: "User",
    +nameRenderer: ?{|
      +__fragmentPropName?: ?string,
      +__module_component?: ?string,
      +$fragmentSpreads: RelayModernEnvironmentWithOperationTrackerTestMarkdownUserNameRenderer_name$fragmentType & RelayModernEnvironmentWithOperationTrackerTestPlainUserNameRenderer_name$fragmentType,
    |},
    +plainNameRenderer: ?{|
      +__fragmentPropName?: ?string,
      +__module_component?: ?string,
      +$fragmentSpreads: RelayModernEnvironmentWithOperationTrackerTestPlainUserNameRenderer_name$fragmentType,
    |},
  |},
  +body: ?{|
    +text: ?string,
  |},
  +id: string,
  +$fragmentType: RelayModernEnvironmentWithOperationTrackerTestFeedbackFragment$fragmentType,
|};
export type RelayModernEnvironmentWithOperationTrackerTestFeedbackFragment$key = {
  +$data?: RelayModernEnvironmentWithOperationTrackerTestFeedbackFragment$data,
  +$fragmentSpreads: RelayModernEnvironmentWithOperationTrackerTestFeedbackFragment$fragmentType,
  ...
};
*/

var node/*: ReaderFragment*/ = {
  "argumentDefinitions": [],
  "kind": "Fragment",
  "metadata": null,
  "name": "RelayModernEnvironmentWithOperationTrackerTestFeedbackFragment",
  "selections": [
    {
      "alias": null,
      "args": null,
      "kind": "ScalarField",
      "name": "id",
      "storageKey": null
    },
    {
      "alias": null,
      "args": null,
      "concreteType": "Text",
      "kind": "LinkedField",
      "name": "body",
      "plural": false,
      "selections": [
        {
          "alias": null,
          "args": null,
          "kind": "ScalarField",
          "name": "text",
          "storageKey": null
        }
      ],
      "storageKey": null
    },
    {
      "alias": null,
      "args": null,
      "concreteType": "User",
      "kind": "LinkedField",
      "name": "author",
      "plural": false,
      "selections": [
        {
          "alias": null,
          "args": null,
          "kind": "ScalarField",
          "name": "__typename",
          "storageKey": null
        },
        {
          "alias": null,
          "args": [
            {
              "kind": "Literal",
              "name": "supported",
              "value": [
                "PlainUserNameRenderer",
                "MarkdownUserNameRenderer"
              ]
            }
          ],
          "concreteType": null,
          "kind": "LinkedField",
          "name": "nameRenderer",
          "plural": false,
          "selections": [
            {
              "kind": "InlineFragment",
              "selections": [
                {
                  "args": null,
                  "documentName": "RelayModernEnvironmentWithOperationTrackerTestFeedbackFragment",
                  "fragmentName": "RelayModernEnvironmentWithOperationTrackerTestPlainUserNameRenderer_name",
                  "fragmentPropName": "name",
                  "kind": "ModuleImport"
                }
              ],
              "type": "PlainUserNameRenderer",
              "abstractKey": null
            },
            {
              "kind": "InlineFragment",
              "selections": [
                {
                  "args": null,
                  "documentName": "RelayModernEnvironmentWithOperationTrackerTestFeedbackFragment",
                  "fragmentName": "RelayModernEnvironmentWithOperationTrackerTestMarkdownUserNameRenderer_name",
                  "fragmentPropName": "name",
                  "kind": "ModuleImport"
                }
              ],
              "type": "MarkdownUserNameRenderer",
              "abstractKey": null
            }
          ],
          "storageKey": "nameRenderer(supported:[\"PlainUserNameRenderer\",\"MarkdownUserNameRenderer\"])"
        },
        {
          "alias": "plainNameRenderer",
          "args": [
            {
              "kind": "Literal",
              "name": "supported",
              "value": [
                "PlainUserNameRenderer"
              ]
            }
          ],
          "concreteType": null,
          "kind": "LinkedField",
          "name": "nameRenderer",
          "plural": false,
          "selections": [
            {
              "kind": "InlineFragment",
              "selections": [
                {
                  "args": null,
                  "documentName": "RelayModernEnvironmentWithOperationTrackerTestFeedbackFragment_plainNameRenderer",
                  "fragmentName": "RelayModernEnvironmentWithOperationTrackerTestPlainUserNameRenderer_name",
                  "fragmentPropName": "name",
                  "kind": "ModuleImport"
                }
              ],
              "type": "PlainUserNameRenderer",
              "abstractKey": null
            }
          ],
          "storageKey": "nameRenderer(supported:[\"PlainUserNameRenderer\"])"
        }
      ],
      "storageKey": null
    }
  ],
  "type": "Feedback",
  "abstractKey": null
};

if (__DEV__) {
  (node/*: any*/).hash = "e135d9b0559cedee19c4ccccd85dc5be";
}

module.exports = ((node/*: any*/)/*: Fragment<
  RelayModernEnvironmentWithOperationTrackerTestFeedbackFragment$fragmentType,
  RelayModernEnvironmentWithOperationTrackerTestFeedbackFragment$data,
>*/);


text:
<?xml version="1.0" encoding="UTF-8"?>
<metadata>
  <groupId>com.simbest.boot</groupId>
  <artifactId>simbest-boot-activity</artifactId>
  <versioning>
    <release>0.1</release>
    <versions>
      <version>0.1</version>
    </versions>
    <lastUpdated>20190409101148</lastUpdated>
  </versioning>
</metadata>


text:
. ./config.sh

start_suite "Launch scope and check it boots"

weave_on "$HOST1" launch
scope_on "$HOST1" launch

wait_for_containers "$HOST1" 60 weave weavescope

has_container "$HOST1" weave
has_container "$HOST1" weavescope

# Fail if the top-level UI is suspiciously small
ui_len="$(curl -s "http://$HOST1:4040/" | wc -c)"
assert_raises "(( $ui_len > 500 ))" 0

scope_end_suite


text:
package org.apache.sysds.runtime.controlprogram;

import java.util.HashMap;
import java.util.HashSet;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Set;
import java.util.StringTokenizer;

import org.apache.sysds.runtime.controlprogram.caching.CacheableData;
import org.apache.sysds.runtime.controlprogram.parfor.util.IDSequence;
import org.apache.sysds.runtime.instructions.cp.Data;
import org.apache.sysds.runtime.instructions.cp.ListObject;
import org.apache.sysds.runtime.util.ProgramConverter;

/**
 * Replaces HashMap⟨String, Data⟩ as the table of
 * variable names and references.  No longer supports global consistency.
 *
 */
public class LocalVariableMap implements Cloneable
{
	private static final String eol = System.getProperty ("line.separator");
	private static final String ELEMENT_DELIM = ProgramConverter.ELEMENT_DELIM;
	private static final IDSequence _seq = new IDSequence();

	//variable map data and id
	private final HashMap<String, Data> localMap;
	private final long localID;

	//optional set of registered outputs
	private HashSet<String> outputs = null;

	public LocalVariableMap() {
		localMap = new HashMap<>();
		localID = _seq.getNextID();
	}

	public LocalVariableMap(LocalVariableMap vars) {
		localMap = new HashMap<>(vars.localMap);
		localID = _seq.getNextID();
	}

	public Set<String> keySet() {
		return localMap.keySet();
	}

	public Set<Entry<String, Data>> entrySet() {
		return localMap.entrySet();
	}

	/**
	 * Retrieves the data object given its name.
	 *
	 * @param name the variable name for the data object
	 * @return the direct reference to the data object
	 */
	public Data get( String name ) {
		return localMap.get( name );
	}

	/**
	 * Adds a new (name, value) pair to the variable map, or replaces an old pair with
	 * the same name.  Several different variable names may refer to the same value.
	 *
	 * @param name the variable name for the data value
	 * @param val the data value object (such as envelope)
	 */
	public void put(String name, Data val) {
		localMap.put( name, val );
	}

	public void putAll(Map<String, Data> vals) {
		localMap.putAll(vals);
	}

	public void putAll(LocalVariableMap vars) {
		putAll(vars.localMap);
	}

	public Data remove( String name ) {
		return localMap.remove( name );
	}

	public void removeAll() {
		localMap.clear();
	}

	public void removeAllIn(Set<String> excludeList) {
		localMap.entrySet().removeIf(
			e -> excludeList.contains(e.getKey()));
	}

	public void removeAllNotIn(Set<String> excludeList) {
		localMap.entrySet().removeIf(
			e -> !excludeList.contains(e.getKey()));
	}

	public boolean hasReferences( Data d ) {
		//perf: avoid java streams here for reduced overhead in rmvar
		for( Data o : localMap.values() )
			if( o instanceof ListObject ? ((ListObject)o).contains(d) : o == d )
				return true;
		return false;
	}

	public void setRegisteredOutputs(HashSet<String> outputs) {
		this.outputs = outputs;
	}

	public HashSet<String> getRegisteredOutputs() {
		return outputs;
	}

	public double getPinnedDataSize() {
		// note: this method returns the total size of distinct pinned
		// data objects that are not subject to automatic eviction
		// (in JMLC all matrices and frames are pinned)

		//compute map of distinct cachable data
		Map<Integer, Data> dict = new HashMap<>();
		double total = 0.0;
		for( Entry<String,Data> e : localMap.entrySet() ) {
			int hash = System.identityHashCode(e.getValue());
			if( !dict.containsKey(hash) && e.getValue() instanceof CacheableData ) {
				dict.put(hash, e.getValue());
				double size = ((CacheableData<?>) e.getValue()).getDataSize();
				total += size;
			}
		}

		//compute total in-memory size
		return total;
	}

	public long countPinnedData() {
		return localMap.values().stream()
			.filter(d -> (d instanceof CacheableData)).count();
	}

	public String serialize() {
		StringBuilder sb = new StringBuilder();
		int count = 0;
		for (Entry <String, Data> e : localMap.entrySet ()) {
			if (count != 0)
				sb.append (ELEMENT_DELIM);
			sb.append(ProgramConverter
				.serializeDataObject(e.getKey(), e.getValue()));
			count++;
		}
		return sb.toString();
	}

	public static LocalVariableMap deserialize(String varStr) {
		StringTokenizer st2 = new StringTokenizer (varStr, ELEMENT_DELIM );
		LocalVariableMap vars = new LocalVariableMap ();
		while( st2.hasMoreTokens() ) {
			String tmp = st2.nextToken().trim();
			Object[] tmp2 = ProgramConverter.parseDataObject (tmp);
			vars.put((String) tmp2 [0], (Data) tmp2 [1]);
		}
		return vars;
	}

	@Override
	public String toString() {
		StringBuilder sb = new StringBuilder();
		sb.append("Local Variable Map ID = \"");
		sb.append(localID);
		sb.append("\":");
		sb.append(eol);
		for (Entry <String, Data> pair : localMap.entrySet()) {
			sb.append("  ");
			sb.append(pair.getKey());
			sb.append(" = ");
			sb.append(pair.getValue());
			sb.append(eol);
		}
		return sb.toString();
	}

	@Override
	public Object clone() {
		return new LocalVariableMap(this);
	}
}


text:
import React from 'react'
import { Progress } from 'shengnian-ui-react'

const ProgressExampleActive = () => (
  <Progress percent={60} active>
    Active
  </Progress>
)

export default ProgressExampleActive


text:
tinymce.addI18n('pt_BR', {
	"easyupload.DIALOG_TITLE": "Enviar arquivos",
	"easyupload.TOOLTIP": "Enviar um arquivo",
	"easyupload.MENU_TEXT": "Enviar Arquivo",
	"easyupload.CLOSE_WINDOW": 'Fechar',
	"easyupload.DIALOG_TEXT": 'Adicionar'
});


text:
<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
    android:layout_width="wrap_content"
    android:layout_height="wrap_content"
    android:background="@drawable/new_bg_dialog"
    android:minHeight="280dp"
    android:orientation="vertical" >
    <include
        layout="@layout/dk_dialog_header"
        android:layout_height="0px"
        android:layout_weight="1"/>
    <FrameLayout
        android:layout_width="fill_parent"
        android:layout_height="0px"
        android:layout_weight="3">
        <LinearLayout
            android:id="@+id/line_vertical"
            android:layout_width="2dp"
            android:layout_height="fill_parent"
            android:layout_gravity="left"
            android:layout_marginLeft="54dp"
            android:orientation="horizontal" >
            <View
                android:layout_width="1dp"
                android:layout_height="fill_parent"
                android:background="#cccccc" />
            <View
                android:layout_width="1dp"
                android:layout_height="fill_parent"
                android:background="#ffffff" />
        </LinearLayout>
        <RelativeLayout
            android:layout_width="fill_parent"
            android:layout_height="wrap_content"
            android:layout_marginTop="12dp" >
            <Button
                android:id="@+id/btnCardRechargeYidong"
                android:layout_width="64dp"
                android:layout_height="34dp"
                android:layout_alignParentLeft="true"
                android:layout_marginTop="12dp"
                android:background="@drawable/transparent"
                android:text="@string/dk_payment_channel_rechargecard_cmobile"
                android:textColor="#333333"
                android:textSize="16sp" />
            <Button
                android:id="@+id/btnCardRechargeLiantong"
                android:layout_width="64dp"
                android:layout_height="34dp"
                android:layout_alignLeft="@id/btnCardRechargeYidong"
                android:layout_below="@id/btnCardRechargeYidong"
                android:layout_marginTop="12dp"
                android:background="@drawable/transparent"
                android:gravity="center"
                android:text="@string/dk_payment_channel_rechargecard_cunicom"
                android:textColor="#333333"
                android:textSize="16sp" />
            <Button
                android:id="@+id/btnCardRechargeDianxin"
                android:layout_width="64dp"
                android:layout_height="34dp"
                android:layout_alignLeft="@id/btnCardRechargeLiantong"
                android:layout_below="@id/btnCardRechargeLiantong"
                android:layout_marginTop="12dp"
                android:background="@drawable/transparent"
                android:text="@string/dk_payment_channel_rechargecard_ctelcom"
                android:textColor="#333333"
                android:textSize="16sp" />
            <ScrollView
                android:layout_width="fill_parent"
                android:layout_height="wrap_content"
                android:layout_marginRight="10dp"
                android:scrollbars="none"
                android:layout_toRightOf="@id/btnCardRechargeYidong" >
                <include
                    layout="@layout/dk_dialog_rechargecard_body" />
            </ScrollView>
        </RelativeLayout>
    </FrameLayout>
	<include
        layout="@layout/dk_dialog_footer"
        android:layout_height="0px"
        android:layout_weight="1"/>
</LinearLayout>