text:
// odata-handler-tests.js

(function (window, undefined) {

    var dataServiceVersion = "4.0";
    var endpoint = "./endpoints/FoodStoreDataServiceV4.svc";
    var mimeType = "application/json;odata.metadata=minimal";
    var headers = {
                "Content-Type": mimeType,
                Accept: mimeType,
                "OData-Version": "4.0"
            };
    var unexpectedErrorHandler = function (err) {
        djstest.assert(false, "Unexpected call to error handler with error: " + djstest.toString(err));
        djstest.done();
    };

    djstest.addTest(function createUpdateDeleteTest() {
        // This is a simple create-update-delete cycle as a high-level test.

        var serviceUri = "./endpoints/FoodStoreDataServiceV4.svc/";
        var baseUri = serviceUri + "Categories";
        var testItem;
        var handledData = { CategoryID: 1001, Name: "Name #1001" };
        var uri;

        var itemCreatedCallback = function (data, response) {
            djstest.assert(response.headers["Location"], "location URL in the headers");
            djstest.assert(data.Name, "Name #1001");

            uri = response.headers["Location"];
            testItem = handledData;
            testItem.Name = "Updated name";

            odatajs.oData.request({
                method: "PUT",
                data: testItem,
                requestUri: uri
            }, itemUpdatedCallback);
        };

        var itemUpdatedCallback = function (data, response) {
            djstest.assertAreEqual(response.statusCode, 204, "Expecting no content on update");
            odatajs.oData.request({
                method: "DELETE",
                requestUri: uri
            }, itemDeletedCallback);
        };

        var itemDeletedCallback = function (data, response) {
            djstest.done();
        };

        $.post(serviceUri + "ResetData", function () {
            odatajs.oData.request({
                requestUri: baseUri,
                method: "POST",
                data: { CategoryID: 1001, Name: "Name #1001" }
            }, itemCreatedCallback);
        });
    });

    djstest.addTest(function errorHandlerTest() {
        djstest.assertsExpected(1);
        odatajs.oData.read("./endpoints/FoodStoreDataServiceV4.svc/Categories?$reserved-misused=true",
            function (data) {
                djstest.fail("expected an error callback");
                djstest.done();
            },
            function (err) {
                djstest.assert(err.response.body, "err.response.body is assigned");
                djstest.done();
            });
    });

    djstest.addTest(function textHandlerParseTest() {
        djstest.assertsExpected(1);
        MockHttpClient.clear().addResponse("textHandlerParseTest", {
            statusCode: 200,
            body: " text ",
            headers: { "Content-Type": "text/plain" }
        });
        odatajs.oData.read("textHandlerParseTest", function (data) {
            djstest.assertAreEqual(data, " text ", "data matches");
            djstest.done();
        }, function (err) {
            djstest.fail("expected success");
            djstest.done();
        }, undefined, MockHttpClient);
    });

    djstest.addTest(function textHandlerParseEmptyTest() {
        djstest.assertsExpected(1);
        MockHttpClient.clear().addResponse("textHandlerParseTest", {
            statusCode: 200,
            body: "",
            headers: { "Content-Type": "text/plain" }
        });
        odatajs.oData.read("textHandlerParseTest", function (data) {
            djstest.assertAreEqual(data, "", "data matches");
            djstest.done();
        }, function (err) {
            djstest.fail("expected success");
            djstest.done();
        }, undefined, MockHttpClient);
    });

    djstest.addTest(function textHandlerSerializeTest() {
        djstest.assertsExpected(1);
        MockHttpClient.clear().addRequestVerifier("uri", function (request) {
            djstest.assertAreEqual(request.body, "text", "text in request");
        }).addResponse("uri", { statusCode: 200, body: "", headers: { "Content-Type": "text/plain"} });
        odatajs.oData.request({ requestUri: "uri", method: "POST", data: "text", headers: { "Content-Type": "text/plain"} }, function (data) {
            djstest.done();
        }, function (err) {
            djstest.fail("expected success");
            djstest.done();
        }, undefined, MockHttpClient);
    });

    djstest.addTest(function textHandlerSerializeBlankTest() {
        djstest.assertsExpected(1);
        MockHttpClient.clear().addRequestVerifier("uri", function (request) {
            djstest.assertAreEqual(request.body, "", "text in request");
        }).addResponse("uri", { statusCode: 200, body: "", headers: { "Content-Type": "text/plain"} });
        odatajs.oData.request({ requestUri: "uri", method: "POST", data: "", headers: { "Content-Type": "text/plain"} }, function (data) {
            djstest.done();
        }, function (err) {
            djstest.fail("expected success");
            djstest.done();
        }, undefined, MockHttpClient);
    });

    // DATAJS INTERNAL START
    djstest.addTest(function handlerReadTest() {
        var tests = [
            {
                response: { headers: { "Content-Type": "application/json", "OData-Version": "4.0" }, body: "response 0" },
                shouldHit: true,
                context: { contentType: window.odatajs.oData.handler.contentType("application/json"), dataServiceVersion: "4.0" }
            },
            {
                response: { headers: { "Content-Type": "application/json" }, body: "response 1" },
                shouldHit: true,
                context: { contentType: window.odatajs.oData.handler.contentType("application/json"), dataServiceVersion: "" }
            },
            {
                response: { headers: { "Content-Type": "otherMediaType" }, body: "response 2" },
                shouldHit: false,
                context: { contentType: window.odatajs.oData.handler.contentType("otherMediaType"), dataServiceVersion: "" }
            },
            {
                response: { headers: { "Content-Type": "application/json", "OData-Version": "4.0" }, body: "response 3" },
                shouldHit: true,
                context: { contentType: window.odatajs.oData.handler.contentType("application/json"), dataServiceVersion: "4.0" }
            },
            {
                response: { body: "response 4" },
                shouldHit: false,
                context: { contentType: window.odatajs.oData.handler.contentType("application/json"), dataServiceVersion: "" }
            },
            {
                response: null,
                shouldHit: false,
                context: {}
            },
            {
                response: undefined,
                shouldHit: false,
                context: {}
            }
        ];

        var i;
        var test;
        var testRead = function (handler, body, context) {
            djstest.assert(test.shouldHit, "method should be hit on item #" + i);
            djstest.assertAreEqual(handler, testHandler, "handler matches target on item #" + i);
            djstest.assertAreEqualDeep(context, test.context, "context matches target on item #" + i);
            djstest.assertAreEqual(body, test.response.body, "body matches target on item #" + i);
            return body;
        };

        var testHandler = window.odatajs.oData.handler.handler(testRead, null, "application/json", "4.0");

        var len, expectedAssertCount = 0;
        for (i = 0, len = tests.length; i < len; i++) {
            test = tests[i];
            test.context.handler = testHandler;
            test.context.response = test.response;
            if (test.shouldHit) {
                expectedAssertCount += 4;
            }

            testHandler.read(test.response, {});
        }

        djstest.assertsExpected(expectedAssertCount);
        djstest.done();
    });

    djstest.addTest(function handlerWriteTest() {
        var tests = [
            {
                request: { headers: { "Content-Type": "application/json", "OData-Version": "4.0" }, data: "request 0" },
                shouldHit: true,
                context: { contentType: window.odatajs.oData.handler.contentType("application/json"), dataServiceVersion: "4.0" }
            },
            {
                request: { headers: { "Content-Type": "application/json" }, data: "request 1" },
                shouldHit: true,
                context: { contentType: window.odatajs.oData.handler.contentType("application/json"), dataServiceVersion: undefined }
            },
            {
                request: { headers: { "Content-Type": "otherMediaType" }, data: "request 2" },
                shouldHit: false,
                context: { contentType: window.odatajs.oData.handler.contentType("otherMediaType"), dataServiceVersion: undefined }
            },
            {
                request: { headers: {}, data: "request 3" },
                shouldHit: true,
                context: { contentType: null, dataServiceVersion: undefined }
            },
            {
                request: { headers: { "Content-Type": "application/json", "OData-Version": "4.0" }, data: "request 4" },
                shouldHit: true,
                context: { contentType: window.odatajs.oData.handler.contentType("application/json"), dataServiceVersion: "4.0" }
            },
            {
                request: null,
                shouldHit: false,
                context: {}
            },
            {
                request: undefined,
                shouldHit: false,
                context: {}
            }
        ];

        var test;
        var testWrite = function (handler, data, context) {
            djstest.assert(test.shouldHit, "method should be hit");
            djstest.assertAreEqual(handler, testHandler, "handler matches target");
            djstest.assertAreEqualDeep(context, test.context, "context matches target");
            djstest.assertAreEqual(data, test.request.data, "body matches target");
            return data;
        };

        var testHandler = window.odatajs.oData.handler.handler(null, testWrite, "application/json", "4.0");

        var i, len, expectedAssertCount = 0;
        for (i = 0, len = tests.length; i < len; i++) {
            test = tests[i];
            test.context.handler = testHandler;
            test.context.request = test.request;
            if (test.shouldHit) {
                expectedAssertCount += 4;
            }
            testHandler.write(test.request);
        }

        djstest.assertsExpected(expectedAssertCount);
        djstest.done();
    });

    djstest.addTest(function handlerWriteUpdatesRequestContentTypeTest() {
        var testWrite = function (handler, data, context) {
            context.contentType = window.odatajs.oData.handler.contentType("my new content type");
            return data;
        };

        var testHandler = window.odatajs.oData.handler.handler(null, testWrite, "application/json", "4.0");

        var tests = [
            { request: { headers: { "Content-Type": "application/json" }, data: "request 0" }, expected: "application/json" },
            { request: { headers: {}, data: "request 1" }, expected: "my new content type" }
        ];

        var i, len;
        for (i = 0, len = tests.length; i < len; i++) {
            testHandler.write(tests[i].request);
            djstest.assertAreEqual(tests[i].request.headers["Content-Type"], tests[i].expected, "request content type is the expected");
        }
        djstest.done();
    });

    djstest.addTest(function contentTypeTest() {
        var tests = [
            { contentType: "application/json;param1=value1;param2=value2", expected: { mediaType: "application/json", properties: { param1: "value1", param2: "value2"}} },
            { contentType: "application/json; param1=value1; param2=value2", expected: { mediaType: "application/json", properties: { param1: "value1", param2: "value2"}} },
            { contentType: "application/json;param1=value1; param2=value2", expected: { mediaType: "application/json", properties: { param1: "value1", param2: "value2"}} },
            { contentType: "application/json; param1=value1;param2=value2", expected: { mediaType: "application/json", properties: { param1: "value1", param2: "value2"}} },
            { contentType: "application/json", expected: { mediaType: "application/json", properties: {}} },
            { contentType: ";param1=value1;param2=value2", expected: { mediaType: "", properties: { param1: "value1", param2: "value2"}} }
        ];

        var i, len, cTypeString;
        for (i = 0, len = tests.length; i < len; i++) {
            var actual = window.odatajs.oData.handler.contentType(tests[i].contentType);
            djstest.assertAreEqual(actual.mediaType, tests[i].expected.mediaType, "Content type media type is parsed correctly");
            djstest.assertAreEqualDeep(actual.properties, tests[i].expected.properties, "Content type properties are parsed correctly");
        }

        djstest.assert(! window.odatajs.oData.handler.contentType(undefined), "contentType returns undefined for undefined input");
        djstest.assert(! window.odatajs.oData.handler.contentType(null), "contentType returns undefined for null input");

        djstest.done();
    });

    djstest.addTest(function contentTypeToStringTest() {
        var tests = [
            { contentType: { mediaType: "application/json", properties: { param1: "value1", param2: "value2"} }, expected: "application/json;param1=value1;param2=value2" },
            { contentType: { mediaType: "application/json", properties: {} }, expected: "application/json" },
            { contentType: { mediaType: "", properties: { param1: "value1", param2: "value2"} }, expected: ";param1=value1;param2=value2" }
        ];

        var i, len, cTypeString;
        for (i = 0, len = tests.length; i < len; i++) {
            cTypeString = window.odatajs.oData.handler.contentTypeToString(tests[i].contentType);
            djstest.assertAreEqual(cTypeString, tests[i].expected, "contentTypeToString returns the correct contentType string");
        }

        djstest.done();
    });

    djstest.addTest(function readServiceDocumentTest(headers) {
        odatajs.oData.request({
            requestUri: endpoint,
            method: "GET",
            headers: headers
        }, function (data, response) {
            djstest.assertAreEqual(data.value[0].name, "Categories", "Verify .name");
            djstest.assertAreEqual(data.value[0].kind, "EntitySet", "Verify .kind");
            djstest.assertAreEqual(data.value[0].url, "Categories", "Verify .url");

            djstest.assertAreEqual(data.value[1].name, "Foods", "Verify .name");
            djstest.assertAreEqual(data.value[1].kind, "EntitySet", "Verify .kind");
            djstest.assertAreEqual(data.value[1].url, "Foods", "Verify .url");
            djstest.done();
        }, unexpectedErrorHandler);
     });

    // DATAJS INTERNAL END
})(this);


text:
package edu.kit.dama.mdm.base.interfaces;

/**
 *
 * @author jejkal
 */
public interface IDefaultTask extends ISimpleTask {

    /**
     * Get task.
     *
     * @return the task
     */
    String getTask();
}

redpajama_set_name: RedPajamaGithub


text:
var start = require('./common')
var db = start();
db.on('open', function () {
  db.db.dropDatabase(function () {
    process.exit();
  });
});


text:
sap.ui.define(['jquery.sap.global', "sap/m/semantic/SemanticPage", "sap/m/semantic/SemanticConfiguration", "sap/m/semantic/SemanticPageRenderer", "sap/m/semantic/SegmentedContainer", "sap/m/semantic/ShareMenu", "sap/m/ActionSheet", "sap/m/Button"],
		function(jQuery, SemanticPage, SemanticConfiguration, SemanticPageRenderer, SegmentedContainer, ShareMenu, ActionSheet, Button) {
	"use strict";

	/**
	 * Constructor for a new ShareMenuPage
	 * @param {string} [sId] id for the new control, generated automatically if no id is given
	 * @param {object} [mSettings] initial settings for the new control
	 *
	 * @class
	 * A ShareMenuPage is a {@link sap.m.semantic.SemanticPage} with support for "share" menu in the footer.
	 *
	 * @extends sap.m.semantic.SemanticPage
	 *
	 * @author SAP SE
	 * @version 1.42.8
	 *
	 * @constructor
	 * @public
	 * @since 1.30.0
	 * @alias sap.m.semantic.ShareMenuPage
	 * @ui5-metamodel This control/element also will be described in the UI5 (legacy) designtime metamodel
	 */

	var ShareMenuPage = SemanticPage.extend("sap.m.semantic.ShareMenuPage", /** @lends sap.m.semantic.ShareMenuPage.prototype */ {
		metadata: {

			library: "sap.m",

			aggregations: {

				/**
				 * Custom share menu buttons
				 */
				customShareMenuContent: {
					type: "sap.m.Button",
					multiple: true,
					singularName: "customShareMenuContent"
				},

				/**
				 * Wrapped instance of {@link sap.m.ActionSheet}
				 */
				_actionSheet: {
					type: "sap.m.ActionSheet",
					multiple: false,
					visibility: "hidden"
				}

			},
			designTime : true
		},
		renderer: SemanticPageRenderer.render
	});

	ShareMenuPage.prototype._getSemanticPositionsMap = function (oControl, oConfig) {

		if (!this._oPositionsMap) {
			this._oPositionsMap = SemanticPage.prototype._getSemanticPositionsMap.apply(this, arguments);
			this._oPositionsMap[SemanticConfiguration.prototype._PositionInPage.shareMenu] = {
				oContainer: this._getSegmentedShareMenu().getSection("semantic"),
				sAggregation: "content"
			};
		}

		return this._oPositionsMap;
	};

	ShareMenuPage.prototype.exit = function () {

		SemanticPage.prototype.exit.apply(this, arguments);

		if (this._oSegmentedShareMenu) {
			this._oSegmentedShareMenu.destroy();
			this._oSegmentedShareMenu = null;
		}
	};

	/*

	 SHARE MENU (CUSTOM CONTENT)
	 */

	ShareMenuPage.prototype.getCustomShareMenuContent = function () {
		return this._getSegmentedShareMenu().getSection("custom").getContent();
	};

	ShareMenuPage.prototype.addCustomShareMenuContent = function (oButton, bSuppressInvalidate) {
		this._getSegmentedShareMenu().getSection("custom").addContent(oButton, bSuppressInvalidate);
		return this;
	};

	ShareMenuPage.prototype.indexOfCustomShareMenuContent = function (oButton) {
		return this._getSegmentedShareMenu().getSection("custom").indexOfContent(oButton);
	};

	ShareMenuPage.prototype.insertCustomShareMenuContent = function (oButton, iIndex, bSuppressInvalidate) {
		this._getSegmentedShareMenu().getSection("custom").insertContent(oButton, iIndex, bSuppressInvalidate);
		return this;
	};

	ShareMenuPage.prototype.removeCustomShareMenuContent = function (oButton, bSuppressInvalidate) {
		return this._getSegmentedShareMenu().getSection("custom").removeContent(oButton, bSuppressInvalidate);
	};

	ShareMenuPage.prototype.removeAllCustomShareMenuContent = function (bSuppressInvalidate) {
		return this._getSegmentedShareMenu().getSection("custom").removeAllContent(bSuppressInvalidate);
	};

	ShareMenuPage.prototype.destroyCustomShareMenuContent = function (bSuppressInvalidate) {

		var aChildren = this.getCustomShareMenuContent();

		if (!aChildren) {
			return this;
		}

		// set suppress invalidate flag
		if (bSuppressInvalidate) {
			this.iSuppressInvalidate++;
		}

		this._getSegmentedShareMenu().getSection("custom").destroy();

		if (!this.isInvalidateSuppressed()) {
			this.invalidate();
		}

		// reset suppress invalidate flag
		if (bSuppressInvalidate) {
			this.iSuppressInvalidate--;
		}

		return this;
	};

	/**
	 * Create the internal action sheet of the "share" menu
	 * @returns {sap.m.IBar}
	 * @private
	 */
	ShareMenuPage.prototype._getActionSheet = function () {

		var oActionSheet = this.getAggregation("_actionSheet");
		if (!oActionSheet) {
			this.setAggregation("_actionSheet", new ActionSheet(
					{placement: sap.m.PlacementType.Top}), true);
			oActionSheet = this.getAggregation("_actionSheet");
		}

		return oActionSheet;
	};

	ShareMenuPage.prototype._getSegmentedShareMenu = function() {
		if (!this._oSegmentedShareMenu) {

			var oShareMenu = new ShareMenu(this._getActionSheet());
			var oShareMenuBtn = oShareMenu.getBaseButton();

			if (oShareMenu && oShareMenuBtn) {
				this._oSegmentedShareMenu = new SegmentedContainer(oShareMenu);
				this._oSegmentedShareMenu.addSection({sTag: "custom"});
				this._oSegmentedShareMenu.addSection({sTag: "semantic"});

				this._getSegmentedFooter().addSection({
					sTag: "shareMenu",
					aContent: [oShareMenuBtn]
				});
			}
		}
		return this._oSegmentedShareMenu;
	};

	return ShareMenuPage;
}, /* bExport= */ false);


text:
package com.Voxce.DAO;

import java.util.ArrayList;
import java.util.List;

import org.hibernate.SessionFactory;
import org.springframework.orm.hibernate3.HibernateTemplate;

import com.Voxce.model.DefaultAnswerTexts;
import com.Voxce.model.Users;

public class DefaultAnswerTextsDAO {

	private HibernateTemplate hibernateTemplate;

	List<DefaultAnswerTexts> listDefaultAnswerTexts;

	// GET HIBERNATE SESSION FACTORY
	public void setSessionFactory(SessionFactory sessionFactory) {
		this.hibernateTemplate = new HibernateTemplate(sessionFactory);
	}

// *** ADD DEFAULT ANSWER TEXT
	public int saveDefaultAnswerTexts(DefaultAnswerTexts answerText) {

		int messageCode = -1;

		java.util.Date today = new java.util.Date();
		java.sql.Date dateCreated = new java.sql.Date(today.getTime());
		answerText.setDate_created(dateCreated);

		try {

			hibernateTemplate.saveOrUpdate(answerText);
			messageCode = 3;

		} catch (Exception exp) {
			exp.printStackTrace();
		}

		return messageCode;
	}

// ****** GET DEFAULT ANSWER TEXTS LIST
	@SuppressWarnings("unchecked")
	public List<DefaultAnswerTexts> getDefaultAnswerTextsList(Users user) throws Exception {
		List<DefaultAnswerTexts> list=(List<DefaultAnswerTexts>) hibernateTemplate.find("from DefaultAnswerTexts");
		if(list==null)
			return new ArrayList<DefaultAnswerTexts>();
		return list;
	}

// **** FIND THE DEFAULT ANSWER TEXT
	public DefaultAnswerTexts findADefaultAnswerTexts(int ans_id) {

		DefaultAnswerTexts answerText = null;
		List<?> findAnswerText = null;
		try {

			findAnswerText = hibernateTemplate.find("FROM DefaultAnswerTexts WHERE default_answer_text_id = ?", ans_id);
			answerText = (DefaultAnswerTexts) findAnswerText.get(0);

		} catch (Exception excp) {
			System.out.println("Exception DefaultAnswerTexts = " + excp);
		}

		return answerText;
	}

// **** UPDATE THE DEFAULT ANSWER TEXT
	public int updateDefaultAnswerTexts(DefaultAnswerTexts newDAT) {

		int messageCode = -1;

		java.util.Date today = new java.util.Date();
		java.sql.Date dateModified = new java.sql.Date(today.getTime());

		newDAT.setDate_modified(dateModified);

		try {
			DefaultAnswerTexts oldText = this.findADefaultAnswerTexts(newDAT.getDefault_answer_text_id());

			newDAT.setCreated_by(oldText.getCreated_by());
			newDAT.setDate_created(oldText.getDate_created());

			hibernateTemplate.update(newDAT);
			hibernateTemplate.flush();

			messageCode = 3;

		} catch (Exception e) {
			System.out.println(e);
		}

		return messageCode;
	}

}


text:
Authentication
==============

Unlike Web applications, RESTful APIs are usually stateless, which means sessions or cookies should not
be used. Therefore, each request should come with some sort of authentication credentials because
the user authentication status may not be maintained by sessions or cookies. A common practice is
to send a secret access token with each request to authenticate the user. Since an access token
can be used to uniquely identify and authenticate a user, **API requests should always be sent
via HTTPS to prevent man-in-the-middle (MitM) attacks**.

There are different ways to send an access token:

* [HTTP Basic Auth](https://en.wikipedia.org/wiki/Basic_access_authentication): the access token
  is sent as the username. This should only be used when an access token can be safely stored
  on the API consumer side. For example, the API consumer is a program running on a server.
* Query parameter: the access token is sent as a query parameter in the API URL, e.g.,
  `https://example.com/users?access-token=xxxxxxxx`. Because most Web servers will keep query
  parameters in server logs, this approach should be mainly used to serve `JSONP` requests which
  cannot use HTTP headers to send access tokens.
* [OAuth 2](https://oauth.net/2/): the access token is obtained by the consumer from an authorization
  server and sent to the API server via [HTTP Bearer Tokens](https://datatracker.ietf.org/doc/html/rfc6750),
  according to the OAuth2 protocol.

Yii supports all of the above authentication methods. You can also easily create new authentication methods.

To enable authentication for your APIs, do the following steps:

1. Configure the `user` [application component](structure-application-components.md):
   - Set the [[yii\web\User::enableSession|enableSession]] property to be `false`.
   - Set the [[yii\web\User::loginUrl|loginUrl]] property to be `null` to show an HTTP 403 error instead of redirecting to the login page.
2. Specify which authentication methods you plan to use by configuring the `authenticator` behavior
   in your REST controller classes.
3. Implement [[yii\web\IdentityInterface::findIdentityByAccessToken()]] in your [[yii\web\User::identityClass|user identity class]].

Step 1 is not required but is recommended for RESTful APIs which should be stateless. When [[yii\web\User::enableSession|enableSession]]
is `false`, the user authentication status will NOT be persisted across requests using sessions. Instead, authentication
will be performed for every request, which is accomplished by Step 2 and 3.

> Tip: You may configure [[yii\web\User::enableSession|enableSession]] of the `user` application component
> in application configurations if you are developing RESTful APIs in terms of an application. If you develop
> RESTful APIs as a module, you may put the following line in the module's `init()` method, like the following:
>
> ```php
> public function init()
> {
>     parent::init();
>     \Yii::$app->user->enableSession = false;
> }
> ```

For example, to use HTTP Basic Auth, you may configure the `authenticator` behavior as follows,

```php
use yii\filters\auth\HttpBasicAuth;

public function behaviors()
{
    $behaviors = parent::behaviors();
    $behaviors['authenticator'] = [
        'class' => HttpBasicAuth::class,
    ];
    return $behaviors;
}
```

If you want to support all three authentication methods explained above, you can use `CompositeAuth` like the following,

```php
use yii\filters\auth\CompositeAuth;
use yii\filters\auth\HttpBasicAuth;
use yii\filters\auth\HttpBearerAuth;
use yii\filters\auth\QueryParamAuth;

public function behaviors()
{
    $behaviors = parent::behaviors();
    $behaviors['authenticator'] = [
        'class' => CompositeAuth::class,
        'authMethods' => [
            HttpBasicAuth::class,
            HttpBearerAuth::class,
            QueryParamAuth::class,
        ],
    ];
    return $behaviors;
}
```

Each element in `authMethods` should be an auth method class name or a configuration array.

Implementation of `findIdentityByAccessToken()` is application specific. For example, in simple scenarios
when each user can only have one access token, you may store the access token in an `access_token` column
in the user table. The method can then be readily implemented in the `User` class as follows,

```php
use yii\db\ActiveRecord;
use yii\web\IdentityInterface;

class User extends ActiveRecord implements IdentityInterface
{
    public static function findIdentityByAccessToken($token, $type = null)
    {
        return static::findOne(['access_token' => $token]);
    }
}
```

After authentication is enabled as described above, for every API request, the requested controller
will try to authenticate the user in its `beforeAction()` step.

If authentication succeeds, the controller will perform other checks (such as rate limiting, authorization)
and then run the action. The authenticated user identity information can be retrieved via `Yii::$app->user->identity`.

If authentication fails, a response with HTTP status 401 will be sent back together with other appropriate headers
(such as a `WWW-Authenticate` header for HTTP Basic Auth).

## Authorization

After a user is authenticated, you probably want to check if he or she has the permission to perform the requested
action for the requested resource. This process is called *authorization* which is covered in detail in
the [Authorization section](security-authorization.md).

If your controllers extend from [[yii\rest\ActiveController]], you may override
the [[yii\rest\ActiveController::checkAccess()|checkAccess()]] method to perform authorization check. The method
will be called by the built-in actions provided by [[yii\rest\ActiveController]].


text:
<?xml version="1.0"?>
<tryton>
    <data>

        <record model="ir.ui.view" id="sale_configuration_view_form">
            <field name="model">sale.configuration</field>
            <field name="inherit" ref="sale.sale_configuration_view_form"/>
            <field name="name">sale_configuration_view_form</field>
        </record>

    </data>
</tryton>


text:
package org.apache.commons.chain2.web.portlet;

import java.util.ArrayList;
import java.util.Collection;
import java.util.Enumeration;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Set;
import javax.portlet.PortletRequest;

import org.apache.commons.chain2.web.MapEntry;

/**
 *
Private implementation of Map for portlet parameter
 * name-value.

 *
 */
final class PortletParamMap implements Map<String, String> {

    public PortletParamMap(PortletRequest request) {
        this.request = request;
    }

    private final PortletRequest request;

    public void clear() {
        throw new UnsupportedOperationException();
    }

    public boolean containsKey(Object key) {
        return (request.getParameter(key(key)) != null);
    }

    public boolean containsValue(Object value) {
        return values().contains(value);
    }

    public Set<Entry<String, String>> entrySet() {
        Set<Entry<String, String>> set = new HashSet<Entry<String, String>>();
        Enumeration<String> keys = request.getParameterNames();
        String key;
        while (keys.hasMoreElements()) {
            key = keys.nextElement();
            set.add(new MapEntry<String, String>(key, request.getParameter(key), false));
        }
        return (set);
    }

    @Override
    public boolean equals(Object o) {
        return (request.equals(o));
    }

    public String get(Object key) {
        return (request.getParameter(key(key)));
    }

    @Override
    public int hashCode() {
        return (request.hashCode());
    }

    public boolean isEmpty() {
        return (size() < 1);
    }

    public Set<String> keySet() {
        Set<String> set = new HashSet<String>();
        Enumeration<String> keys = request.getParameterNames();
        while (keys.hasMoreElements()) {
            set.add(keys.nextElement());
        }
        return (set);
    }

    public String put(String key, String value) {
        throw new UnsupportedOperationException();
    }

    public void putAll(Map<? extends String, ? extends String> map) {
        throw new UnsupportedOperationException();
    }

    public String remove(Object key) {
        throw new UnsupportedOperationException();
    }

    public int size() {
        int n = 0;
        Enumeration<String> keys = request.getParameterNames();
        while (keys.hasMoreElements()) {
            keys.nextElement();
            n++;
        }
        return (n);
    }

    public Collection<String> values() {
        List<String> list = new ArrayList<String>();
        Enumeration<String> keys = request.getParameterNames();
        while (keys.hasMoreElements()) {
            list.add(request.getParameter(keys.nextElement()));
        }
        return (list);
    }

    private String key(Object key) {
        if (key == null) {
            throw new IllegalArgumentException();
        } else if (key instanceof String) {
            return ((String) key);
        } else {
            return (key.toString());
        }
    }

}


text:
define([
	'jquery',
	'underscore',
	'backbone',
	'scripts/config',
	'scripts/registry',
	'scripts/models/tools/tool',
	'scripts/views/dialogs/error-view'
], function($, _, Backbone, Config, Registry, Tool, ErrorView) {
	return Backbone.Model.extend({

		//
		// attributes
		//

		defaults: {
			'name': undefined,
			'description': undefined,
		},

		//
		// Backbone attributes
		//

		urlRoot: Config.csaServer + '/run_requests',

		//
		// ajax methods
		//

		saveOneTimeRunRequests: function(assessmentRunUuids, notifyWhenComplete, options) {
			var self = this;
			$.ajax(_.extend(options, {
				url: this.urlRoot + '/one-time',
				type: 'POST',
				dataType:'json',
				data: {
					'notify-when-complete': notifyWhenComplete,
					'assessment-run-uuids': assessmentRunUuids
				},
				error: function( res ){
					self.handleError( res );
				}
			}));
		},

		saveRunRequests: function(assessmentRunUuids, notifyWhenComplete, options){
			var self = this;
			$.ajax(_.extend(options, {
				url: this.url(),
				type: 'POST',
				dataType:'json',
				data: {
					'notify-when-complete': notifyWhenComplete,
					'assessment-run-uuids': assessmentRunUuids
				},
				error: function( res ){
					self.handleError( res );
				}
			}));
		},

		handleError: function(response) {
			response = 'responseText' in response ? JSON.parse(response.responseText) : '';
			switch (response.status) {

				case 'owner_no_permission':

					// show error dialog
					//
					Registry.application.modal.show(
						new ErrorView({
							message: "The owner of this project must request permission to use \"" + response.tool_name + ".\""
						})
					);
					break;

				case 'no_project':

					// show error dialog
					//
					Registry.application.modal.show(
						new ErrorView({
							message: "The project owner has not designated \"" + response.project_name + "\" for use with \"" + response.tool_name + ".\" To do so the project owner must add an assessment which uses \"" + response.tool_name + ".\""
						})
					);
					break;

				case 'no_policy':
					var tool = new Tool(response.tool);

					// fetch tool policy text
					//
					tool.fetchPolicy({

						// callbacks
						//
						success: function(policy) {

							// show confirm tool policy dialog
							//
							tool.confirmToolPolicy({
								policy_code: response.policy_code,
								policy: policy,

								// callbacks
								//
								error: function(response) {

									// show error dialog
									//
									Registry.application.modal.show(
										new ErrorView({
											message: "Error saving policy acknowledgement."
										})
									);
								}
							});
						},

						error: function() {

							// show error dialog
							//
							Registry.application.modal.show(
								new ErrorView({
									message: "Could not fetch tool policy."
								})
							);
						}
					});
					break;

				default:
					break;
			}
		},

		deleteRunRequest: function(assessmentRun, options) {
			$.ajax(_.extend(options, {
				url: this.url() + '/assessment_runs/' + assessmentRun.get('assessment_run_uuid'),
				type:'DELETE'
			}));
		},

		//
		// overridden Backbone methods
		//

		url: function() {
			return this.urlRoot + (this.isNew()? '' : '/' + this.get('run_request_uuid'));
		},

		isNew: function() {
			return !this.has('run_request_uuid');
		}
	});
});


text:
<FrameLayout xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:tools="http://schemas.android.com/tools" android:id="@+id/item_detail_container"
    android:layout_width="match_parent" android:layout_height="match_parent"
    tools:context="com.alphamedia.rutilahu.ItemDetailActivity" tools:ignore="MergeRootFrame" />
<!-- From: file:/D:/kerjaan/waditra/Android-Lollipop-Swipe-to-Refresh-master/app/src/main/res/layout/activity_item_detail.xml -->


text:
var async = require('async');

var mongoose = require('../lib/mongoose'),
    Schema = mongoose.Schema;

var tokenSchema = new Schema({
    type: String,
    token:String,
    data:{type:String},
    created: {
        type: Date,
        default: Date.now
    },
    enddate: {type:Date}
});

tokenSchema.statics.createToken = function(type, data, token, callback) {
    var Token = this;

    async.waterfall([
        function(callback) {
            var enddate = new Date();
            enddate.setDate(enddate.getDate()+ 1);

            var thetoken = new Token({
                type: type,
                token: token,
                data: data,
                enddate: enddate
            });
            thetoken.save(function(err) {
                if (err) return callback(err);
                callback(null, thetoken);
            });

        }
    ], callback);
};

exports.Token = mongoose.model('tokens', tokenSchema);


text:
require 'httparty'
require 'thor'
require 'yaml'

require 'multichain/cli'
require 'multichain/client'
require 'multichain/encoder'
require 'multichain/wallets'
require 'multichain/version'


text:
package net.wastl.webmail.exceptions;

/**
 * An error occured while creating the userdata for a user.
 *
 * @author Sebastian Schaffert
 */
public class CreateUserDataException extends UserDataException {
    static final long serialVersionUID = 5214525880288931216L;

    public CreateUserDataException() {
        super();
    }

    public CreateUserDataException(String s, String user, String domain) {
        super(s,user,domain);
    }
}


text:
package xyz.filipfloreani.overlapr.sorting;

import android.util.Log;

import com.wenchao.cardstack.DefaultStackEventListener;

/**
 * Created by filipfloreani on 20/05/2017.
 */

public class CardStackListener extends DefaultStackEventListener {

    private static final String TAG = "CardStackListener";

    private SortingActivity sortingActivity;

    public CardStackListener(int detectionThreshold, SortingActivity sortingActivity) {
        super(detectionThreshold);
        this.sortingActivity = sortingActivity;
    }

    @Override
    public void discarded(int mIndex, int direction) {
        switch (direction) {
            case 0: // DIRECTION_TOP_LEFT
                Log.d(TAG, "EXIT TOP LEFT");
                sortingActivity.onExitTopLeft(mIndex);
                break;
            case 1: // DIRECTION_TOP_RIGHT
                Log.d(TAG, "EXIT TOP RIGHT");
                sortingActivity.onExitTopRight(mIndex);
                break;
            case 2: // DIRECTION_BOTTOM_LEFT
                Log.d(TAG, "EXIT BOTTOM LEFT");
                sortingActivity.onExitBottomLeft(mIndex);
                break;
            case 3: // DIRECTION_BOTTOM_RIGHT
                Log.d(TAG, "EXIT BOTTOM RIGHT");
                sortingActivity.onExitBottomRight(mIndex);
                break;
        }
    }
}


text:
Capistrano plugin that includes a collection of tasks we find useful here at Kyan.

## Usage

### Prerequisites

We assume you are using multi-stage environments.

### Setup

Add the library to your `Gemfile`:

```ruby
group :development do
  gem 'capistrano-kyan', require: false
end
```

Update your config/deploy.rb. Here's an example one:

```ruby
require 'capistrano-kyan'
require 'capistrano/ext/multistage'

set :stages, %w(production staging)
set :default_stage, "staging"
set :application, "ournewserver.co.uk"

set :user, "deploy"
set :use_sudo, false

ssh_options[:forward_agent] = true
default_run_options[:pty] = true

set :scm, :git
set :repository, "git@github.com:kyan/#{application}.git"
set :deploy_via, :remote_cache

# If you are using Passenger mod_rails uncomment this:
namespace :deploy do
  task :start do ; end
  task :stop do ; end
  task :restart, :roles => :app, :except => { :no_release => true } do
    run "ln -nfs #{shared_path}/config/application.yml #{release_path}/config/application.yml"
    run "#{try_sudo} touch #{File.join(current_path,'tmp','restart.txt')}"
  end
end

# these are the capistrano-kyan bits
after "deploy:setup",           "kyan:vhost:setup"
after "deploy:finalize_update", "kyan:db:symlink"
after "deploy:create_symlink",  "nginx:reload"
```

Add your vhost files:

```
#
# /config/vhosts/staging.vhost.conf.erb
#

server {
  listen 80;

  server_name staging.ournewserver.co.uk;
  root /var/www/staging.ournewserver.co.uk/current/public;
  passenger_enabled on;
  rails_env staging;
  client_max_body_size 4M;

  # serve static content directly
  location ~* \.(ico|jpg|gif|png|swf|html)$ {
    if (-f $request_filename) {
      expires max;
      break;
    }
  }
}
```

and

```
#
# /config/vhosts/production.vhost.conf.erb
#

server {
  listen 80;

  server_name ournewserver.co.uk;
  root /var/www/ournewserver.co.uk/current/public;
  passenger_enabled on;
  rails_env staging;
  client_max_body_size 4M;

  # serve static content directly
  location ~* \.(ico|jpg|gif|png|swf|html)$ {
    if (-f $request_filename) {
      expires max;
      break;
    }
  }
}
```

Now you need to update your multi-stage files to include these:

```
#
# config/deploy/staging.rb
#

server 'ournewserver.co.uk', :app, :web, :db, :primary => true
set :branch, "staging"
set :rails_env, 'staging'
set :deploy_to, "/var/www/staging.#{application}"
set :vhost_tmpl_name, "staging.vhost.conf.erb"
```

```
#
# config/deploy/production.rb
#

server 'ournewserver.co.uk', :app, :web, :db, :primary => true
set :branch, "staging"
set :rails_env, 'staging'
set :deploy_to, "/var/www/staging.#{application}"
set :vhost_tmpl_name, "production.vhost.conf.erb"
```

## Deploying

This will create the directory structure.

```
$ cap deploy:setup
```

Then you can test each individual task:

```
cap kyan:vhost:setup
```

## Configuration

You can modify any of the following options in your `deploy.rb` config.

- `vhost_env` - Set vhost environment. Default to `rails_env` variable.
- `vhost_tmpl_path` - Set vhost template path. Default to `config/deploy`.
- `vhost_tmpl_name` - Set vhost template name. Default to `vhost.conf.erb`.
- `vhost_server_path` - Set vhost server path. Default to `/etc/nginx/sites-enabled`.
- `procfile` - Set procfile filename for upstart export. Default to `Procfile`.

## Available Tasks

To get a list of all capistrano tasks, run `cap -T`:

```
cap kyan:vhost:setup            # Creates and symlinks an Nginx virtualhost entry.
```

## License

See LICENSE file for details.


text:
include("caf/core/shared/caf_tools.lua")

local usetab = CreateClientConVar("CAF_UseTab", "1", true, false)

local function CAFTab()
    if usetab:GetBool() then
        spawnmenu.AddToolTab("Custom Addon Framework", "CAF")
    end
end

hook.Add("AddToolMenuTabs", "CAFTab", CAFTab)

function CAF_BuildCPanel(cp, toolname, listname, custom)
    cp:AddControl("CheckBox", { Label = "Don't Weld", Command = toolname .. "_DontWeld" })
    cp:AddControl("CheckBox", { Label = "Allow welding to world", Command = toolname .. "_AllowWorldWeld" })
    cp:AddControl("CheckBox", { Label = "Make Frozen", Command = toolname .. "_Frozen" })
    local ListControl = vgui.Create("CAFControl")
    cp:AddPanel(ListControl)
    ListControl:SetList(toolname, listname)
end


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

    Copyright 2005-2014 The Kuali Foundation

    Licensed under the Educational Community License, Version 2.0 (the "License");
    you may not use this file except in compliance with the License.
    You may obtain a copy of the License at

    http://www.opensource.org/licenses/ecl2.php

    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.

-->
<data xmlns="ns:workflow" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="ns:workflow resource:WorkflowData">
	<documentTypes xmlns="ns:workflow/DocumentType" xsi:schemaLocation="ns:workflow/DocumentType resource:DocumentType">
		<documentType>
			<name>SearchDocType_RouteNodeTest</name>
			<parent>SearchDocType</parent>
			<description>SearchDocType_RouteNodeTest</description>
			<label>SearchDocType_RouteNodeTest</label>
			<postProcessorName>org.kuali.rice.kew.postprocessor.DefaultPostProcessor</postProcessorName>
			<docHandler>_blank</docHandler>
			<superUserGroupName namespace="KR-WKFLW">TestWorkgroup</superUserGroupName>
			<blanketApproveGroupName namespace="KR-WKFLW">TestWorkgroup</blanketApproveGroupName>
			<defaultExceptionGroupName namespace="KR-WKFLW">TestWorkgroup</defaultExceptionGroupName>
			<active>true</active>
			<routePaths>
				<routePath>
					<start name="Initial" nextNode="First" />
					<requests name="First" />
				</routePath>
			</routePaths>
			<routeNodes>
				<start name="Initial">
					<activationType>P</activationType>
				</start>
				<requests name="First">
					<activationType>S</activationType>
					<ruleTemplate>searchTemplate</ruleTemplate>
				</requests>
			</routeNodes>
		</documentType>
	</documentTypes>
</data>


text:
const router = require('express').Router();
const mongoose = require('mongoose');
const _ = require('underscore');
const file = require('file');
const multer = require('multer');

module.exports = () => {
  console.log('* packages loading *');
  return {
    router,
    mongoose,
    _,
    file,
    multer,
  };
};


text:
import {
  SELECT_SUBREDDIT,
  INVALIDATE_SUBREDDIT,
  REQUEST_POSTS,
  RECEIVE_POSTS
} from './constants'

export function selectSubreddit(subreddit) {
  return {
    type: SELECT_SUBREDDIT,
    subreddit
  };
}

export function invalidateSubreddit(subreddit) {
  return {
    type: INVALIDATE_SUBREDDIT,
    subreddit
  };
}

export function requestPosts(subreddit) {
  return {
    type: REQUEST_POSTS,
    subreddit
  };
}

export function receivePosts(subreddit, json) {
  return {
    type: RECEIVE_POSTS,
    subreddit,
    posts: json.data.children.map(child => child.data)
  };
}


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

?>

Notice Resources

PREFACE:

Notices may optionally have a resource attached to them.  The user will be able to click on the link to be able to view the resource whether it is an external link or a document you've uploaded.

Attach Resources

Select a resource from the <select><option>-- Optional: Attach a Resource --</option></select> drop-down

Unattach Resources

Select a the "-- Optional: Attach a Resource --" from the <select><option>-- Optional: Attach a Resource --</option></select> drop-down

Deleting Notices

Step One

You may choose to delete the notice by clicking the <input type="checkbox"> checkbox next to the Delete this Notice text.

Step Two

Click the <button class="uk-button uk-button-primary uk-button-mini">Submit</button> button to save changes.


text:
package com.hazelcast.instance;

import com.hazelcast.cardinality.CardinalityEstimator;
import com.hazelcast.cardinality.impl.CardinalityEstimatorService;
import com.hazelcast.client.impl.ClientServiceProxy;
import com.hazelcast.collection.impl.list.ListService;
import com.hazelcast.collection.impl.queue.QueueService;
import com.hazelcast.collection.impl.set.SetService;
import com.hazelcast.concurrent.atomiclong.AtomicLongService;
import com.hazelcast.concurrent.atomicreference.AtomicReferenceService;
import com.hazelcast.concurrent.countdownlatch.CountDownLatchService;
import com.hazelcast.concurrent.idgen.IdGeneratorService;
import com.hazelcast.concurrent.lock.LockService;
import com.hazelcast.concurrent.semaphore.SemaphoreService;
import com.hazelcast.config.Config;
import com.hazelcast.core.ClientService;
import com.hazelcast.core.Cluster;
import com.hazelcast.core.DistributedObject;
import com.hazelcast.core.DistributedObjectListener;
import com.hazelcast.core.HazelcastInstance;
import com.hazelcast.core.HazelcastInstanceAware;
import com.hazelcast.core.IAtomicLong;
import com.hazelcast.core.IAtomicReference;
import com.hazelcast.core.ICountDownLatch;
import com.hazelcast.core.IExecutorService;
import com.hazelcast.core.IList;
import com.hazelcast.core.ILock;
import com.hazelcast.core.IMap;
import com.hazelcast.core.IQueue;
import com.hazelcast.core.ISemaphore;
import com.hazelcast.core.ISet;
import com.hazelcast.core.ITopic;
import com.hazelcast.core.IdGenerator;
import com.hazelcast.core.ManagedContext;
import com.hazelcast.core.Member;
import com.hazelcast.core.MultiMap;
import com.hazelcast.core.PartitionService;
import com.hazelcast.core.ReplicatedMap;
import com.hazelcast.durableexecutor.DurableExecutorService;
import com.hazelcast.durableexecutor.impl.DistributedDurableExecutorService;
import com.hazelcast.executor.impl.DistributedExecutorService;
import com.hazelcast.internal.jmx.ManagementService;
import com.hazelcast.internal.serialization.InternalSerializationService;
import com.hazelcast.logging.ILogger;
import com.hazelcast.logging.LoggingService;
import com.hazelcast.map.impl.MapService;
import com.hazelcast.mapreduce.JobTracker;
import com.hazelcast.mapreduce.impl.MapReduceService;
import com.hazelcast.memory.MemoryStats;
import com.hazelcast.multimap.impl.MultiMapService;
import com.hazelcast.quorum.QuorumService;
import com.hazelcast.replicatedmap.impl.ReplicatedMapService;
import com.hazelcast.ringbuffer.Ringbuffer;
import com.hazelcast.ringbuffer.impl.RingbufferService;
import com.hazelcast.scheduledexecutor.IScheduledExecutorService;
import com.hazelcast.scheduledexecutor.impl.DistributedScheduledExecutorService;
import com.hazelcast.spi.ProxyService;
import com.hazelcast.spi.annotation.PrivateApi;
import com.hazelcast.spi.impl.SerializationServiceSupport;
import com.hazelcast.topic.impl.TopicService;
import com.hazelcast.topic.impl.reliable.ReliableTopicService;
import com.hazelcast.transaction.HazelcastXAResource;
import com.hazelcast.transaction.TransactionContext;
import com.hazelcast.transaction.TransactionException;
import com.hazelcast.transaction.TransactionManagerService;
import com.hazelcast.transaction.TransactionOptions;
import com.hazelcast.transaction.TransactionalTask;
import com.hazelcast.transaction.impl.xa.XAService;
import com.hazelcast.util.EmptyStatement;
import com.hazelcast.util.ExceptionUtil;

import java.util.Collection;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.ConcurrentMap;

import static com.hazelcast.util.Preconditions.checkNotNull;

@PrivateApi
@SuppressWarnings({"checkstyle:methodcount", "checkstyle:classfanoutcomplexity"})
public class HazelcastInstanceImpl implements HazelcastInstance, SerializationServiceSupport {

    @SuppressWarnings("checkstyle:visibilitymodifier")
    public final Node node;

    final ILogger logger;

    final String name;

    final ManagementService managementService;

    final LifecycleServiceImpl lifecycleService;

    final ManagedContext managedContext;

    final ConcurrentMap<String, Object> userContext = new ConcurrentHashMap<String, Object>();

    final HazelcastInstanceCacheManager hazelcastCacheManager;

    @SuppressWarnings("checkstyle:executablestatementcount")
    protected HazelcastInstanceImpl(String name, Config config, NodeContext nodeContext)
            throws Exception {
        this.name = name;
        this.lifecycleService = new LifecycleServiceImpl(this);

        ManagedContext configuredManagedContext = config.getManagedContext();
        managedContext = new HazelcastManagedContext(this, configuredManagedContext);

        //we are going to copy the user-context map of the Config so that each HazelcastInstance will get its own
        //user-context map instance instead of having a shared map instance. So changes made to the user-context map
        //in one HazelcastInstance will not reflect on other the user-context of other HazelcastInstances.
        userContext.putAll(config.getUserContext());
        node = createNode(config, nodeContext);

        try {
            logger = node.getLogger(getClass().getName());

            node.start();

            if (!node.isRunning()) {
                throw new IllegalStateException("Node failed to start!");
            }

            managementService = new ManagementService(this);
            initManagedContext(configuredManagedContext);

            this.hazelcastCacheManager = new HazelcastInstanceCacheManager(this);
            ClassLoader classLoader = node.getConfigClassLoader();
            if (classLoader instanceof HazelcastInstanceAware) {
                ((HazelcastInstanceAware) classLoader).setHazelcastInstance(this);
            }
        } catch (Throwable e) {
            try {
                // Terminate the node by terminating node engine,
                // connection manager, multicast service, operation threads, etc ... if they are exist
                node.shutdown(true);
            } catch (Throwable ignored) {
                EmptyStatement.ignore(ignored);
            }
            throw ExceptionUtil.rethrow(e);
        }
    }

    protected Node createNode(Config config, NodeContext nodeContext) {
        return new Node(this, config, nodeContext);
    }

    private void initManagedContext(ManagedContext configuredManagedContext) {
        if (configuredManagedContext != null) {
            if (configuredManagedContext instanceof HazelcastInstanceAware) {
                ((HazelcastInstanceAware) configuredManagedContext).setHazelcastInstance(this);
            }
        }
    }

    public ManagementService getManagementService() {
        return managementService;
    }

    @Override
    public String getName() {
        return name;
    }

    @Override
    public <K, V> IMap<K, V> getMap(String name) {
        checkNotNull(name, "Retrieving a map instance with a null name is not allowed!");
        return getDistributedObject(MapService.SERVICE_NAME, name);
    }

    @Override
    public <E> IQueue<E> getQueue(String name) {
        checkNotNull(name, "Retrieving a queue instance with a null name is not allowed!");
        return getDistributedObject(QueueService.SERVICE_NAME, name);
    }

    @Override
    public <E> ITopic<E> getTopic(String name) {
        checkNotNull(name, "Retrieving a topic instance with a null name is not allowed!");
        return getDistributedObject(TopicService.SERVICE_NAME, name);
    }

    @Override
    public <E> ITopic<E> getReliableTopic(String name) {
        checkNotNull(name, "Retrieving a topic instance with a null name is not allowed!");
        return getDistributedObject(ReliableTopicService.SERVICE_NAME, name);
    }

    @Override
    public <E> ISet<E> getSet(String name) {
        checkNotNull(name, "Retrieving a set instance with a null name is not allowed!");
        return getDistributedObject(SetService.SERVICE_NAME, name);
    }

    @Override
    public <E> IList<E> getList(String name) {
        checkNotNull(name, "Retrieving a list instance with a null name is not allowed!");
        return getDistributedObject(ListService.SERVICE_NAME, name);
    }

    @Override
    public <K, V> MultiMap<K, V> getMultiMap(String name) {
        checkNotNull(name, "Retrieving a multi-map instance with a null name is not allowed!");
        return getDistributedObject(MultiMapService.SERVICE_NAME, name);
    }

    @Override
    public JobTracker getJobTracker(String name) {
        checkNotNull(name, "Retrieving a job tracker instance with a null name is not allowed!");
        return getDistributedObject(MapReduceService.SERVICE_NAME, name);
    }

    @Override
    public <E> Ringbuffer<E> getRingbuffer(String name) {
        checkNotNull(name, "Retrieving a ringbuffer instance with a null name is not allowed!");
        return getDistributedObject(RingbufferService.SERVICE_NAME, name);
    }

    @Override
    public ILock getLock(String key) {
        checkNotNull(key, "Retrieving a lock instance with a null key is not allowed!");
        return getDistributedObject(LockService.SERVICE_NAME, key);
    }

    @Override
    public <T> T executeTransaction(TransactionalTask<T> task)
            throws TransactionException {
        return executeTransaction(TransactionOptions.getDefault(), task);
    }

    @Override
    public <T> T executeTransaction(TransactionOptions options, TransactionalTask<T> task)
            throws TransactionException {
        TransactionManagerService transactionManagerService = node.nodeEngine.getTransactionManagerService();
        return transactionManagerService.executeTransaction(options, task);
    }

    @Override
    public TransactionContext newTransactionContext() {
        return newTransactionContext(TransactionOptions.getDefault());
    }

    @Override
    public TransactionContext newTransactionContext(TransactionOptions options) {
        TransactionManagerService transactionManagerService = node.nodeEngine.getTransactionManagerService();
        return transactionManagerService.newTransactionContext(options);
    }

    @Override
    public IExecutorService getExecutorService(String name) {
        checkNotNull(name, "Retrieving an executor instance with a null name is not allowed!");
        return getDistributedObject(DistributedExecutorService.SERVICE_NAME, name);
    }

    @Override
    public DurableExecutorService getDurableExecutorService(String name) {
        checkNotNull(name, "Retrieving a durable executor instance with a null name is not allowed!");
        return getDistributedObject(DistributedDurableExecutorService.SERVICE_NAME, name);
    }

    @Override
    public IdGenerator getIdGenerator(String name) {
        checkNotNull(name, "Retrieving an ID-generator instance with a null name is not allowed!");
        return getDistributedObject(IdGeneratorService.SERVICE_NAME, name);
    }

    @Override
    public IAtomicLong getAtomicLong(String name) {
        checkNotNull(name, "Retrieving an atomic-long instance with a null name is not allowed!");
        return getDistributedObject(AtomicLongService.SERVICE_NAME, name);
    }

    @Override
    public <E> IAtomicReference<E> getAtomicReference(String name) {
        checkNotNull(name, "Retrieving an atomic-reference instance with a null name is not allowed!");
        return getDistributedObject(AtomicReferenceService.SERVICE_NAME, name);
    }

    @Override
    public ICountDownLatch getCountDownLatch(String name) {
        checkNotNull(name, "Retrieving a countdown-latch instance with a null name is not allowed!");
        return getDistributedObject(CountDownLatchService.SERVICE_NAME, name);
    }

    @Override
    public ISemaphore getSemaphore(String name) {
        checkNotNull(name, "Retrieving a semaphore instance with a null name is not allowed!");
        return getDistributedObject(SemaphoreService.SERVICE_NAME, name);
    }

    @Override
    public <K, V> ReplicatedMap<K, V> getReplicatedMap(String name) {
        checkNotNull(name, "Retrieving a replicated map instance with a null name is not allowed!");
        return getDistributedObject(ReplicatedMapService.SERVICE_NAME, name);
    }

    @Override
    public HazelcastInstanceCacheManager getCacheManager() {
        return hazelcastCacheManager;
    }

    @Override
    public Cluster getCluster() {
        return node.clusterService;
    }

    @Override
    public Member getLocalEndpoint() {
        return node.getLocalMember();
    }

    @Override
    public Collection<DistributedObject> getDistributedObjects() {
        ProxyService proxyService = node.nodeEngine.getProxyService();
        return proxyService.getAllDistributedObjects();
    }

    @Override
    public Config getConfig() {
        return node.getConfig();
    }

    @Override
    public ConcurrentMap<String, Object> getUserContext() {
        return userContext;
    }

    @Override
    public PartitionService getPartitionService() {
        return node.partitionService.getPartitionServiceProxy();
    }

    @Override
    public QuorumService getQuorumService() {
        return node.nodeEngine.getQuorumService();
    }

    @Override
    public ClientService getClientService() {
        return new ClientServiceProxy(node);
    }

    @Override
    public LoggingService getLoggingService() {
        return node.loggingService;
    }

    @Override
    public LifecycleServiceImpl getLifecycleService() {
        return lifecycleService;
    }

    @Override
    public void shutdown() {
        getLifecycleService().shutdown();
    }

    @Override
    @SuppressWarnings("unchecked")
    public <T extends DistributedObject> T getDistributedObject(String serviceName, String name) {
        ProxyService proxyService = node.nodeEngine.getProxyService();
        return (T) proxyService.getDistributedObject(serviceName, name);
    }

    @Override
    public String addDistributedObjectListener(DistributedObjectListener distributedObjectListener) {
        final ProxyService proxyService = node.nodeEngine.getProxyService();
        return proxyService.addProxyListener(distributedObjectListener);
    }

    @Override
    public boolean removeDistributedObjectListener(String registrationId) {
        final ProxyService proxyService = node.nodeEngine.getProxyService();
        return proxyService.removeProxyListener(registrationId);
    }

    @Override
    public InternalSerializationService getSerializationService() {
        return node.getSerializationService();
    }

    public MemoryStats getMemoryStats() {
        return node.getNodeExtension().getMemoryStats();
    }

    @Override
    public HazelcastXAResource getXAResource() {
        return getDistributedObject(XAService.SERVICE_NAME, XAService.SERVICE_NAME);
    }

    @Override
    public CardinalityEstimator getCardinalityEstimator(String name) {
        return getDistributedObject(CardinalityEstimatorService.SERVICE_NAME, name);
    }

    @Override
    public IScheduledExecutorService getScheduledExecutorService(String name) {
        return getDistributedObject(DistributedScheduledExecutorService.SERVICE_NAME, name);
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) {
            return true;
        }
        if (o == null || !(o instanceof HazelcastInstance)) {
            return false;
        }

        HazelcastInstance that = (HazelcastInstance) o;
        return !(name != null ? !name.equals(that.getName()) : that.getName() != null);
    }

    @Override
    public int hashCode() {
        return name != null ? name.hashCode() : 0;
    }

    @Override
    public String toString() {
        return "HazelcastInstance{name='" + name + "', node=" + node.getThisAddress() + '}';
    }
}


text:
Android Toolkit for Arch Linux (Manjaro, VeltOS), Debian (Knoppix, Ubuntu, Elementary OS, Tails, LinuxMint), Red Hat (Fedora, CentOS, openSUSE)

This page contains a tool binary image files that allow you to restore your Nexus device's original factory firmware. These binary image files are written for your convenience, for example, if you are a tester and custom firmware you have to often return the phone to its original state.

And also, this tool allows you to set custom recovery, lock/unlock bootloader and erasing partitions.

## Features
- Automatically installs the necessary software (Fastboot/ADB)
- Automatically downloads the required recovery (Cyanogen Recovery/[CWM](https://www.clockworkmod.com/rommanager)/[TWRP](https://twrp.me/)/[Stock](https://developers.google.com/android/nexus/images))
- Automatically downloads the [original](https://developers.google.com/android/nexus/images) firmware image for your devices

## Flashing Instructions
 - Download the script

Run in the console:

    git clone https://github.com/igor-dyatlov/nexus-toolkit-script.git

 Alternatively you can [download](https://github.com/igor-dyatlov/nexus-toolkit-script/archive/master.zip) this repository.

 - Connect your device to your computer over USB

Run from source folder:

    ./start.sh

On your device, go into Settings -> About and find the Build Number and tap on it 7 times to enable developer settings. Press back and go into Developer Options and enable USB debugging. From your computer, open a command prompt and type:

Excellent! Good luck in the firmware

## Screenshots

### Donation
https://www.paypal.me/IgorDyatlov

### License
All files in this project are under the [LICENSE.md](LICENSE.md) license unless otherwise stated in the file or by a dependency's license file.


text:
'use strict';

const Audit = require('../../../audits/accessibility/dlitem.js');
const assert = require('assert').strict;

/* eslint-env jest */

describe('Accessibility: dlitem audit', () => {
  it('generates an audit output', () => {
    const artifacts = {
      Accessibility: {
        violations: [{
          id: 'dlitem',
          nodes: [],
          help: 'http://example.com/',
        }],
      },
    };

    const output = Audit.audit(artifacts);
    assert.equal(output.score, 0);
  });

  it('generates an audit output (single node)', () => {
    const artifacts = {
      Accessibility: {
        violations: [{
          id: 'dlitem',
          nodes: [],
          help: 'http://example.com/',
        }],
      },
    };

    const output = Audit.audit(artifacts);
    assert.equal(output.score, 0);
  });
});


text:
<?php

class Issue498Test extends PHPUnit_Framework_TestCase
{

    /**
     * @test
     * @dataProvider shouldBeTrueDataProvider
     * @group        falseOnly
     */
    public function shouldBeTrue( $testData )
    {

        $this->assertTrue( true );
    }

    /**
     * @test
     * @dataProvider shouldBeFalseDataProvider
     * @group        trueOnly
     */
    public function shouldBeFalse( $testData )
    {

        $this->assertFalse( false );
    }

    public function shouldBeTrueDataProvider()
    {

        //throw new Exception("Can't create the data");
        return array(
            array( true ),
            array( false )
        );
    }

    public function shouldBeFalseDataProvider()
    {

        throw new Exception( "Can't create the data" );

        return array(
            array( true ),
            array( false )
        );
    }
}


text:
package controllers

import play.api.mvc._

import scala.concurrent.{ExecutionContext, Future}

/**
 *
 * @author ponkotuy
 * Date: 14/02/25
 */
object Common extends Controller {
  type Req = Map[String, Seq[String]]

  def reqHead(request: Req)(key: String): Option[String] = {
    for {
      results <- request.get(key)
      one <- results.headOption
    } yield one
  }

  def returnString[A](f: => A)(implicit ec: ExecutionContext) = actionAsync { Ok(f.toString) }

  def actionAsync(f: => Result)(implicit ec: ExecutionContext) = Action.async { request =>
    Future {
      try {
        f
      } catch {
        case e: IllegalArgumentException => BadRequest(e.getMessage)
      }
    }
  }

  def actionAsync(f: (Request[AnyContent]) => Result)(implicit ec: ExecutionContext)  = Action.async { request =>
    Future {
      try {
        f(request)
      } catch {
        case e: IllegalArgumentException => BadRequest(e.getMessage)
      }
    }
  }

  def formAsync(f: Request[Map[String, Seq[String]]] => Result)(implicit ec: ExecutionContext)  = Action.async(parse.urlFormEncoded) { request =>
    Future {
      try {
        f(request)
      } catch {
        case e: IllegalArgumentException => BadRequest(e.getMessage)
      }
    }
  }
}


text:
<?php

namespace AppBundle\Service;

/**
 * Class CourierService.
 *
 * @category Service
 */
class CourierService
{
    /**
     * @var \Swift_Mailer
     */
    private $mailer;

    /**
     * Methods.
     */

    /**
     * CourierService constructor.
     *
     * @param \Swift_Mailer $mailer
     */
    public function __construct(\Swift_Mailer $mailer)
    {
        $this->mailer = $mailer;
    }

    /**
     * Build an email.
     *
     * @param string      $from
     * @param string      $toEmail
     * @param string      $subject
     * @param string      $body
     * @param string|null $replyAddress
     * @param string|null $toName
     *
     * @return \Swift_Message
     */
    private function buildSwiftMesage($from, $toEmail, $subject, $body, $replyAddress = null, $toName = null)
    {
        $message = new \Swift_Message();
        $message
            ->setSubject($subject)
            ->setFrom($from)
            ->setTo($toEmail, $toName)
            ->setBody($body)
            ->setCharset('UTF-8')
            ->setContentType('text/html');
        if (!is_null($replyAddress)) {
            $message->setReplyTo($replyAddress);
        }

        return $message;
    }

    /**
     * Send an email.
     *
     * @param string      $from
     * @param string      $toEmail
     * @param string      $subject
     * @param string      $body
     * @param string|null $replyAddress
     * @param string|null $toName
     *
     * @return int
     */
    public function sendEmail($from, $toEmail, $subject, $body, $replyAddress = null, $toName = null)
    {
        $message = $this->buildSwiftMesage($from, $toEmail, $subject, $body, $replyAddress, $toName);

        return $this->mailer->send($message);
    }

    /**
     * Send an email with an attatchment PDF.
     *
     * @param string $from
     * @param string $toEmail
     * @param string $toName
     * @param string $subject
     * @param string $body
     * @param string $pdfFilename
     * @param \TCPDF $pdf
     *
     * @return int
     */
    public function sendEmailWithPdfAttached($from, $toEmail, $toName, $subject, $body, $pdfFilename, \TCPDF $pdf)
    {
        $swiftAttatchment = new \Swift_Attachment($pdf->Output($pdfFilename, 'S'), $pdfFilename, 'application/pdf');
        $message = $this->buildSwiftMesage($from, $toEmail, $subject, $body, null, $toName);
        $message->attach($swiftAttatchment);

        return $this->mailer->send($message);
    }
}


text:
<?php
// +-----------------------------------------------------------------------+
// | Piwigo - a PHP based photo gallery                                    |
// +-----------------------------------------------------------------------+
// | Copyright(C) 2008-2014 Piwigo Team                  http://piwigo.org |
// | Copyright(C) 2003-2008 PhpWebGallery Team    http://phpwebgallery.net |
// | Copyright(C) 2002-2003 Pierrick LE GALL   http://le-gall.net/pierrick |
// +-----------------------------------------------------------------------+
// | This program is free software; you can redistribute it and/or modify  |
// | it under the terms of the GNU General Public License as published by  |
// | the Free Software Foundation                                          |
// |                                                                       |
// | This program is distributed in the hope that it will be useful, but   |
// | WITHOUT ANY WARRANTY; without even the implied warranty of            |
// | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU      |
// | General Public License for more details.                              |
// |                                                                       |
// | You should have received a copy of the GNU General Public License     |
// | along with this program; if not, write to the Free Software           |
// | Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, |
// | USA.                                                                  |
// +-----------------------------------------------------------------------+
$lang[' and %d virtual'] = 'ha %d galloudel';
$lang[' and %d virtuals'] = 'ha %d galloudel';
$lang['Add a virtual album'] = 'Ouzhpennañ ur rummad galloudel';
$lang['Virtual Links'] = 'Liammoù galloudel';
$lang['Virtual album'] = 'Rummad galloudel';
$lang['Virtual album added'] = 'Rummad galloudel ouzhpennet';
$lang['Virtual album deleted'] = 'Rummad galloudel dilemet';
$lang['Virtual album name'] = 'Anv ar rummad galloudel';
$lang['Virtual albums to move'] = 'Rummadoù galloudel da zilec\'hiañ';
$lang['With no virtual album'] = 'Hep rummad galloudel';
$lang['%d album moved'] = 'dilec\'hiet %d rummad';
$lang['%d albums moved'] = 'dilec\'hiet %d rummad';
$lang['%d day'] = '%d deiz';
$lang['%d days'] = '%d deiz';
$lang['%d anomalies have been detected corrected.'] = '%d direizhder a zo bet detektet ha reizhet.';
$lang['%d anomalies have been detected.'] = '%d direizhder a zo bet detektet.';
$lang['%d anomalies have been ignored.'] = '%d direizhder n\'int ket bet reizhet.';
$lang['%d anomalies have not been corrected.'] = '%d direizhder n\'int ket bet posubl reizhañ.';
$lang['%d anomaly has been corrected.'] = '%d direizhder a zo bet reizhet.';
$lang['%d anomaly has been detected.'] = '%d direizhder a zo bet detektet.';
$lang['%d anomaly has been ignored.'] = '%d direizhder n\'eo ket bet reizhet.';
$lang['%d anomaly has not been corrected.'] = '%d direizhder n\'eo ket bet posubl reizhañ.';
$lang['%d guest'] = '%d gweladenner';
$lang['%d guests'] = '%d gweladenner';
$lang['%d hour'] = '%d eurvezh';
$lang['%d hours'] = '%d eurvezh';
$lang['%d member'] = '%d ezel';
$lang['%d members'] = '%d ezel';
$lang['%d month'] = '%d mizvezh';
$lang['%d months'] = '%d mizvezh';
$lang['%d second'] = '%d eilenn';
$lang['%d seconds'] = '%d eilenn';
$lang['%d photo was deleted'] = '%d luc\'hskeudenn dilemet';
$lang['%d photos uploaded'] = '%d luc\'hskeudenn pellgarget';
$lang['%d photos were deleted'] = '%d luc\'hskeudenn dilemet';
$lang['%d line filtered'] = '%d linenn silet';
$lang['%d lines filtered'] = '%d linenn silet';
$lang['%d minute'] = '%d munut';
$lang['%d minutes'] = '%d munut';
$lang['%d association'] = '%d kevredigez';
$lang['%d associations'] = '%d kevredigez';
$lang['%d group'] = '%d strollad';
$lang['%d groups'] = '%d strollad';
$lang['%d mail was not sent.'] = '%d postel n\'eo ket bet kaset.';
$lang['%d mail was sent.'] = '%d postel a zo bet kaset.';
$lang['%d mails were not sent.'] = '%d postel n\'int ket bet kaset.';
$lang['%d mails were sent.'] = '%d postel a zo bet kaset.';
$lang['%d album including'] = '%d rummad, dioutañ';
$lang['%d albums including'] = '%d rummad, diouto';
$lang['%d tag'] = '%d merker';
$lang['%d week'] = '%d sizhunvezh';
$lang['%d weeks'] = '%d sizhunvezh';
$lang['%d year'] = '%d bloavezh';
$lang['%d years'] = '%d bloavezh';
$lang['%s ago'] = '%s zo';
$lang['%s in the future'] = '%s en dazont';
$lang['%d user'] = '%d implijer';
$lang['%d user deleted'] = '%d implijer dilemet';
$lang['%d users'] = '%d implijer';
$lang['%d users deleted'] = '%d implijer dilemet';
$lang['Notify administrators when a comment is'] = 'Kemenn ar merour pa vez un evezhiadenn';
$lang['%d of %d photos selected'] = '%d luc\'hskeudenn etre %d diuzet';
$lang['%d of %d users selected'] = '%d implijer etre %d diuzet';
$lang['%d parameter was updated.'] = '%d arventenn hizivaet.';
$lang['%d parameters were updated.'] = '%d arventenn hizivaet.';
$lang['Status of user "%s" updated'] = 'Statud implijer "%s" hizivaet';
$lang['Update user'] = 'Hizivaat implijer';
$lang['Updates'] = 'Hizivadurioù';
$lang['User %s updated'] = 'Implijer %s hizivaet';
$lang['You can update to Piwigo %s directly, without upgrading to Piwigo %s (recommended).'] = 'Posubl eo hizivaat betek Piwigo %s war-eeun, hep hizivaat da Piwigo %s (erbedet).';
$lang['photos updated in the database'] = 'luc\'hskeudennoù hizivaet en diaz roadennoù';
$lang['update the database from files'] = 'Hizivaat an diaz roadennoù gant ar restroù';
$lang['group "%s" updated'] = 'strollad "%s" hizivaet';
$lang['This is a major update, with new exciting features.'] = 'Un hizivadur meur eo, gant arc\'hweladurioù nevez a-feson.';
$lang['This is a minor update, with only bug corrections.'] = 'Un hizivadur bihan eo, gant reizhadurioù drein hepken.';
$lang['Update photos information'] = 'Hizivaat titouroù al luc\'hskeudenn';
$lang['Two updates are available'] = 'Daou hizivadur hergerzh';
$lang['Update All'] = 'Hizivaat pep tra';
$lang['Update Complete'] = 'Echu eo an hizivadur';
$lang['Update albums informations'] = 'Hizivaat titouroù ar rummadoù';
$lang['Update in progress... Please wait.'] = 'Hizivadur war ober… Gortozit.';
$lang['Update to Piwigo %s'] = 'Hizivaat betek Piwigo %s';
$lang['Reject'] = 'Dinac\'h';
$lang['%d user comment validated'] = '%d evezhiadenn implijerien kadarnaet';
$lang['%d user comments validated'] = '%d evezhiadenn implijerien kadarnaet';
$lang['User comments validation'] = 'Kadarnaat evezhiadennoù an implijerien';
$lang['%d user comment rejected'] = '%d evezhiadenn implijerien diwiriekaet';
$lang['Activate comments'] = 'Gweredekaat an evezhiadennoù';
$lang['Comments for all'] = 'Evezhiadennoù evit an holl';
$lang['Default comments order'] = 'Urzh an evezhiadennoù dre ziouer';
$lang['%d user comments rejected'] = '%d evezhiadenn implijerien diwiriekaet';
$lang['Pending Comments'] = 'Evezhiadennoù o c\'hortoz';
$lang['%d tags'] = '%d merker';
$lang['%d physical'] = '%d fizikel';
$lang['%d physicals'] = '%d fizikel';
$lang['... or '] = '… pe';
$lang['Photo informations updated'] = 'Hizivaet titouroù al luc\'hskeudenn';
$lang['Password updated'] = 'Hizivaet ar ger-tremen';
$lang['Check for updates'] = 'Sell ma vez hizivadurioù';
$lang['%d user was not updated.'] = '%d implijer n\'eo ket bet hizivaet';
$lang['%d users were not updated.'] = '%d implijer n\'int ket bet hizivaet';
$lang['Ignore this update'] = 'Leuskel an hizivadur-mañ';
$lang['%d user was updated.'] = '%d implijer hizivaet';
$lang['Album updated successfully'] = 'Rummad hizivaet mat';
$lang['Piwigo Update'] = 'Hizivadur Piwigo';
$lang['%d users were updated.'] = '%d implijer hizivaet';
$lang['%s has been successfully updated.'] = '%s a zo bet hizivaet';
$lang['Reset ignored updates'] = 'Adderaouiñ an hizivadurioù dilezet';
$lang['Add Photos'] = 'Lakaat luc\'hskeudennoù ouzhpenn';
$lang['Add a tag'] = 'Lakaat ur merker ouzhpenn';
$lang['Add a user'] = 'Lakaat un implijer ouzhpenn';
$lang['%s photos can not be regenerated'] = '%s luc\'hskeudenn a zo bet adgraet';
$lang['%s photos have been regenerated'] = '%s luc\'hskeudenn a zo bet adgraet';
$lang['Photos generation in progress...'] = 'Oc\'h ober al luc\'hskeudennoù…';
$lang['Thumbnails generation in progress...'] = 'Oc\'h ober ar skeudennoùigoù…';
$lang['Email admins when a comment requires validation'] = 'Kas ur bostel pa vez ezhom da gadarnaat un evezhiadenn';
$lang['Validate'] = 'Kadarnaat';
$lang['Validation'] = 'Kadarnadur';
$lang['pending validation'] = 'o c\'hortoz ar c\'hadarnadur';
$lang['%d waiting for validation'] = '%d o c\'hortoz ar c\'hadarnadur';
$lang['The uploaded file exceeds the MAX_FILE_SIZE directive that was specified in the HTML form'] = 'Ar restr ezkarget a zo pounneroc\'h eget sturiad MAX_FILE_SIZE lakaet e furmskrid HTML.';
$lang['Start Upload'] = 'Kregiñ gant an ezkargañ';
$lang['The uploaded file exceeds the upload_max_filesize directive in php.ini: %sB'] = 'Ar restr ezkarget a zo pounneroc\'h eget sturiad upload_max_filesize e php.ini: %sB';
$lang['The uploaded file was only partially uploaded'] = 'Ar restr da ezkargañ a zo bet ezkarget a-zarn hepken';
$lang['The uploaded files exceed the post_max_size directive in php.ini: %sB'] = 'Ar restroù ezkarget a zo pounneroc\'h eget sturiad post_max_size e php.ini: %sB';
$lang['Unknown upload error'] = 'Fazi ezkargañ dianav';
$lang['Upload'] = 'Ezkargañ';
$lang['Upload Photos'] = 'Ezkargañ luc\'hskeudennoù';
$lang['Uploaded Photos'] = 'Luc\'hskeudennoù ezkarget';
$lang['You are using the Browser uploader. Try the Flash uploader instead.'] = 'Oc\'h implij an ezkarger er merdeer emaoc\'h. Esaeit an ezkarger Flash kentoc\'h.';
$lang['You are using the Flash uploader. Problems? Try the Browser uploader instead.'] = 'Oc\'h implij an ezkarger Flash emaoc\'h. Kudennoù ? Esaeit an ezkarger er merdeer kentoc\'h.';
$lang['pLoader stands for Piwigo Uploader. From your computer, pLoader prepares your photos and transfer them to your Piwigo photo gallery.'] = 'pLoader a zo un ezkarger Piwigo. pLoader a brient hol luc\'hskeudennoù ha treuzkas anezho eus hoc\'h urzhiater d\'ho palier luc\'hskeudennoù Piwigo.';
$lang['%s must be to set to false in your local/config/config.inc.php file'] = 'Ret eo arventennañ %s da false en ho restr local/config/config.inc.php';
$lang['Add'] = 'Ouzhpennañ';
$lang['Add New Language'] = 'Lakaat ur yezh nevez ouzhpenn';
$lang['Add New Theme'] = 'Lakaat un tem nevez ouzhpenn';
$lang['Add a criteria'] = 'Lakaat un dezverk ouzhpenn';
$lang['Add a filter'] = 'Lakaat ur sil ouzhpenn';
$lang['Add group'] = 'Lakaat ur strollad ouzhpenn';
$lang['Add tags'] = 'Lakaat merkerioù ouzhpenn';
$lang['Add to caddie'] = 'Lakaat er baner';
$lang['%s value is not correct file because exif are not supported'] = 'N\'eo ket reizh talvoud %s peogwir n\'eo ket skoret exif';
$lang['Piwigo for iOS application empowers you to connect to your Piwigo gallery from your iPhone, iPad or iPod Touch, create some albums and upload several photos at once.'] = 'Gant arload Piwigo evit iOS e vo posubl deoc\'h kevreañ hoc\'h iPhone, iPad pe iPod Touch ouzh ho palier Piwigo, krouiñ rummadoù hag ezkargañ ur bern luc\'hskeudennoù en ur wech.';
$lang['Piwigo for Android application empowers you to connect your Android phone or table to your Piwigo gallery, create some albums and upload several photos at once.'] = 'Gant arload Piwigo evit Android e vo posubl deoc\'h kevreañ ho pellgomzer pe tablezenn ouzh ho palier Piwigo, krouiñ rummadoù hag ezkargañ ur bern luc\'hskeudennoù en ur wech.';
$lang['+ Add an upload box'] = '+ Lakaat ur voest-ezkargañ';
$lang[', click on'] = ', klikit war';
$lang['(this tag will be deleted)'] = '(ar merker-mañ a vo dilemet)';
$lang['Delete this language'] = 'Dilemel ar yezh-mañ';
$lang['Delete this theme'] = 'Dilemel an tem-mañ';
$lang['Deleted on'] = 'Dilemet d\'an';
$lang['%u users have automatic permission because they belong to a granted group.'] = 'implijerien %u o deus an aotre emgefreek peogwir int e-barzh ur strollad aotreet.';
$lang['(filtered from %s total users)'] = '(silet etre %s implijer en holl)';
$lang['A locked gallery is only visible to administrators'] = 'Ur palier prennet a vez gwelet gant ar verourien hepken';
$lang['A new version of Piwigo is available.'] = 'Ur stumm nevez Piwigo a zo hegerz';
$lang['ACCESS_0'] = 'Moned dieub';
$lang['ACCESS_1'] = 'Gwelet gant an holl';
$lang['ACCESS_2'] = 'Gwelet gant an implijerien enrollet';
$lang['ACCESS_3'] = 'Gwelet gant ar verourien';
$lang['ACCESS_4'] = 'Gwelet gant ar vistri-gwiad';
$lang['ACCESS_5'] = 'Moned berzet';
$lang['Active Plugins'] = 'Lugantoù gweredekaet';
$lang['Active Themes'] = 'Temoù gweredekaet';
$lang['Active Languages'] = 'Yezhoù gweredekaet';
$lang['Activate icon "%s"'] = 'Gweredekaat an arlun "%s"';
$lang['Activate icon "new" next to albums and pictures'] = 'Gweredekaat an arlun "nevez" e-kichen ar rummadoù hag al luc\'hskeudennoù';
$lang['Activate it now'] = 'Gweredekaat anezhañ diouzhtu';
$lang['Activate'] = 'Gweredekaat';
$lang['Activate Navigation Bar'] = 'Gweredekaat ar varrenn verdeiñ ';
$lang['Activate Navigation Thumbnails'] = 'Gweredekaat skeudennoùigoù-merdeiñ';
$lang['Action'] = 'Obererezh';
$lang['Actions'] = 'Obererezhioù';
$lang['Access type'] = 'Doare moned';
$lang['Added by %s'] = 'Lakaet gant %s';
$lang['Permalink %s has been previously used by album %s. Delete from the permalink history first'] = 'Peurliamm %s a zo bet implijet gant rummad %s. Dilemit anezhañ eus istor ar peurliammoù da gentañ.';
$lang['The permalink name must be composed of a-z, A-Z, 0-9, "-", "_" or "/". It must not be numeric or start with number followed by "-"'] = 'Ret eo lakaat en anv ar peurliamm lizherennoù a-z, A-Z, 0-9, "-", "_" pe "/". Arabat eo lakaat sifroù hepken, pe kregiñ gant ur sifr  ha "-" goude.';
$lang['Save to permalink history'] = 'Enrollañ en istor ar peurliammoù';
$lang['Add/delete a permalink'] = 'Lakaat/Dilemel ur peurliamm';
$lang['Cannot delete the old permalink !'] = 'Ar peurliamm kozh ne c\'hell ket bezañ dilemet!';
$lang['Permalink'] = 'Peurliamm';
$lang['Permalink %s is already used by album %s'] = 'Peurliamm %s a zo implijet gant ar rummad %s dija';
$lang['Permalink history'] = 'Istor ar peurliammoù';
$lang['Permalinks'] = 'Peurliammoù';
$lang['Create the "%s" directory at the root of your Piwigo installation'] = 'Ober kavlec\'h "%s" e penngavlec\'h ho staliadur Piwigo';
$lang['Give write access (chmod 777) to "%s" directory at the root of your Piwigo installation'] = 'Reiñ gwirioù da skrivañ (chmod 777) e kavlec\'h "%s" eus penngavlec\'h ho staliadur Piwigo';
$lang['Add write access to the "%s" directory'] = 'Reiñ gwirioù da skrivañ e kavlec\'h "%s"';
$lang['Add another set of photos'] = 'Lakaat ur stroll luc\'hskeudennoù all';
$lang['Add detailed content'] = 'Lakaat endalc\'h dre ar munud';
$lang['Allow rating'] = 'Aotreiñ da reiñ notennoù';
$lang['All %d photos are selected'] = 'An holl %d luc\'hskeudenn a zo diuzet';
$lang['All %d users are selected'] = 'An holl %d implijer a zo diuzet';
$lang['All languages are up to date.'] = 'An holl yezhoù a zo hizivaet';
$lang['All plugins are up to date.'] = 'An holl lugantoù a zo hizivaet';
$lang['All themes are up to date.'] = 'An holl temoù a zo hizivaet';
$lang['Album manual order was saved'] = 'Urzh dre zorn ar rummad a zo bet enrollet';
$lang['Album name'] = 'Anv ar rummad';
$lang['Album photos associated to the following albums: %s'] = 'Luc\'hskeudennoù liammet gant ar rummadoù-mañ: %s';
$lang['Albums authorized thanks to group associations'] = 'Rummadoù aotreet dre ar strolladoù';
$lang['Albums automatically sorted'] = 'Rummadoù urzhiet emgefreek';
$lang['Album "%s" has been added'] = 'Rummad "%s" a zo bet lakaet ouzhpenn';
$lang['Album "%s" now contains %d photos'] = '%d luc\'hskeudenn a zo er rummad "%s" bremañ';
$lang['Album list management'] = 'Merañ listenn ar rummadoù';
$lang['Allowed file types: %s.'] = 'Seurtoù restroù aotreet: %s';
$lang['All optimizations have been successfully completed.'] = 'An holl gwellekadurioù a zo bet graet.';
$lang['Allow user customization'] = 'Aotren personeladur an implijerien';
$lang['Allow user registration'] = 'Aotren an implijerien d\'en em enrollañ';
$lang['Allow users to delete their own comments'] = 'Aotren an implijerien da zilemel o evezhiadennoù';
$lang['Allow users to edit their own comments'] = 'Aotren an implijerien da cheñch o evezhiadennoù';
$lang['Adobe Photoshop Lightroom is a photography software designed to manage large quantities of digital images and doing post production work.'] = 'Adobe Photoshop Lightroom a zo ur meziant graet evit merañ ur maread luc\'hskeudennoù niverel hag evit ober labour goudeproduiñ.';
$lang['digiKam is an advanced digital photo management free software for Linux, Windows, and MacOSX.'] = 'digiKam a zo ur meziant frank araokaet evit merañ luc\'hskeudennoù niverel gant Linux, Windows, pe MacOS X.';
$lang['File upload stopped by extension'] = 'Paouezet eo bet ezkargañ ar restr gant astenn';
$lang['Some upgrades are available for extensions.'] = 'Hizivadurioù ez eus evit astennoù.';
$lang['All extensions are up to date.'] = 'An holl astennoù a zo hizivaet';
$lang['Exif extension not available, admin should disable exif use'] = 'N\'eo ket hegerzh astenn exif, ret e vefe d\'ar merour diweredekaat implij exif.';
$lang['Extensions Update'] = 'Hizivadur an astennoù';
$lang['Administration Home'] = 'Pajenn-degemer ar merour';
$lang['Advanced features'] = 'Arc\'hweladurioù araokaet';
$lang['An error has occured during upgrade.'] = 'Ur fazi a zo c\'hoarvezet en ur hizivaat.';
$lang['An error occured during extraction (%s).'] = 'Ur fazi a zo c\'hoarvezet en ur eztennañ ar restroù (%s).';
$lang['An information email was sent to group "%s"'] = 'Ur postel gant titouroù a zo bet kaset da strollad "%s"';
$lang['Anomaly'] = 'Direizhder';
$lang['An error has occured during extract. Please check files permissions of your piwigo installation.
Click here to show log error.'] = 'Ur fazi a zo c\'hoarvezet en ur eztennañ. Sellit ouzh aotreoù ar restroù ho staliadur Piwigo.
Klikit amañ evit diskouez renabl ar fazi.';
$lang['By rank'] = 'Dre renk';
$lang['Caddie'] = 'Karrigell';
$lang['Caddie management'] = 'Merañ ar c\'harrigell';
$lang['By %s'] = 'Dre %s';
$lang['Associate to album'] = 'Liammañ ouzh ar rummad';
$lang['Associated'] = 'Liammet';
$lang['Authorized'] = 'Aotreet';
$lang['Apply selected corrections'] = 'Arloañ ar reizhadurioù diuzet';
$lang['Applications'] = 'Arloadoù';
$lang['Apply action'] = 'Arloañ an obererezh';
$lang['Apply to sub-albums'] = 'Arloañ d\'an iz-rummadoù';
$lang['Anyway only webmasters can see this tab and never administrators.'] = 'Ar mestr-gwiad hepken a c\'hell gwellet an ivinell-mañ. Ar merourien ne c\'hellont ket.';
$lang['Date'] = 'Deiziad';
$lang['Configuration'] = 'Kefluniadur';
$lang['Database'] = 'Diaz roadennoù';
$lang['Average rate'] = 'Notenn keitad';
$lang['Cancel'] = 'Nullañ';
$lang['Change password'] = 'Cheñch ger-tremen';
$lang['Watermark'] = 'Ritenn';
$lang['add a new watermark'] = 'Lakaat ur ritenn nevez';
$lang['Apply watermark if height is bigger than'] = 'Lakaat ur ritenn ma vez an uhelder brasoc\'h eget';
$lang['Apply watermark if width is bigger than'] = 'Lakaat ur ritenn ma vez al ledander brasoc\'h eget';
$lang['Aperture is designed for professional photographers with iPhoto simplicity.'] = 'Aperture a zo empennet evit al luc\'hskeudennerien a-vicher, gant aezamant iPhoto.';
$lang['Aperture is a powerful tool to refine images and manage massive libraries on Mac.'] = 'Aperture a zo un ostilh galloudus evit eilaozañ luc\'hskeudennoù ha merañ meur a luc\'hskeudennoù gant MacOSX.';
$lang['iPhoto is the default photo manager on MacOSX. The Piwigo export plugin let you create new albums and export your photos directly from iPhoto to your Piwigo photo gallery.'] = 'iPhoto a zo ar merour-luc\'hskeudennoù dre ziouer gant MacOSX. Gant lugant ezporzhiañ Piwigo e vo posubl deoc\'h krouiñ rummadoù nevez, hag ezporzhiañ ho luc\'hskeudennoù eus iPhoto betek ho palier luc\'hskeudennoù Piwigo.';
$lang['Automatic correction'] = 'Difazier emgefreek';
$lang['Automatic sort order'] = 'Urzh rummañ emgefreek';
$lang['Available on'] = 'Hegerzh e';
$lang['Available only with HTML format'] = 'Hegerzh gant furmad HTML hepken';
$lang['The anomaly will be ignored until next application version'] = 'Ne vo graet netra diwar-benn ar fazi betek stumm an arload a zeu';
$lang['Piwigo version'] = 'Stumm Piwigo';
$lang['You are running the latest version of Piwigo.'] = 'Emañ stumm Piwigo diwezhañ o labourat ganeoc\'h.';
$lang['The version of %s [%s] installed is not compatible with the version required ']['%s'] = 'Stumm %s staliet [%s] n\'eo ket kenglotus gant stumm eo ret kaout [%s]';
$lang['GD version'] = 'Stumm GD';
$lang['New Version'] = 'Stumm nevez';
$lang['Version'] = 'Stumm';
$lang['Authorize users to add comments on selected albums'] = 'Reiñ an aotre d\'an implijerien evit lakaat evezhiadennoù er rummadoù diuzet';
$lang['Are you sure you want to delete this plugin?'] = 'Ha sur oc\'h da zilemel al lugant-se ?';
$lang['Are you sure you want to install this plugin?'] = 'Ha sur oc\'h da staliañ al lugant-se ?';
$lang['Delete selected photos'] = 'Dilemel al luc\'hskeudennoù diuzet';
$lang['Drop into album'] = 'Diuzañ ur rummad';
$lang['Choose an action'] = 'Dibabit un obererezh';
$lang['Center of interest'] = 'Darn talvoudus';
$lang['Change Admin Colors'] = 'Cheñch livioù ar mererezh';
$lang['Change username'] = 'Cheñch anv implijer';
$lang['Available versions for'] = 'Stummoù hegerz evit';
$lang['Basic settings'] = 'Arventennoù diazez';
$lang['By default, the center of interest is placed in the middle of the photo.'] = 'An darn talvoudus e-barzh al luc\'hskeudenn a vez en he c\'hreiz dre ziouer.';
$lang['Can\'t connect to server.'] = 'Ne oa ket posubl kevreañ ouzh ar servijer';
$lang['Languages which need upgrade'] = 'Yezhoù o deus ezhomm un hizivadur';
$lang['Are you sure to install this upgrade? You must verify if this version does not need uninstallation.'] = 'Ha sur oc\'h da gregiñ gant staliadur an hizivaat-se? Ret eo deoc\'h sellout ouzh ar stumm-mañ, ma ne vez ket ezhomm da zistaliañ a-raok.';
$lang['Plugins which need upgrade'] = 'Lugantoù da hizivaat';
$lang['Themes which need upgrade'] = 'Temoù o deus ezhomm un hizivadur';
$lang['Unable to check for upgrade.'] = 'Ne oa ket posubl degas an hizivadur';
$lang['user_status_guest'] = 'Ostiziad ';
$lang['user_status_normal'] = 'Implijer';
$lang['user_status_webmaster'] = 'Mestr-gwiad';
$lang['Approximate maximum resolution: %dM pixels (that\'s %dx%d pixels).'] = 'Diarunusted uc\'hek arnes: %dM piksel (%dx%d piksel).';
$lang['Can\'t download archive.'] = 'Ne oa ket posubl pellgargañ an diell.';
$lang['Can\'t read or extract archive.'] = 'Ne oa ket posubl lenn an diell pe tennañ ar erstroù e-maez.';
$lang['Number of rates'] = 'Niver a notennoù';
$lang['Rate'] = 'Notenn';
$lang['Rate date'] = 'Deiziad an notenn';
$lang['Rated %d times, score : %.2f'] = 'Notennet %d gwech, skor : %.2f';
$lang['Sum of rates'] = 'Sammad an notennoù';
$lang['Number of downloads'] = 'Niver a pellgargoù';
$lang['Download,'] = 'Pellgargañ,';
$lang['Downloads'] = 'Pellgargoù';
$lang['Can\'t create temporary file.'] = 'Ne oa ket posubl krouiñ ar restr badennek';
$lang['Missing a temporary folder'] = 'Ar c\'havlec\'h badennek a vank';
$lang['By default, Piwigo will create a new websize from the HD (high definition) version of your photo.'] = 'Dre ziouer e krouo Piwigo ur ment nevez evit ar gwiad eus stumm HD (despizadur uhel) ho luc\'hseudenn.';
$lang['Batch Manager'] = 'Merour-batch';
$lang['Site manager'] = 'Merour-lec\'hienn';
$lang['Allow users to add a link to their website'] = 'Aotren an implijerien da lakaat ul liamm d\'o lec\'hienn';
$lang['Main "guest" user status is incorrect'] = 'Statud an implijer "guest" a zo direizh';
$lang['Main "webmaster" user status is incorrect'] = 'Statud an implijer "webmaster" a zo direizh';
$lang['Correction the anomaly will cancel the fact that it\'s ignored'] = 'An direizhder reizhet ne vo ket tavet ken';
$lang['Bound Theme'] = 'Tem liammet';
$lang['Correction'] = 'Reizhadur';
$lang['Correction applied with error'] = 'Ur fazi a zo bet graet en ur reizhañ';
$lang['Correction applied with success'] = 'Difaziet hep kudenn';
$lang['Impossible automatic correction'] = 'Ne c\'haller ket difaziañ emgefreek';
$lang['Continue processing treatment'] = 'Kenderc\'hel gant an treterezh war-ober';
$lang['Classic display'] = 'Skrammañ klasel';
$lang['Close user details'] = 'Serriñ titouroù an implijer';
$lang['Complementary mail content'] = 'Endalc\'h ar bostel evit klokaat';
$lang['Confirm merge'] = 'Kadarnaat ar c\'hendeuzadur';
$lang['Check for upgrade'] = 'Sell ma vez un hizivadur';
$lang['Check for upgrade failed for unknown reasons.'] = 'Ne oa ket posubl da sellet ma vez un hizivadur, ha n\'eo ket anavezet an abeg.';
$lang['Check all'] = 'Gwiriañ pep tra';
$lang['Check automatic corrections'] = 'Gwiriañ ar reizhadurioù emgefreek';
$lang['Check integrity'] = 'Gwiriadur an anterinded';
$lang['Choose an option'] = 'Dibabit un dibarzh';
$lang['Deactivate'] = 'Diweredekaat';
$lang['Deactivate all'] = 'Diweredekaat pep tra';
$lang['Do you want to activate anyway?'] = 'Fellout a ra deoc\'h gweredekaat memes tra ?';
$lang['Impossible to deactivate this language, first set another language as default.'] = 'N\'haller ket diweredekaat ar yezh-se, arventannit ur yezh dre ziouer all a-raok.';
$lang['Day'] = 'Deiz';
$lang['Current name'] = 'Anv a-vremañ';
$lang['Database synchronization with files'] = 'Sinkronelaat an diaz roadennoù gant restroù';
$lang['For photo sizes with crop, such as "Square", Piwigo will do its best to include the center of interest.'] = 'Evit ment luc\'hskeudennoù didroc\'het, evel "karrez", Piwigo a raio ar gwellañ ma c\'hello evit enklozañ an darn talvoudus.';
$lang['Not cropped correctly?'] = 'Ne oa ket didroc\'het mat ?';
$lang['Photo sizes with crop'] = 'Ment al luc\'hskeudennoù didroc\'het';
$lang['Create'] = 'Krouiñ';
$lang['Create this site'] = 'Krouiñ al lec\'hienn-mañ';
$lang['Crop'] = 'Didroc\'hañ';
$lang['Directory'] = 'Kavlec\'h';
$lang['Delete multiple size images'] = 'Dilemel mentoù liezek al luc\'hskeudennoù';
$lang['Generate multiple size images'] = 'Krouiñ mentoù liezek al luc\'hskeudennoù';
$lang['Multiple Size'] = 'Mentoù liezek';
$lang['Default photos order'] = 'Urzh al luc\'hskeudennoù dre ziouer';
$lang['Default user cannot be deleted'] = 'N\'haller ket dilemel an arveriad dre ziouer ';
$lang['Default user does not exist'] = 'An arveriad dre ziouer n\'eus ket anezhañ';
$lang['Delete Representant'] = 'Dilemel skeudennig ar rummad';
$lang['display maximum informations (added albums and photos, deleted albums and photos)'] = 'Skrammañ titouroù uc\'hek (rummadoù ha luc\'hskeudennoù ouzhpennet, uc\'hek (rummadoù ha luc\'hskeudennoù dilemet)';
$lang['Include display of recent photos grouped by dates'] = 'Skrammañ al luc\'hskeudennoù nevez e strolladoù dre zeiziad';
$lang['Default display'] = 'Skrammañ dre ziouer';
$lang['Display options'] = 'Dibarzhioù skrammañ';
$lang['No display'] = 'Skrammadur ebet';
$lang['display'] = 'Skrammañ';
$lang['Link all album photos to some existing albums'] = 'Liammañ pep luc\'hskeudenn er rummad da rummadoù a zo anezho';
$lang['Tag "%s" already exists'] = 'Bez ez eus ar merker "%s" anezhañ dija.';
$lang['This site already exists'] = 'Bez ez eus al lec\'hienn anezhañ dija.';
$lang['existing album'] = 'rummad a zo anezhañ';
$lang['Groups and users'] = 'Strolladoù hag implijerien';
$lang['Main "guest" user does not exist'] = 'An implijer "guest" n\'eus ket anezhañ';
$lang['Main "webmaster" user does not exist'] = 'An implijer "webmaster" n\'eus ket anezhañ';
$lang['Directory does not exist'] = 'Ar c\'havlec\'h n\'eus ket anezhañ';
$lang['Deny selected groups'] = 'Berzañ ar strolladoù diuzet';
$lang['Deny selected users'] = 'Berzañ an implijerien diuzet';
$lang['Description'] = 'Deskrivadur';
$lang['Detailed informations'] = 'Titouroù dre ar munud';
$lang['Delete orphan tags'] = 'Dilemel ar merkerioù emzivat';
$lang['Delete selected tags'] = 'Dilemel ar merkerioù diuzet';
$lang['Delete selected users'] = 'Dilemel an implijerien diuzet';
$lang['Deletions'] = 'Dilamadurioù';
$lang['Select the destination tag'] = 'Arveriañ ar merker pal';
$lang['Source tag'] = 'Merker tarzh';