text:
class Solution
  def initialize
    @stack = Array.new
    @queue = Array.new
  end

  def pushCharacter char
    @stack.unshift char
  end

  def popCharacter
    @stack.shift
  end

  def enqueueCharacter char
    @queue.push char
  end

  def dequeueCharacter
    @queue.shift
  end
end

# ******************************Runner code.************************************
words = ['racecar', 'anneivotemorecarsracerometovienna', 'vogleweed']

words.each do |s|
  # s='racecar'
  #Create the Solution class object
  obj=Solution.new()
  l=s.length
  # push/enqueue all the characters of string s to stack
  for i in 0...l
      obj.pushCharacter(s[i])
      obj.enqueueCharacter(s[i])
  end

  isPalindrome=true
  '''
  pop the top character from stack
  dequeue the first character from queue
  compare both the characters
  '''
  for i in 0...(l / 2)
      if obj.popCharacter()!=obj.dequeueCharacter()

          isPalindrome=false
          break
      end
  end
  #finally print whether string s is palindrome or not.
  if isPalindrome
      puts("The word, "+s+", is a palindrome.")
  else
     puts("The word, "+s+", is not a palindrome.")
  end
end


text:
import static java.util.Arrays.stream;
import static java.util.stream.Collectors.toList;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.ArrayDeque;
import java.util.Arrays;
import java.util.Deque;
import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Set;

public class PlayingWithWheels {
    private static final BufferedReader reader = new BufferedReader(
            new InputStreamReader(System.in));

    static class Node {
        int[] node;

        @Override
        public int hashCode() {
            final int prime = 31;
            int result = 1;
            result = prime * result + Arrays.hashCode(node);
            return result;
        }

        @Override
        public boolean equals(Object obj) {
            if (this == obj)
                return true;
            if (obj == null)
                return false;
            if (getClass() != obj.getClass())
                return false;
            Node other = (Node) obj;
            if (!Arrays.equals(node, other.node))
                return false;
            return true;
        }

        public Node(List<Integer> s) {
            this.node = new int[s.size()];
            for (int i = 0; i < s.size(); ++i) {
                this.node[i] = s.get(i).intValue();
            }
        }

        public Node(Node node, int i, int p) {
            this.node = Arrays.copyOf(node.node, node.node.length);
            this.node[i] += p;
            if (this.node[i] < 0) {
                this.node[i] = 9;
            } else {
                this.node[i] %= 10;
            }
        }
    }

    private static Set<Node> adjacent(Node node) {
        Set<Node> adjacent = new HashSet<>();
        for (int i = 0; i < node.node.length; ++i) {
            adjacent.add(new Node(node, i, 1));
            adjacent.add(new Node(node, i, -1));
        }
        return adjacent;
    }

    private static int solve(Node start, Node end, Set<Node> forbidden) {
        if (start.equals(end)) {
            return 0;
        }

        Deque<Node> next = new ArrayDeque<>();
        Set<Node> visited = new HashSet<>();
        Map<Node, Integer> depths = new HashMap<>();

        int depth = 0;
        next.push(start);
        depths.put(start, depth);

        while (!next.isEmpty()) {
            Node node = next.pop();
            depth = depths.get(node);
            for (Node adjNode : adjacent(node)) {
                if (adjNode.equals(end)) {
                    return forbidden.contains(end) ? -1 : depth + 1;
                }
                if (!forbidden.contains(adjNode) &&
                        !visited.contains(adjNode)) {
                    visited.add(adjNode);
                    next.addLast(adjNode);
                    depths.put(adjNode, depth + 1);
                }
            }
        }

        return -1;
    }

    private static List<Integer> parseLine(String line) {
        return stream(line.trim().split(" "))
                .filter(x -> !x.equals(""))
                .map(Integer::parseInt)
                .collect(toList());
    }

    public static void main(String[] args) throws IOException {
        int n = Integer.parseInt(reader.readLine().trim());
        for (int i = 0; i < n; ++i) {
            String currentLine = "";
            while ((currentLine = reader.readLine()).trim().equals(""))
                ;
            Node start = new Node(parseLine(currentLine));
            Node end = new Node(parseLine(reader.readLine()));
            int m = Integer.parseInt(reader.readLine().trim());
            Set<Node> forbidden = new HashSet<>();
            for (int j = 0; j < m; ++j) {
                forbidden.add(new Node(parseLine(reader.readLine())));
            }
            System.out.println(solve(start, end, forbidden));
        }
    }
}

redpajama_set_name: RedPajamaGithub


text:
<?php

namespace Havvg\Component\Lock\Exception;

class ResourceLockedException extends \RuntimeException implements ExceptionInterface
{

}


text:
if [ -d /usr/local/jdk-6u7-64 ]; then
  export JAVA_HOME=${JAVA_HOME:-/usr/local/jdk-6u7-64}
else
  export JAVA_HOME=${JAVA_HOME:-/usr/local/java/}
fi

# Extra Java CLASSPATH elements.  Optional.
# export HADOOP_CLASSPATH=

# The maximum amount of heap to use, in MB. Default is 1000.
export HADOOP_HEAPSIZE=1000

# Extra Java runtime options.  Empty by default.
# export HADOOP_OPTS=-server
export HADOOP_OPTS="$HADOOP_OPTS -Djava.net.preferIPv4Stack=true"

# Command specific options appended to HADOOP_OPTS when specified
#export HADOOP_SECONDARYNAMENODE_OPTS=-Xmx2048m
#export HADOOP_JOBTRACKER_OPTS="-Xmx3000m -verbose:gc -XX:+PrintGCTimeStamps -XX:+PrintGCDetails -Xloggc:/var/hadoop/logs/jobtracker1.gc.log -Dcom.sun.management.jmxremote.port=8997 -Dcom.sun.management.jmxremote.authenticate=false -Dcom.sun.management.jmxremote.ssl=false"
#export HADOOP_NAMENODE_OPTS="-Xmx2048m -verbose:gc -XX:+PrintGCTimeStamps -XX:+PrintGCDetails -Xloggc:/var/hadoop/logs/namenode.gc.log -Dcom.sun.management.jmxremote.port=8998 -Dcom.sun.management.jmxremote.authenticate=false -Dcom.sun.management.jmxremote.ssl=false"
# export HADOOP_TASKTRACKER_OPTS=
# The following applies to multiple commands (fs, dfs, fsck, distcp etc)
# export HADOOP_CLIENT_OPTS

# Extra ssh options.  Empty by default.
# export HADOOP_SSH_OPTS="-o ConnectTimeout=1 -o SendEnv=HADOOP_CONF_DIR"
export HADOOP_SSH_OPTS="-o ConnectTimeout=1"
# Where log files are stored.  $HADOOP_HOME/logs by default.
# export HADOOP_LOG_DIR=${HADOOP_HOME}/logs
export HADOOP_LOG_DIR=/var/hadoop.benchmark/logs

# File naming remote slave hosts.  $HADOOP_HOME/conf/slaves by default.
# export HADOOP_SLAVES=${HADOOP_HOME}/conf/slaves

# host:path where hadoop code should be rsync'd from.  Unset by default.
# export HADOOP_MASTER=master:/home/$USER/src/hadoop

# Seconds to sleep between slave commands.  Unset by default.  This
# can be useful in large clusters, where, e.g., slave rsyncs can
# otherwise arrive faster than the master can service them.
# export HADOOP_SLAVE_SLEEP=0.1

# The directory where pid files are stored. /tmp by default.
# export HADOOP_PID_DIR=/var/hadoop/pids
export HADOOP_PID_DIR=/var/hadoop.benchmark/pids

# A string representing this instance of hadoop. $USER by default.
# export HADOOP_IDENT_STRING=$USER

# The scheduling priority for daemon processes.  See 'man nice'.
# export HADOOP_NICENESS=10


text:
package org.supercsv.ext.spring;

import java.lang.annotation.Annotation;

import org.springframework.beans.factory.annotation.Autowired;
import org.supercsv.cellprocessor.ift.CellProcessor;
import org.supercsv.ext.builder.StringCellProcessorBuilder;

/**
 *
 *
 * @author T.TSUCHIE
 *
 */
public class UserIdCellProcessorBuilder extends StringCellProcessorBuilder {

    @Autowired
    private UserService userService;

    @Override
    public CellProcessor buildOutputCellProcessor(final Class<String> type, final  Annotation[] annos,
            final CellProcessor processor, final boolean ignoreValidationProcessor) {

        CellProcessor cellProcessor = super.buildOutputCellProcessor(type, annos, processor, ignoreValidationProcessor);
        return cellProcessor;
    }

    @Override
    public CellProcessor buildInputCellProcessor(final Class<String> type, final Annotation[] annos,
            final CellProcessor processor) {

        CellProcessor cellProcessor = processor;
        if(cellProcessor == null) {
            cellProcessor = new UserIdExist(userService);
        } else {
            cellProcessor = new UserIdExist(userService, cellProcessor);
        }

        cellProcessor = super.buildInputCellProcessor(type, annos, cellProcessor);

        return cellProcessor;
    }

}


text:
struct LastMouse
{
	SLONG		ButtonState,
				MouseX,
				MouseY;
	MFPoint		MousePoint;
};

extern volatile UBYTE		MouseMoved,
							LeftButton,
							MiddleButton,
							RightButton;
extern volatile SLONG		MouseX,
							MouseY;
extern volatile LastMouse	LeftMouse,
							MiddleMouse,
							RightMouse;
extern volatile MFPoint		MousePoint;

//---------------------------------------------------------------

#endif


text:
import React from 'react'

const userProptype = React.PropTypes.shape({
  id: React.PropTypes.number,
  callsign: React.PropTypes.string,
  email: React.PropTypes.string,
  admin: React.PropTypes.bool,
})

export default userProptype


text:
'use strict';

goog.provide('Blockly.Msg.bg');

goog.require('Blockly.Msg');

Blockly.Msg.ADD_COMMENT = "Добави коментар";
Blockly.Msg.AUTH = "Позволи на приложението да записва и споделя работата ти.";
Blockly.Msg.CHANGE_VALUE_TITLE = "Промени стойността:";
Blockly.Msg.CHAT = "Говори с колега, като пишеш в това поле!";
Blockly.Msg.CLEAN_UP = "Премахни блокове";
Blockly.Msg.COLLAPSE_ALL = "Скрий блокове";
Blockly.Msg.COLLAPSE_BLOCK = "Скрий блок";
Blockly.Msg.COLOUR_BLEND_COLOUR1 = "цвят 1";
Blockly.Msg.COLOUR_BLEND_COLOUR2 = "цвят 2";
Blockly.Msg.COLOUR_BLEND_HELPURL = "http://meyerweb.com/eric/tools/color-blend/";  // untranslated
Blockly.Msg.COLOUR_BLEND_RATIO = "съотношение";
Blockly.Msg.COLOUR_BLEND_TITLE = "смеси";
Blockly.Msg.COLOUR_BLEND_TOOLTIP = "Смесва два цвят в дадено съотношение (0.0 - 1.0).";
Blockly.Msg.COLOUR_PICKER_HELPURL = "https://bg.wikipedia.org/wiki/Цвят_(оптика)";
Blockly.Msg.COLOUR_PICKER_TOOLTIP = "Избери цвят от палитрата.";
Blockly.Msg.COLOUR_RANDOM_HELPURL = "http://randomcolour.com";  // untranslated
Blockly.Msg.COLOUR_RANDOM_TITLE = "случаен цвят";
Blockly.Msg.COLOUR_RANDOM_TOOLTIP = "Избери цвят на случаен принцип.";
Blockly.Msg.COLOUR_RGB_BLUE = "син";
Blockly.Msg.COLOUR_RGB_GREEN = "зелен";
Blockly.Msg.COLOUR_RGB_HELPURL = "http://www.december.com/html/spec/colorper.html";  // untranslated
Blockly.Msg.COLOUR_RGB_RED = "червен";
Blockly.Msg.COLOUR_RGB_TITLE = "оцвети с";
Blockly.Msg.COLOUR_RGB_TOOLTIP = "Създай цвят с избраните пропорции, червено, зелено и синьо. Всички стойности трябва да бъдат от 0 до 100.";
Blockly.Msg.CONTROLS_FLOW_STATEMENTS_HELPURL = "https://github.com/google/blockly/wiki/Loops#loop-termination-blocks";  // untranslated
Blockly.Msg.CONTROLS_FLOW_STATEMENTS_OPERATOR_BREAK = "прекъсни цикъла";
Blockly.Msg.CONTROLS_FLOW_STATEMENTS_OPERATOR_CONTINUE = "премини към следващата стъпка от цикъла";
Blockly.Msg.CONTROLS_FLOW_STATEMENTS_TOOLTIP_BREAK = "Прекъсни цикъла, в койте се съдержа тази команда.";
Blockly.Msg.CONTROLS_FLOW_STATEMENTS_TOOLTIP_CONTINUE = "Премини към следващата стъпка от цикъла";
Blockly.Msg.CONTROLS_FLOW_STATEMENTS_WARNING = "Предупреждение: Този блок може да се използва само в цикъл.";
Blockly.Msg.CONTROLS_FOREACH_HELPURL = "https://github.com/google/blockly/wiki/Loops#for-each";  // untranslated
Blockly.Msg.CONTROLS_FOREACH_TITLE = "за всеки елемент %1 в списъка %2";
Blockly.Msg.CONTROLS_FOREACH_TOOLTIP = "За всеки елемент в списък присвои елемента на променливата '%1' и след това изпълни командите.";
Blockly.Msg.CONTROLS_FOR_HELPURL = "https://github.com/google/blockly/wiki/Loops#count-with";  // untranslated
Blockly.Msg.CONTROLS_FOR_TITLE = "преброй чрез %1 от %2 до %3 през %4";
Blockly.Msg.CONTROLS_FOR_TOOLTIP = "Нека променлива \"%1\" премине през стойностите от началното до крайното число през зададената стъпка и изпълни избраните блокове.";
Blockly.Msg.CONTROLS_IF_ELSEIF_TOOLTIP = "Добави условие към \"ако\" блока.";
Blockly.Msg.CONTROLS_IF_ELSE_TOOLTIP = "Добави окончателено, прихващащо всичко останали случаи условие към \"ако\" блока.";
Blockly.Msg.CONTROLS_IF_HELPURL = "https://github.com/google/blockly/wiki/IfElse";  // untranslated
Blockly.Msg.CONTROLS_IF_IF_TOOLTIP = "Добави, премахни или пренареди частите, за да промениш този \"ако\" блок.";
Blockly.Msg.CONTROLS_IF_MSG_ELSE = "иначе";
Blockly.Msg.CONTROLS_IF_MSG_ELSEIF = "иначе ако";
Blockly.Msg.CONTROLS_IF_MSG_IF = "ако";
Blockly.Msg.CONTROLS_IF_TOOLTIP_1 = "Ако стойността е вярна, изпълни операциите.";
Blockly.Msg.CONTROLS_IF_TOOLTIP_2 = "Ако стойността е вярна, изпълни първия блок. Иначе, изпълни втория блок.";
Blockly.Msg.CONTROLS_IF_TOOLTIP_3 = "Ако първата стойност е вярна, изпълни първия блок. Иначе, ако втората стойност е вярна, изпълни втория блок.";
Blockly.Msg.CONTROLS_IF_TOOLTIP_4 = "Ако първата стойност е вярна, изпълни първия блок. В противен случай, ако втората стойност е вярна, изпълни втория блок. Ако нито една от стойностите не е вярна, изпълни последния блок.";
Blockly.Msg.CONTROLS_REPEAT_HELPURL = "https://bg.wikipedia.org/wiki/Цикъл_(програмиране)#For_.D1.86.D0.B8.D0.BA.D1.8A.D0.BB.D1.8A.D1.82";
Blockly.Msg.CONTROLS_REPEAT_INPUT_DO = "изпълни";
Blockly.Msg.CONTROLS_REPEAT_TITLE = "Повтори %1 пъти";
Blockly.Msg.CONTROLS_REPEAT_TOOLTIP = "Изпълнява команди няколко пъти.";
Blockly.Msg.CONTROLS_WHILEUNTIL_HELPURL = "https://github.com/google/blockly/wiki/Loops#repeat";  // untranslated
Blockly.Msg.CONTROLS_WHILEUNTIL_OPERATOR_UNTIL = "повтаряй докато";
Blockly.Msg.CONTROLS_WHILEUNTIL_OPERATOR_WHILE = "повтаряй докато е вярно, че";
Blockly.Msg.CONTROLS_WHILEUNTIL_TOOLTIP_UNTIL = "Докато стойността е лъжа, изпълнявай командите.";
Blockly.Msg.CONTROLS_WHILEUNTIL_TOOLTIP_WHILE = "Докато стойността е истина, изпълнявай командите.";
Blockly.Msg.DELETE_ALL_BLOCKS = "Изтриване на всички 1% блокове?";
Blockly.Msg.DELETE_BLOCK = "Изтрий блок";
Blockly.Msg.DELETE_X_BLOCKS = "Изтрий %1 блока";
Blockly.Msg.DISABLE_BLOCK = "Деактивирай блок";
Blockly.Msg.DUPLICATE_BLOCK = "Копирай";
Blockly.Msg.ENABLE_BLOCK = "Активирай блок";
Blockly.Msg.EXPAND_ALL = "Покажи блокове";
Blockly.Msg.EXPAND_BLOCK = "Покажи блок";
Blockly.Msg.EXTERNAL_INPUTS = "Външни входове";
Blockly.Msg.HELP = "Помощ";
Blockly.Msg.INLINE_INPUTS = "Вътрешни входове";
Blockly.Msg.LISTS_CREATE_EMPTY_HELPURL = "https://github.com/google/blockly/wiki/Lists#create-empty-list";  // untranslated
Blockly.Msg.LISTS_CREATE_EMPTY_TITLE = "създай празен списък";
Blockly.Msg.LISTS_CREATE_EMPTY_TOOLTIP = "Връща списък с дължина 0, не съдържащ данни";
Blockly.Msg.LISTS_CREATE_WITH_CONTAINER_TITLE_ADD = "списък";
Blockly.Msg.LISTS_CREATE_WITH_CONTAINER_TOOLTIP = "Добави, премахни или пренареди частите, за да промениш този списъчен блок.";
Blockly.Msg.LISTS_CREATE_WITH_HELPURL = "https://github.com/google/blockly/wiki/Lists#create-list-with";  // untranslated
Blockly.Msg.LISTS_CREATE_WITH_INPUT_WITH = "създай списък с";
Blockly.Msg.LISTS_CREATE_WITH_ITEM_TOOLTIP = "Добави елемент към текста.";
Blockly.Msg.LISTS_CREATE_WITH_TOOLTIP = "Създай списък с произволен брой елементи.";
Blockly.Msg.LISTS_GET_INDEX_FIRST = "първия";
Blockly.Msg.LISTS_GET_INDEX_FROM_END = "№ от края";
Blockly.Msg.LISTS_GET_INDEX_FROM_START = "#";  // untranslated
Blockly.Msg.LISTS_GET_INDEX_GET = "вземи";
Blockly.Msg.LISTS_GET_INDEX_GET_REMOVE = "вземи и премахни";
Blockly.Msg.LISTS_GET_INDEX_LAST = "последния";
Blockly.Msg.LISTS_GET_INDEX_RANDOM = "произволен";
Blockly.Msg.LISTS_GET_INDEX_REMOVE = "премахни";
Blockly.Msg.LISTS_GET_INDEX_TAIL = "";  // untranslated
Blockly.Msg.LISTS_GET_INDEX_TOOLTIP_GET_FIRST = "Връща първия елемент в списък.";
Blockly.Msg.LISTS_GET_INDEX_TOOLTIP_GET_FROM_END = "Връща елемента на определената позиция в списък. #1 е последният елемент.";
Blockly.Msg.LISTS_GET_INDEX_TOOLTIP_GET_FROM_START = "Връща елемента на определената позиция в списък. #1 е първият елемент.";
Blockly.Msg.LISTS_GET_INDEX_TOOLTIP_GET_LAST = "Връща последния елемент в списък.";
Blockly.Msg.LISTS_GET_INDEX_TOOLTIP_GET_RANDOM = "Връща случаен елемент от списъка.";
Blockly.Msg.LISTS_GET_INDEX_TOOLTIP_GET_REMOVE_FIRST = "Премахва и връща първия елемент в списък.";
Blockly.Msg.LISTS_GET_INDEX_TOOLTIP_GET_REMOVE_FROM_END = "Премахва и връща елемента на определена позиция в списък. #1 е последният елемент.";
Blockly.Msg.LISTS_GET_INDEX_TOOLTIP_GET_REMOVE_FROM_START = "Премахва и връща елемента на определена позиция в списък. #1 е последният елемент.";
Blockly.Msg.LISTS_GET_INDEX_TOOLTIP_GET_REMOVE_LAST = "Премахва и връща последния елемент в списък.";
Blockly.Msg.LISTS_GET_INDEX_TOOLTIP_GET_REMOVE_RANDOM = "Премахва и връща случаен елемент в списък.";
Blockly.Msg.LISTS_GET_INDEX_TOOLTIP_REMOVE_FIRST = "Премахва първия елемент в списък.";
Blockly.Msg.LISTS_GET_INDEX_TOOLTIP_REMOVE_FROM_END = "Премахва елемент на определена позиция в списък. #1 е последният елемент.";
Blockly.Msg.LISTS_GET_INDEX_TOOLTIP_REMOVE_FROM_START = "Премахва елемент на определена позиция в списък. #1 е първият елемент.";
Blockly.Msg.LISTS_GET_INDEX_TOOLTIP_REMOVE_LAST = "Премахва последния елемент в списък.";
Blockly.Msg.LISTS_GET_INDEX_TOOLTIP_REMOVE_RANDOM = "Премахва случаен елемент от списък.";
Blockly.Msg.LISTS_GET_SUBLIST_END_FROM_END = "до № открая";
Blockly.Msg.LISTS_GET_SUBLIST_END_FROM_START = "до #";
Blockly.Msg.LISTS_GET_SUBLIST_END_LAST = "до края";
Blockly.Msg.LISTS_GET_SUBLIST_HELPURL = "https://github.com/google/blockly/wiki/Lists#getting-a-sublist";  // untranslated
Blockly.Msg.LISTS_GET_SUBLIST_START_FIRST = "вземи подсписък от първия";
Blockly.Msg.LISTS_GET_SUBLIST_START_FROM_END = "вземи подсписък от № от края";
Blockly.Msg.LISTS_GET_SUBLIST_START_FROM_START = "вземи подсписък от №";
Blockly.Msg.LISTS_GET_SUBLIST_TAIL = "";  // untranslated
Blockly.Msg.LISTS_GET_SUBLIST_TOOLTIP = "Копира част от списък.";
Blockly.Msg.LISTS_INDEX_OF_FIRST = "намери първата поява на елемента";
Blockly.Msg.LISTS_INDEX_OF_HELPURL = "https://github.com/google/blockly/wiki/Lists#getting-items-from-a-list";  // untranslated
Blockly.Msg.LISTS_INDEX_OF_LAST = "намери последната поява на елемента";
Blockly.Msg.LISTS_INDEX_OF_TOOLTIP = "Връща индекса на първото/последното появяване на елемента в списъка. Връща 0 ако елементът не е намерен.";
Blockly.Msg.LISTS_INLIST = "в списъка";
Blockly.Msg.LISTS_ISEMPTY_HELPURL = "https://github.com/google/blockly/wiki/Lists#is-empty";  // untranslated
Blockly.Msg.LISTS_ISEMPTY_TITLE = "%1 е празен";
Blockly.Msg.LISTS_ISEMPTY_TOOLTIP = "Връща стойност вярно, ако списъкът е празен.";
Blockly.Msg.LISTS_LENGTH_HELPURL = "https://github.com/google/blockly/wiki/Lists#length-of";  // untranslated
Blockly.Msg.LISTS_LENGTH_TITLE = "дължината на %1";
Blockly.Msg.LISTS_LENGTH_TOOLTIP = "Връща дължината на списък.";
Blockly.Msg.LISTS_REPEAT_HELPURL = "https://github.com/google/blockly/wiki/Lists#create-list-with";  // untranslated
Blockly.Msg.LISTS_REPEAT_TITLE = "създай списък от %1 повторен %2 пъти";
Blockly.Msg.LISTS_REPEAT_TOOLTIP = "Създава списък, състоящ се от определен брой копия на елемента.";
Blockly.Msg.LISTS_SET_INDEX_HELPURL = "https://github.com/google/blockly/wiki/Lists#in-list--set";  // untranslated
Blockly.Msg.LISTS_SET_INDEX_INPUT_TO = "следното";
Blockly.Msg.LISTS_SET_INDEX_INSERT = "вмъкни на позиция";
Blockly.Msg.LISTS_SET_INDEX_SET = "промени";
Blockly.Msg.LISTS_SET_INDEX_TOOLTIP_INSERT_FIRST = "Вмъква елемент в началото на списъка.";
Blockly.Msg.LISTS_SET_INDEX_TOOLTIP_INSERT_FROM_END = "Вмъква елемент на определена позиция в списък. №1 е последният елемент.";
Blockly.Msg.LISTS_SET_INDEX_TOOLTIP_INSERT_FROM_START = "Вмъква елемент на определена позиция в списък. №1 е първият елемент.";
Blockly.Msg.LISTS_SET_INDEX_TOOLTIP_INSERT_LAST = "Добави елемент в края на списък.";
Blockly.Msg.LISTS_SET_INDEX_TOOLTIP_INSERT_RANDOM = "Вмъква елемент на произволно място в списък.";
Blockly.Msg.LISTS_SET_INDEX_TOOLTIP_SET_FIRST = "Променя първия елемент в списък.";
Blockly.Msg.LISTS_SET_INDEX_TOOLTIP_SET_FROM_END = "Променя елемента на определена позиция в списък. #1 е последният елемент.";
Blockly.Msg.LISTS_SET_INDEX_TOOLTIP_SET_FROM_START = "Променя елемента на определена позиция в списък. #1 е първият елемент.";
Blockly.Msg.LISTS_SET_INDEX_TOOLTIP_SET_LAST = "Променя последния елемент в списък.";
Blockly.Msg.LISTS_SET_INDEX_TOOLTIP_SET_RANDOM = "Променя случаен елемент от списък.";
Blockly.Msg.LISTS_SORT_HELPURL = "https://github.com/google/blockly/wiki/Lists#sorting-a-list";  // untranslated
Blockly.Msg.LISTS_SORT_ORDER_ASCENDING = "ascending";  // untranslated
Blockly.Msg.LISTS_SORT_ORDER_DESCENDING = "descending";  // untranslated
Blockly.Msg.LISTS_SORT_TITLE = "sort %1 %2 %3";  // untranslated
Blockly.Msg.LISTS_SORT_TOOLTIP = "Sort a copy of a list.";  // untranslated
Blockly.Msg.LISTS_SORT_TYPE_IGNORECASE = "alphabetic, ignore case";  // untranslated
Blockly.Msg.LISTS_SORT_TYPE_NUMERIC = "numeric";  // untranslated
Blockly.Msg.LISTS_SORT_TYPE_TEXT = "alphabetic";  // untranslated
Blockly.Msg.LISTS_SPLIT_HELPURL = "https://github.com/google/blockly/wiki/Lists#splitting-strings-and-joining-lists";  // untranslated
Blockly.Msg.LISTS_SPLIT_LIST_FROM_TEXT = "Направи списък от текст";
Blockly.Msg.LISTS_SPLIT_TEXT_FROM_LIST = "направи текст от списък";
Blockly.Msg.LISTS_SPLIT_TOOLTIP_JOIN = "Събира списък от текстове в един текст, раделени с разделител.";
Blockly.Msg.LISTS_SPLIT_TOOLTIP_SPLIT = "Разделя текст в списък на текстове, по всеки разделител.";
Blockly.Msg.LISTS_SPLIT_WITH_DELIMITER = "с разделител";
Blockly.Msg.LOGIC_BOOLEAN_FALSE = "невярно";
Blockly.Msg.LOGIC_BOOLEAN_HELPURL = "https://github.com/google/blockly/wiki/Logic#values";  // untranslated
Blockly.Msg.LOGIC_BOOLEAN_TOOLTIP = "Връща вярно или невярно.";
Blockly.Msg.LOGIC_BOOLEAN_TRUE = "вярно";
Blockly.Msg.LOGIC_COMPARE_HELPURL = "https://en.wikipedia.org/wiki/Inequality_(mathematics)";
Blockly.Msg.LOGIC_COMPARE_TOOLTIP_EQ = "Върни вярно, ако двата параметъра са еднакви.";
Blockly.Msg.LOGIC_COMPARE_TOOLTIP_GT = "Върни истина, ако първия параметър е по-голям от втория.";
Blockly.Msg.LOGIC_COMPARE_TOOLTIP_GTE = "Върни истина, ако първия параметър е по-голям или равен на втория.";
Blockly.Msg.LOGIC_COMPARE_TOOLTIP_LT = "Върни вярно, ако първия параметър е по-малък от втория.";
Blockly.Msg.LOGIC_COMPARE_TOOLTIP_LTE = "Върни истина, ако първия параметър е по-малък или равен на втория.";
Blockly.Msg.LOGIC_COMPARE_TOOLTIP_NEQ = "Върни вярно, ако двата параметъра са различни.";
Blockly.Msg.LOGIC_NEGATE_HELPURL = "https://github.com/google/blockly/wiki/Logic#not";  // untranslated
Blockly.Msg.LOGIC_NEGATE_TITLE = "не %1";
Blockly.Msg.LOGIC_NEGATE_TOOLTIP = "Върни вярно, ако параметърът е неверен. Върни невярно, ако параметърът е верен.";
Blockly.Msg.LOGIC_NULL = "нула";
Blockly.Msg.LOGIC_NULL_HELPURL = "https://en.wikipedia.org/wiki/Nullable_type";  // untranslated
Blockly.Msg.LOGIC_NULL_TOOLTIP = "Връща нула.";
Blockly.Msg.LOGIC_OPERATION_AND = "и";
Blockly.Msg.LOGIC_OPERATION_HELPURL = "https://github.com/google/blockly/wiki/Logic#logical-operations";  // untranslated
Blockly.Msg.LOGIC_OPERATION_OR = "или";
Blockly.Msg.LOGIC_OPERATION_TOOLTIP_AND = "Върни вярно, ако и двата параметъра са верни.";
Blockly.Msg.LOGIC_OPERATION_TOOLTIP_OR = "Върни \"вярно\", ако поне един от входовете е верен.";
Blockly.Msg.LOGIC_TERNARY_CONDITION = "тест";
Blockly.Msg.LOGIC_TERNARY_HELPURL = "https://en.wikipedia.org/wiki/%3F:";  // untranslated
Blockly.Msg.LOGIC_TERNARY_IF_FALSE = "Ако е невярно";
Blockly.Msg.LOGIC_TERNARY_IF_TRUE = "Ако е вярно";
Blockly.Msg.LOGIC_TERNARY_TOOLTIP = "Провери исловието в \"тест\". Ако условието е истина, върни  \"ако е истина\" стойността, иначе върни \"ако е лъжа\" стойността.";
Blockly.Msg.MATH_ADDITION_SYMBOL = "+";  // untranslated
Blockly.Msg.MATH_ARITHMETIC_HELPURL = "https://bg.wikipedia.org/wiki/Аритметика";
Blockly.Msg.MATH_ARITHMETIC_TOOLTIP_ADD = "Върни сумата на двете числа.";
Blockly.Msg.MATH_ARITHMETIC_TOOLTIP_DIVIDE = "Върни частното на двете числа.";
Blockly.Msg.MATH_ARITHMETIC_TOOLTIP_MINUS = "Върни разликата на двете числа.";
Blockly.Msg.MATH_ARITHMETIC_TOOLTIP_MULTIPLY = "Върни произведението на двете числа.";
Blockly.Msg.MATH_ARITHMETIC_TOOLTIP_POWER = "Върни първото число, повдигнато на степен на второто число.";
Blockly.Msg.MATH_CHANGE_HELPURL = "https://bg.wikipedia.org/wiki/Събиране";
Blockly.Msg.MATH_CHANGE_TITLE = "промени %1 на %2";
Blockly.Msg.MATH_CHANGE_TOOLTIP = "Добави число към променлива '%1'.";
Blockly.Msg.MATH_CONSTANT_HELPURL = "http://bg.wikipedia.org/wiki/Константа";
Blockly.Msg.MATH_CONSTANT_TOOLTIP = "Връща една от често срещаните константи: π (3.141...), e (2.718...), φ (1.618...), sqrt(2) (1.414...), sqrt(½) (0.707...) или ∞ (безкрайност).";
Blockly.Msg.MATH_CONSTRAIN_HELPURL = "https://en.wikipedia.org/wiki/Clamping_%28graphics%29";  // untranslated
Blockly.Msg.MATH_CONSTRAIN_TITLE = "ограничи %1 между %2 и %3";
Blockly.Msg.MATH_CONSTRAIN_TOOLTIP = "Ограничи число да бъде в определените граници (включително).";
Blockly.Msg.MATH_DIVISION_SYMBOL = "÷";  // untranslated
Blockly.Msg.MATH_IS_DIVISIBLE_BY = "се дели на";
Blockly.Msg.MATH_IS_EVEN = "е четно";
Blockly.Msg.MATH_IS_NEGATIVE = "е отрицателно";
Blockly.Msg.MATH_IS_ODD = "е нечетно";
Blockly.Msg.MATH_IS_POSITIVE = "е положително";
Blockly.Msg.MATH_IS_PRIME = "е просто";
Blockly.Msg.MATH_IS_TOOLTIP = "Проверете дали дадено число е четно, нечетно, просто, цяло, положително, отрицателно или дали се дели на друго число. Връща истина или лъжа.";
Blockly.Msg.MATH_IS_WHOLE = "е цяло";
Blockly.Msg.MATH_MODULO_HELPURL = "http://bg.wikipedia.org/wiki/Остатък";
Blockly.Msg.MATH_MODULO_TITLE = "остатъка от делението на %1 на %2";
Blockly.Msg.MATH_MODULO_TOOLTIP = "Върни остатъка от деление на две числа.";
Blockly.Msg.MATH_MULTIPLICATION_SYMBOL = "×";  // untranslated
Blockly.Msg.MATH_NUMBER_HELPURL = "https://bg.wikipedia.org/wiki/Число";
Blockly.Msg.MATH_NUMBER_TOOLTIP = "Число.";
Blockly.Msg.MATH_ONLIST_HELPURL = "";  // untranslated
Blockly.Msg.MATH_ONLIST_OPERATOR_AVERAGE = "средната стойност на числата в списъка";
Blockly.Msg.MATH_ONLIST_OPERATOR_MAX = "най-голямата стойност в списъка";
Blockly.Msg.MATH_ONLIST_OPERATOR_MEDIAN = "медианата на списък";
Blockly.Msg.MATH_ONLIST_OPERATOR_MIN = "най-малката стойност в списъка";
Blockly.Msg.MATH_ONLIST_OPERATOR_MODE = "мода на списъка";
Blockly.Msg.MATH_ONLIST_OPERATOR_RANDOM = "случаен елемент от списъка";
Blockly.Msg.MATH_ONLIST_OPERATOR_STD_DEV = "стандартно отклонение на списък";
Blockly.Msg.MATH_ONLIST_OPERATOR_SUM = "сумирай списъка";
Blockly.Msg.MATH_ONLIST_TOOLTIP_AVERAGE = "Върни средната стойност (аритметичното средно) на числата в списъка.";
Blockly.Msg.MATH_ONLIST_TOOLTIP_MAX = "Върни най-голямото число в списъка.";
Blockly.Msg.MATH_ONLIST_TOOLTIP_MEDIAN = "Върни медианата в списъка.";
Blockly.Msg.MATH_ONLIST_TOOLTIP_MIN = "Върни най-малкото число в списъка.";
Blockly.Msg.MATH_ONLIST_TOOLTIP_MODE = "Върни списък на най-често срещаните елементи в списъка.";
Blockly.Msg.MATH_ONLIST_TOOLTIP_RANDOM = "Върни случаен елемент от списъка.";
Blockly.Msg.MATH_ONLIST_TOOLTIP_STD_DEV = "Връща стандартното отклонение на списъка.";
Blockly.Msg.MATH_ONLIST_TOOLTIP_SUM = "Върни сумата на всички числа в списъка.";
Blockly.Msg.MATH_POWER_SYMBOL = "^";  // untranslated
Blockly.Msg.MATH_RANDOM_FLOAT_HELPURL = "https://bg.wikipedia.org/wiki/Генератор_на_случайни_числа";
Blockly.Msg.MATH_RANDOM_FLOAT_TITLE_RANDOM = "случайно дробно число";
Blockly.Msg.MATH_RANDOM_FLOAT_TOOLTIP = "Върни случайно дробно число между 0.0 (включително) и 1.0 (без да го включва)";
Blockly.Msg.MATH_RANDOM_INT_HELPURL = "https://bg.wikipedia.org/wiki/Генератор_на_случайни_числа";
Blockly.Msg.MATH_RANDOM_INT_TITLE = "случайно цяло число между %1 и %2";
Blockly.Msg.MATH_RANDOM_INT_TOOLTIP = "Върни случайно число в определените граници (включително).";
Blockly.Msg.MATH_ROUND_HELPURL = "https://en.wikipedia.org/wiki/Rounding";
Blockly.Msg.MATH_ROUND_OPERATOR_ROUND = "закръгли";
Blockly.Msg.MATH_ROUND_OPERATOR_ROUNDDOWN = "закръгли надолу";
Blockly.Msg.MATH_ROUND_OPERATOR_ROUNDUP = "закръгли нагоре";
Blockly.Msg.MATH_ROUND_TOOLTIP = "Закръгли число нагоре или надолу.";
Blockly.Msg.MATH_SINGLE_HELPURL = "https://en.wikipedia.org/wiki/Square_root";
Blockly.Msg.MATH_SINGLE_OP_ABSOLUTE = "абсолютна";
Blockly.Msg.MATH_SINGLE_OP_ROOT = "корен квадратен";
Blockly.Msg.MATH_SINGLE_TOOLTIP_ABS = "Връща абсолютната стойност на число.";
Blockly.Msg.MATH_SINGLE_TOOLTIP_EXP = "Върни е (неперовото число) на степен зададеното число.";
Blockly.Msg.MATH_SINGLE_TOOLTIP_LN = "Върни натуралния логаритъм от число.";
Blockly.Msg.MATH_SINGLE_TOOLTIP_LOG10 = "Върни десетичния логаритъм на число.";
Blockly.Msg.MATH_SINGLE_TOOLTIP_NEG = "Върни числото с обърнат знак.";
Blockly.Msg.MATH_SINGLE_TOOLTIP_POW10 = "Върни 10 на степен зададеното число.";
Blockly.Msg.MATH_SINGLE_TOOLTIP_ROOT = "Връща корен квадратен от число.";
Blockly.Msg.MATH_SUBTRACTION_SYMBOL = "-";  // untranslated
Blockly.Msg.MATH_TRIG_ACOS = "acos";  // untranslated
Blockly.Msg.MATH_TRIG_ASIN = "asin";  // untranslated
Blockly.Msg.MATH_TRIG_ATAN = "atan";  // untranslated
Blockly.Msg.MATH_TRIG_COS = "cos";  // untranslated
Blockly.Msg.MATH_TRIG_HELPURL = "https://bg.wikipedia.org/wiki/Тригонометрична_функция";
Blockly.Msg.MATH_TRIG_SIN = "sin";  // untranslated
Blockly.Msg.MATH_TRIG_TAN = "tan";  // untranslated
Blockly.Msg.MATH_TRIG_TOOLTIP_ACOS = "Върни аркускосинус от число.";
Blockly.Msg.MATH_TRIG_TOOLTIP_ASIN = "Върни аркуссинус от число.";
Blockly.Msg.MATH_TRIG_TOOLTIP_ATAN = "Върни аркустангенс от число.";
Blockly.Msg.MATH_TRIG_TOOLTIP_COS = "Върни косинус от ъгъл в градуси (не в радиани)";
Blockly.Msg.MATH_TRIG_TOOLTIP_SIN = "Върни синус от ъгъл в градуси (не в радиани)";
Blockly.Msg.MATH_TRIG_TOOLTIP_TAN = "Върни тангенс от ъгъл в градуси (не в радиани)";
Blockly.Msg.ME = "Аз";
Blockly.Msg.NEW_VARIABLE = "Нова променлива...";
Blockly.Msg.NEW_VARIABLE_TITLE = "Ново име на променливата:";
Blockly.Msg.ORDINAL_NUMBER_SUFFIX = "";  // untranslated
Blockly.Msg.PROCEDURES_ALLOW_STATEMENTS = "позволи операциите";
Blockly.Msg.PROCEDURES_BEFORE_PARAMS = "със:";
Blockly.Msg.PROCEDURES_CALLNORETURN_HELPURL = "https://bg.wikipedia.org/wiki/Подпрограма";
Blockly.Msg.PROCEDURES_CALLNORETURN_TOOLTIP = "Изпълни дефинирана от потребителя функция \"%1\".";
Blockly.Msg.PROCEDURES_CALLRETURN_HELPURL = "https://bg.wikipedia.org/wiki/Подпрограма";
Blockly.Msg.PROCEDURES_CALLRETURN_TOOLTIP = "Изпълни дефинирана от потребителя функция \"%1\" и използвай резултата.";
Blockly.Msg.PROCEDURES_CALL_BEFORE_PARAMS = "със:";
Blockly.Msg.PROCEDURES_CREATE_DO = "Създай '%1'";
Blockly.Msg.PROCEDURES_DEFNORETURN_COMMENT = "Опишете тази функция...";
Blockly.Msg.PROCEDURES_DEFNORETURN_DO = "";  // untranslated
Blockly.Msg.PROCEDURES_DEFNORETURN_HELPURL = "https://en.wikipedia.org/wiki/Procedure_%28computer_science%29";  // untranslated
Blockly.Msg.PROCEDURES_DEFNORETURN_PROCEDURE = "направиш";
Blockly.Msg.PROCEDURES_DEFNORETURN_TITLE = "за да";
Blockly.Msg.PROCEDURES_DEFNORETURN_TOOLTIP = "Създава функция, която не връща резултат.";
Blockly.Msg.PROCEDURES_DEFRETURN_HELPURL = "https://en.wikipedia.org/wiki/Procedure_%28computer_science%29";  // untranslated
Blockly.Msg.PROCEDURES_DEFRETURN_RETURN = "върни";
Blockly.Msg.PROCEDURES_DEFRETURN_TOOLTIP = "Създава функция, която връща резултат.";
Blockly.Msg.PROCEDURES_DEF_DUPLICATE_WARNING = "Предупреждение: Тази функция има дублиращи се параметри.";
Blockly.Msg.PROCEDURES_HIGHLIGHT_DEF = "Покажи дефиницията на функцията";
Blockly.Msg.PROCEDURES_IFRETURN_HELPURL = "http://c2.com/cgi/wiki?GuardClause";
Blockly.Msg.PROCEDURES_IFRETURN_TOOLTIP = "Ако стойността е истина, върни втората стойност.";
Blockly.Msg.PROCEDURES_IFRETURN_WARNING = "Предупреждение: Този блок може да се използва само във функция.";
Blockly.Msg.PROCEDURES_MUTATORARG_TITLE = "име на параметър";
Blockly.Msg.PROCEDURES_MUTATORARG_TOOLTIP = "Добавяне на параметър към функцията.";
Blockly.Msg.PROCEDURES_MUTATORCONTAINER_TITLE = "вход";
Blockly.Msg.PROCEDURES_MUTATORCONTAINER_TOOLTIP = "Добави, премахни или пренареди входните параметри за тази функция.";
Blockly.Msg.REDO = "Redo";  // untranslated
Blockly.Msg.REMOVE_COMMENT = "Премахни коментар";
Blockly.Msg.RENAME_VARIABLE = "Преименувай променливата...";
Blockly.Msg.RENAME_VARIABLE_TITLE = "Преименувай всички '%1' променливи на:";
Blockly.Msg.TEXT_APPEND_APPENDTEXT = "добави текста";
Blockly.Msg.TEXT_APPEND_HELPURL = "https://github.com/google/blockly/wiki/Text#text-modification";  // untranslated
Blockly.Msg.TEXT_APPEND_TO = "към";
Blockly.Msg.TEXT_APPEND_TOOLTIP = "Добави текста към променливата \"%1\".";
Blockly.Msg.TEXT_CHANGECASE_HELPURL = "https://github.com/google/blockly/wiki/Text#adjusting-text-case";  // untranslated
Blockly.Msg.TEXT_CHANGECASE_OPERATOR_LOWERCASE = "с малки букви";
Blockly.Msg.TEXT_CHANGECASE_OPERATOR_TITLECASE = "с Главна Буква На Всяка Дума";
Blockly.Msg.TEXT_CHANGECASE_OPERATOR_UPPERCASE = "с ГЛАВНИ БУКВИ";
Blockly.Msg.TEXT_CHANGECASE_TOOLTIP = "Връща копие на текста със сменени малки и главни букви.";
Blockly.Msg.TEXT_CHARAT_FIRST = "вземи първата буква";
Blockly.Msg.TEXT_CHARAT_FROM_END = "вземи поредна буква от края";
Blockly.Msg.TEXT_CHARAT_FROM_START = "вземи поредна буква";
Blockly.Msg.TEXT_CHARAT_HELPURL = "https://github.com/google/blockly/wiki/Text#extracting-text";  // untranslated
Blockly.Msg.TEXT_CHARAT_INPUT_INTEXT = "от текста";
Blockly.Msg.TEXT_CHARAT_LAST = "вземи последната буква";
Blockly.Msg.TEXT_CHARAT_RANDOM = "вземи произволна буква";
Blockly.Msg.TEXT_CHARAT_TAIL = "";  // untranslated
Blockly.Msg.TEXT_CHARAT_TOOLTIP = "Връща буквата в определена позиция.";
Blockly.Msg.TEXT_CREATE_JOIN_ITEM_TOOLTIP = "Добави елемент към текста.";
Blockly.Msg.TEXT_CREATE_JOIN_TITLE_JOIN = "свържи";
Blockly.Msg.TEXT_CREATE_JOIN_TOOLTIP = "Добави, премахни или пренареди частите, за да промениш този текстов блок.";
Blockly.Msg.TEXT_GET_SUBSTRING_END_FROM_END = "со буква № (броено отзад-напред)";
Blockly.Msg.TEXT_GET_SUBSTRING_END_FROM_START = "до буква №";
Blockly.Msg.TEXT_GET_SUBSTRING_END_LAST = "со последната буква.";
Blockly.Msg.TEXT_GET_SUBSTRING_HELPURL = "https://github.com/google/blockly/wiki/Text#extracting-a-region-of-text";  // untranslated
Blockly.Msg.TEXT_GET_SUBSTRING_INPUT_IN_TEXT = "В текста";
Blockly.Msg.TEXT_GET_SUBSTRING_START_FIRST = "вземи текста от първата буква";
Blockly.Msg.TEXT_GET_SUBSTRING_START_FROM_END = "вземи текста от буква № (броено отзад-напред)";
Blockly.Msg.TEXT_GET_SUBSTRING_START_FROM_START = "вземи текста от буква №";
Blockly.Msg.TEXT_GET_SUBSTRING_TAIL = "";  // untranslated
Blockly.Msg.TEXT_GET_SUBSTRING_TOOLTIP = "Връща определена част от текста.";
Blockly.Msg.TEXT_INDEXOF_HELPURL = "https://github.com/google/blockly/wiki/Text#finding-text";  // untranslated
Blockly.Msg.TEXT_INDEXOF_INPUT_INTEXT = "в текста";
Blockly.Msg.TEXT_INDEXOF_OPERATOR_FIRST = "намери първата поява на текста";
Blockly.Msg.TEXT_INDEXOF_OPERATOR_LAST = "намери последната поява на текста";
Blockly.Msg.TEXT_INDEXOF_TAIL = "";  // untranslated
Blockly.Msg.TEXT_INDEXOF_TOOLTIP = "Връща индекса на първото/последното срещане на първия текст във втория текст. Връща 0, ако текстът не е намерен.";
Blockly.Msg.TEXT_ISEMPTY_HELPURL = "https://github.com/google/blockly/wiki/Text#checking-for-empty-text";  // untranslated
Blockly.Msg.TEXT_ISEMPTY_TITLE = "%1 е празен";
Blockly.Msg.TEXT_ISEMPTY_TOOLTIP = "Връща истина, ако текста е празен.";
Blockly.Msg.TEXT_JOIN_HELPURL = "https://github.com/google/blockly/wiki/Text#text-creation";  // untranslated
Blockly.Msg.TEXT_JOIN_TITLE_CREATEWITH = "създай текст с";
Blockly.Msg.TEXT_JOIN_TOOLTIP = "Създай текст като съчетаеш няколко елемента.";
Blockly.Msg.TEXT_LENGTH_HELPURL = "https://github.com/google/blockly/wiki/Text#text-modification";  // untranslated
Blockly.Msg.TEXT_LENGTH_TITLE = "дължината на %1";
Blockly.Msg.TEXT_LENGTH_TOOLTIP = "Връща броя на символите (включително и интервалите) в текста.";
Blockly.Msg.TEXT_PRINT_HELPURL = "https://github.com/google/blockly/wiki/Text#printing-text";  // untranslated
Blockly.Msg.TEXT_PRINT_TITLE = "отпечатай %1";
Blockly.Msg.TEXT_PRINT_TOOLTIP = "Отпечатай текста, числото или друга стойност.";
Blockly.Msg.TEXT_PROMPT_HELPURL = "https://github.com/google/blockly/wiki/Text#getting-input-from-the-user";  // untranslated
Blockly.Msg.TEXT_PROMPT_TOOLTIP_NUMBER = "Питай потребителя за число.";
Blockly.Msg.TEXT_PROMPT_TOOLTIP_TEXT = "Питай потребителя за текст.";
Blockly.Msg.TEXT_PROMPT_TYPE_NUMBER = "питай за число със съобщение";
Blockly.Msg.TEXT_PROMPT_TYPE_TEXT = "питай за текст със съобщение";
Blockly.Msg.TEXT_TEXT_HELPURL = "https://bg.wikipedia.org/wiki/Низ";
Blockly.Msg.TEXT_TEXT_TOOLTIP = "Буква, дума или ред";
Blockly.Msg.TEXT_TRIM_HELPURL = "https://github.com/google/blockly/wiki/Text#trimming-removing-spaces";  // untranslated
Blockly.Msg.TEXT_TRIM_OPERATOR_BOTH = "премахни интервалите от двете страни";
Blockly.Msg.TEXT_TRIM_OPERATOR_LEFT = "премахни интервалите отляво";
Blockly.Msg.TEXT_TRIM_OPERATOR_RIGHT = "премахни интервалите отдясно";
Blockly.Msg.TEXT_TRIM_TOOLTIP = "Върни копие на текста с пемахнати интервали от диния или двата края.";
Blockly.Msg.TODAY = "Днес";
Blockly.Msg.TYPE_WARN01 = "The variable '";  // untranslated
Blockly.Msg.TYPE_WARN02 = "' has been first assigned to the '";  // untranslated
Blockly.Msg.TYPE_WARN03 = "' type and this block tries to assign the type '";  // untranslated
Blockly.Msg.TYPE_WARN04 = "'!";  // untranslated
Blockly.Msg.UNDO = "Undo";  // untranslated
Blockly.Msg.VARIABLES_DEFAULT_NAME = "елемент";
Blockly.Msg.VARIABLES_GET_CREATE_SET = "Създай \"промени стойността на %1\"";
Blockly.Msg.VARIABLES_GET_HELPURL = "https://github.com/google/blockly/wiki/Variables#get";  // untranslated
Blockly.Msg.VARIABLES_GET_TOOLTIP = "Връща стойността на тази променлива.";
Blockly.Msg.VARIABLES_SET = "нека %1 бъде %2";
Blockly.Msg.VARIABLES_SET_CREATE_GET = "Създай \"вземи стойността на %1\"";
Blockly.Msg.VARIABLES_SET_HELPURL = "https://github.com/google/blockly/wiki/Variables#set";  // untranslated
Blockly.Msg.VARIABLES_SET_TOOLTIP = "Задава тази променлива да бъде равен на входа.";
Blockly.Msg.PROCEDURES_DEFRETURN_TITLE = Blockly.Msg.PROCEDURES_DEFNORETURN_TITLE;
Blockly.Msg.CONTROLS_IF_IF_TITLE_IF = Blockly.Msg.CONTROLS_IF_MSG_IF;
Blockly.Msg.CONTROLS_WHILEUNTIL_INPUT_DO = Blockly.Msg.CONTROLS_REPEAT_INPUT_DO;
Blockly.Msg.CONTROLS_IF_MSG_THEN = Blockly.Msg.CONTROLS_REPEAT_INPUT_DO;
Blockly.Msg.CONTROLS_IF_ELSE_TITLE_ELSE = Blockly.Msg.CONTROLS_IF_MSG_ELSE;
Blockly.Msg.PROCEDURES_DEFRETURN_PROCEDURE = Blockly.Msg.PROCEDURES_DEFNORETURN_PROCEDURE;
Blockly.Msg.LISTS_GET_SUBLIST_INPUT_IN_LIST = Blockly.Msg.LISTS_INLIST;
Blockly.Msg.LISTS_GET_INDEX_INPUT_IN_LIST = Blockly.Msg.LISTS_INLIST;
Blockly.Msg.MATH_CHANGE_TITLE_ITEM = Blockly.Msg.VARIABLES_DEFAULT_NAME;
Blockly.Msg.PROCEDURES_DEFRETURN_DO = Blockly.Msg.PROCEDURES_DEFNORETURN_DO;
Blockly.Msg.CONTROLS_IF_ELSEIF_TITLE_ELSEIF = Blockly.Msg.CONTROLS_IF_MSG_ELSEIF;
Blockly.Msg.LISTS_GET_INDEX_HELPURL = Blockly.Msg.LISTS_INDEX_OF_HELPURL;
Blockly.Msg.CONTROLS_FOREACH_INPUT_DO = Blockly.Msg.CONTROLS_REPEAT_INPUT_DO;
Blockly.Msg.LISTS_SET_INDEX_INPUT_IN_LIST = Blockly.Msg.LISTS_INLIST;
Blockly.Msg.CONTROLS_FOR_INPUT_DO = Blockly.Msg.CONTROLS_REPEAT_INPUT_DO;
Blockly.Msg.LISTS_CREATE_WITH_ITEM_TITLE = Blockly.Msg.VARIABLES_DEFAULT_NAME;
Blockly.Msg.TEXT_APPEND_VARIABLE = Blockly.Msg.VARIABLES_DEFAULT_NAME;
Blockly.Msg.TEXT_CREATE_JOIN_ITEM_TITLE_ITEM = Blockly.Msg.VARIABLES_DEFAULT_NAME;
Blockly.Msg.LISTS_INDEX_OF_INPUT_IN_LIST = Blockly.Msg.LISTS_INLIST;
Blockly.Msg.PROCEDURES_DEFRETURN_COMMENT = Blockly.Msg.PROCEDURES_DEFNORETURN_COMMENT;

// Ardublockly strings
Blockly.Msg.ARD_180SERVO = "0~180 degree Servo (angle)";  // untranslated
Blockly.Msg.ARD_360SERVO = "0~360 degree Servo (rotation)";  // untranslated
Blockly.Msg.ARD_7SEGMENT_COMPONENT = "7-Segment Display";  // untranslated
Blockly.Msg.ARD_7SEGMENT_COMPONENT_TIP = "7-Segment LED Display can be used to show numbers and some characters. It has 7 segments and 1 dot, requiring 8 digital pins on the Arduino to use.";  // untranslated
Blockly.Msg.ARD_7SEGMENT_COMPONENT_WARN = "Pin used in segment %1 is also present in one of the other segments! Change the pin number.";  // untranslated
Blockly.Msg.ARD_7SEGMENT_WRITE = "show number";  // untranslated
Blockly.Msg.ARD_7SEGMENT_WRITESEG = "Set segment";  // untranslated
Blockly.Msg.ARD_7SEGMENT_WRITESEG_TIP = "Set a specific segment of the 7-Segment display high";  // untranslated
Blockly.Msg.ARD_7SEGMENT_WRITE_TIP = "Write a specific number to the 7-segment display. Number must be between 0 and 9, otherwise nothing is shown.";  // untranslated
Blockly.Msg.ARD_ALLBOTSERVO_ANIMATE = "Move AllBot Servo ";  // untranslated
Blockly.Msg.ARD_ALLBOTSERVO_ANIMATE_TIP = "Move Servo to a specified angle gradually over the animation duration. You can combine this with other servo movements";  // untranslated
Blockly.Msg.ARD_ALLBOTSERVO_WRITE = "Set AllBot Servo ";  // untranslated
Blockly.Msg.ARD_ALLBOT_ANIMATE = "Animate AllBot";  // untranslated
Blockly.Msg.ARD_ALLBOT_ANIMATESERVOS = "Servos";  // untranslated
Blockly.Msg.ARD_ALLBOT_ANIMATESPEED = "Animation duration (ms):";  // untranslated
Blockly.Msg.ARD_ALLBOT_ANIMATE_TIP = "Animate the allbot by moving different servos at the same time. Total duration of this animation can be set. A servo may have only one movement block present.";  // untranslated
Blockly.Msg.ARD_ALLBOT_ANKLEFRONTLEFT = "ankleFrontLeft";  // untranslated
Blockly.Msg.ARD_ALLBOT_ANKLEFRONTRIGHT = "ankleFrontRight";  // untranslated
Blockly.Msg.ARD_ALLBOT_ANKLELEFT = "ankleLeft";  // untranslated
Blockly.Msg.ARD_ALLBOT_ANKLEMIDDLELEFT = "ankleMiddleLeft";  // untranslated
Blockly.Msg.ARD_ALLBOT_ANKLEMIDDLERIGHT = "ankleMiddleRight";  // untranslated
Blockly.Msg.ARD_ALLBOT_ANKLEREARLEFT = "ankleRearLeft";  // untranslated
Blockly.Msg.ARD_ALLBOT_ANKLEREARRIGHT = "ankleRearRight";  // untranslated
Blockly.Msg.ARD_ALLBOT_ANKLERIGHT = "ankleRight";  // untranslated
Blockly.Msg.ARD_ALLBOT_BACKWARD = "AllBot Backward:";  // untranslated
Blockly.Msg.ARD_ALLBOT_CHIRP = "AllBot Chirp:";  // untranslated
Blockly.Msg.ARD_ALLBOT_CHIRPSPEED = "beeps, beepspeed";  // untranslated
Blockly.Msg.ARD_ALLBOT_CHIRP_TIP = "Make the allbot chirp a number of beeps at the given speed (delay in microseconds, use 1 to 255)";  // untranslated
Blockly.Msg.ARD_ALLBOT_FORWARD = "AllBot Forward:";  // untranslated
Blockly.Msg.ARD_ALLBOT_HIPFRONTLEFT = "hipFrontLeft";  // untranslated
Blockly.Msg.ARD_ALLBOT_HIPFRONTRIGHT = "hipFrontRight";  // untranslated
Blockly.Msg.ARD_ALLBOT_HIPLEFT = "hipLeft";  // untranslated
Blockly.Msg.ARD_ALLBOT_HIPMIDDLELEFT = "hipMiddleLeft";  // untranslated
Blockly.Msg.ARD_ALLBOT_HIPMIDDLERIGHT = "hipMiddleRight";  // untranslated
Blockly.Msg.ARD_ALLBOT_HIPREARLEFT = "hipRearLeft";  // untranslated
Blockly.Msg.ARD_ALLBOT_HIPREARRIGHT = "hipRearRight";  // untranslated
Blockly.Msg.ARD_ALLBOT_HIPRIGHT = "hipRight";  // untranslated
Blockly.Msg.ARD_ALLBOT_KNEEFRONTLEFT = "kneeFrontLeft";  // untranslated
Blockly.Msg.ARD_ALLBOT_KNEEFRONTRIGHT = "kneeFrontRight";  // untranslated
Blockly.Msg.ARD_ALLBOT_KNEEMIDDLELEFT = "kneeMiddleLeft";  // untranslated
Blockly.Msg.ARD_ALLBOT_KNEEMIDDLERIGHT = "kneeMiddleRight";  // untranslated
Blockly.Msg.ARD_ALLBOT_KNEEREARLEFT = "kneeRearLeft";  // untranslated
Blockly.Msg.ARD_ALLBOT_KNEEREARRIGHT = "kneeRearRight";  // untranslated
Blockly.Msg.ARD_ALLBOT_LEFT = "AllBot Left:";  // untranslated
Blockly.Msg.ARD_ALLBOT_LOOKLEFT = "AllBot Look Left, speed (ms):";  // untranslated
Blockly.Msg.ARD_ALLBOT_LOOKRIGHT = "AllBot Look Right, speed (ms):";  // untranslated
Blockly.Msg.ARD_ALLBOT_LOOK_TIP = "Make the allbot look towards a specific direction with the given speed (ms)";  // untranslated
Blockly.Msg.ARD_ALLBOT_RC = "AllBot Remote Control Handling";  // untranslated
Blockly.Msg.ARD_ALLBOT_RCCOMMAND = "On receiving command ";  // untranslated
Blockly.Msg.ARD_ALLBOT_RCCOMMANDS = "Commands ";  // untranslated
Blockly.Msg.ARD_ALLBOT_RCCOMMAND_SINGLE = "This block must be inside an AllBot Remote Control block ";  // untranslated
Blockly.Msg.ARD_ALLBOT_RCCOMMAND_TIP = "Set the actions the AllBot must do on receiving a command.";  // untranslated
Blockly.Msg.ARD_ALLBOT_RCDO = "Do ";  // untranslated
Blockly.Msg.ARD_ALLBOT_RCSERIAL = "Use Serial to view Commands";  // untranslated
Blockly.Msg.ARD_ALLBOT_RC_SPEED = "RC Speed";  // untranslated
Blockly.Msg.ARD_ALLBOT_RC_SPEED_TIP = "The speed as set in the Remote Control App";  // untranslated
Blockly.Msg.ARD_ALLBOT_RC_TIMES = "RC Times";  // untranslated
Blockly.Msg.ARD_ALLBOT_RC_TIMES_TIP = "The times (number of steps) as set in the Remote Control App";  // untranslated
Blockly.Msg.ARD_ALLBOT_RC_TIP = "A block to react to the AllBot Remote Control App on your smarthphone. Check Serial to see in the serial monitor what commands are received. Note: Your AllBot shield must be switched to RECEIVE after programming it.";  // untranslated
Blockly.Msg.ARD_ALLBOT_RIGHT = "AllBot Right:";  // untranslated
Blockly.Msg.ARD_ALLBOT_SCARED = "AllBot Look Scared:";  // untranslated
Blockly.Msg.ARD_ALLBOT_SCAREDBEEPS = "shakes, beeps:";  // untranslated
Blockly.Msg.ARD_ALLBOT_SCARED_TIP = "Make the allbot shake the given number of shakes, and beep the given number of beeps ";  // untranslated
Blockly.Msg.ARD_ALLBOT_SERVOHUB = "AllBot Servo motor";  // untranslated
Blockly.Msg.ARD_ALLBOT_STEPS = "steps, stepspeed";  // untranslated
Blockly.Msg.ARD_ALLBOT_WALK_TIP = "Make the allbot move a number of steps with the given speed (ms) for one step";  // untranslated
Blockly.Msg.ARD_ANALOGREAD = "read analog pin#";  // untranslated
Blockly.Msg.ARD_ANALOGREAD_TIP = "Return value between 0 and 1024";  // untranslated
Blockly.Msg.ARD_ANALOGWRITE = "set analog pin#";  // untranslated
Blockly.Msg.ARD_ANALOGWRITE_ERROR = "The analogue value set must be between 0 and 255";  // untranslated
Blockly.Msg.ARD_ANALOGWRITE_TIP = "Write analog value between 0 and 255 to a specific PWM Port";  // untranslated
Blockly.Msg.ARD_ANASENSOR = "Analog Sensor";  // untranslated
Blockly.Msg.ARD_ANASENSOR_COMPONENT = "Analog Sensor";  // untranslated
Blockly.Msg.ARD_ANASENSOR_DEFAULT_NAME = "AnaSensor1";  // untranslated
Blockly.Msg.ARD_ANASENSOR_READ = "Read analog sensor";  // untranslated
Blockly.Msg.ARD_ANASENSOR_TIP = "Connect an analog sensor to an analog pin, so as to read its value. On an Arduino UNO a value between 0 and 1024 is returned, corresponding to a measured value between 0 and 5V. Eg.: an LDR sensor, a potmeter, ...";  // untranslated
Blockly.Msg.ARD_ARRAY_CREATE_LENGTH = "of length";  // untranslated
Blockly.Msg.ARD_ARRAY_CREATE_LENGTH_TOOLTIP = "Create an array containing the given number of elements";  // untranslated
Blockly.Msg.ARD_ARRAY_CREATE_TITLE = "array";  // untranslated
Blockly.Msg.ARD_ARRAY_CREATE_TITLE0 = "Create";  // untranslated
Blockly.Msg.ARD_ARRAY_CREATE_TITLE2 = "with values";  // untranslated
Blockly.Msg.ARD_ARRAY_CREATE_WITH_CONTAINER_TITLE_ADD = "array";  // untranslated
Blockly.Msg.ARD_ARRAY_CREATE_WITH_CONTAINER_TOOLTIP = "Add, remove, or reorder sections to reconfigure this array block.";  // untranslated
Blockly.Msg.ARD_ARRAY_CREATE_WITH_INPUT_WITH = "Create array with";  // untranslated
Blockly.Msg.ARD_ARRAY_CREATE_WITH_ITEM_TITLE = "item";  // untranslated
Blockly.Msg.ARD_ARRAY_CREATE_WITH_ITEM_TOOLTIP = "Add an item to the array.";  // untranslated
Blockly.Msg.ARD_ARRAY_CREATE_WITH_TOOLTIP = "Create an array with any number of items";  // untranslated
Blockly.Msg.ARD_ARRAY_DEFAULT_NAME = "Array1";  // untranslated
Blockly.Msg.ARD_ARRAY_GETINDEX_AT = "get element with index";  // untranslated
Blockly.Msg.ARD_ARRAY_GETINDEX_ITEM = "in array";  // untranslated
Blockly.Msg.ARD_ARRAY_GETINDEX_TOOLTIP = "Obtain element in the array at given index. Index must be a number from 0 to the length minus 1!";  // untranslated
Blockly.Msg.ARD_ARRAY_GETLENGTH = "Length of array";  // untranslated
Blockly.Msg.ARD_ARRAY_GETLENGTH_TOOLTIP = "Return the length (=number of elements) of the selected array";  // untranslated
Blockly.Msg.ARD_ARRAY_IND_ERR1 = "Index must be number >= 0";  // untranslated
Blockly.Msg.ARD_ARRAY_IND_ERR2 = "Index must be number < length array";  // untranslated
Blockly.Msg.ARD_ARRAY_LEN_ERR1 = "Length of array must be 1 or more";  // untranslated
Blockly.Msg.ARD_ARRAY_LEN_ERR2 = "Length of array must be an integer number";  // untranslated
Blockly.Msg.ARD_ARRAY_LEN_ERR3 = "Length of array must be a number, not a variable";  // untranslated
Blockly.Msg.ARD_ARRAY_NOT_FLOAT = "One of the values is not a numeric value";  // untranslated
Blockly.Msg.ARD_ARRAY_NOT_INT = "One of the values is not an integer";  // untranslated
Blockly.Msg.ARD_ARRAY_NOT_KNOWN = "Unknown type of array given";  // untranslated
Blockly.Msg.ARD_ARRAY_NOT_NUMBER = "Only assign numbers, not variables when defining an array!";  // untranslated
Blockly.Msg.ARD_ARRAY_SETINDEX_AT = "the element with index";  // untranslated
Blockly.Msg.ARD_ARRAY_SETINDEX_ITEM = "Set in array";  // untranslated
Blockly.Msg.ARD_ARRAY_SETINDEX_TOOLTIP = "Set an element in the array at given index equal to the given value. Index must be a number from 0 to the length minus 1!";  // untranslated
Blockly.Msg.ARD_ARRAY_SETINDEX_VALUE = "to the value";  // untranslated
Blockly.Msg.ARD_AS_ANAINPUT_PIN = "as analog input";  // untranslated
Blockly.Msg.ARD_AS_ANAINPUT_PIN_TIP = "Declare a variable as a analog input pin";  // untranslated
Blockly.Msg.ARD_AS_ANAOUTPUT_PIN = "as analg output";  // untranslated
Blockly.Msg.ARD_AS_ANAOUTPUT_PIN_TIP = "Declare a variable as a analog PWM output pin";  // untranslated
Blockly.Msg.ARD_AS_BOOL_NUMBER = "as boolean";  // untranslated
Blockly.Msg.ARD_AS_BOOL_NUMBER_TIP = "Declare a variable as boolean with value true or false";  // untranslated
Blockly.Msg.ARD_AS_DIGINPUT_PIN = "as digital input";  // untranslated
Blockly.Msg.ARD_AS_DIGINPUT_PIN_TIP = "Declare a variable as a digital input pin";  // untranslated
Blockly.Msg.ARD_AS_DIGOUTPUT_PIN = "as digital output";  // untranslated
Blockly.Msg.ARD_AS_DIGOUTPUT_PIN_TIP = "Declare a variable as a digital output pin";  // untranslated
Blockly.Msg.ARD_AS_FLOAT_NUMBER = "as decimal number";  // untranslated
Blockly.Msg.ARD_AS_FLOAT_NUMBER_TIP = "Declare a variable as a decimal number, eg 3.6 or 5e4 or -3.14";  // untranslated
Blockly.Msg.ARD_AS_INTEGER_NUMBER = "as integer number";  // untranslated
Blockly.Msg.ARD_AS_INTEGER_NUMBER_TIP = "Declare a variable as integer, -32768 to 32767";  // untranslated
Blockly.Msg.ARD_AS_LONG_NUMBER = "as long integer number";  // untranslated
Blockly.Msg.ARD_AS_LONG_NUMBER_TIP = "Declare a variable as a long integer, -2,147,483,648 to 2,147,483,647";  // untranslated
Blockly.Msg.ARD_AS_UINT_NUMBER = "as positive integer number";  // untranslated
Blockly.Msg.ARD_AS_UINT_NUMBER_TIP = "Declare a variable as a positive integer, 0 to 65535";  // untranslated
Blockly.Msg.ARD_AS_ULONG_NUMBER = "as long positive integer number";  // untranslated
Blockly.Msg.ARD_AS_ULONG_NUMBER_TIP = "Declare a variable as a long positive integer, 0 to 4,294,967,295";  // untranslated
Blockly.Msg.ARD_BLOCKS = "You have this block twice on the canvas. That is once too many!";  // untranslated
Blockly.Msg.ARD_BOARD = "Board";  // untranslated
Blockly.Msg.ARD_BOARD_WARN = "This block requires as board %1, but or a duplicate block is present or another block is present that requires another Arduino board!";  // untranslated
Blockly.Msg.ARD_BUILTIN_LED = "set built-in LED";  // untranslated
Blockly.Msg.ARD_BUILTIN_LED_TIP = "Light on or off for the built-in LED of the Arduino";  // untranslated
Blockly.Msg.ARD_BUTTON_COMPONENT = "Push Button";  // untranslated
Blockly.Msg.ARD_BUTTON_DEFAULT_NAME = "PushButton1";  // untranslated
Blockly.Msg.ARD_BUTTON_IFPUSHED = "If pushed we measure value";  // untranslated
Blockly.Msg.ARD_BUTTON_INPUT_CLICK = " is clicked";  // untranslated
Blockly.Msg.ARD_BUTTON_INPUT_IF = "If button";  // untranslated
Blockly.Msg.ARD_BUTTON_INPUT_LONGCLICK = "is undergoing a long click";  // untranslated
Blockly.Msg.ARD_BUTTON_INPUT_PRESSED = "is being pressed";  // untranslated
Blockly.Msg.ARD_BUTTON_INPUT_PULLUP_COMPONENT = "Pushbutton 2-wire no resistor";  // untranslated
Blockly.Msg.ARD_BUTTON_INPUT_PULLUP_TIP = "A push button which can be ON or OFF, connected to the Arduino with 2 wires: GND, and a digital pin";  // untranslated
Blockly.Msg.ARD_BUTTON_INPUT_THEN = "do";  // untranslated
Blockly.Msg.ARD_BUTTON_INPUT_TIP = "Check the input received on a button, and react to it. This function does not block your program if you do not check the checkbox to wait for a click. A click is a press and a release of the button, a long press a click and holding long time before you release, press is active as soon as the button is pressed down.";  // untranslated
Blockly.Msg.ARD_BUTTON_INPUT_WAIT = "wait for a click to happen";  // untranslated
Blockly.Msg.ARD_BUTTON_READ = "Read value button";  // untranslated
Blockly.Msg.ARD_BUTTON_TIP = "A push button which can be ON or OFF, connected to the Arduino with 3 wires: GND, 5V over resisotor, and a digital pin";  // untranslated
Blockly.Msg.ARD_BUZNOTONE = "No tone on buzzer";  // untranslated
Blockly.Msg.ARD_BUZNOTONE_TIP = "Stop generating a tone on the buzzer";  // untranslated
Blockly.Msg.ARD_BUZOUTPUT_COMPONENT = "Buzzer/Speaker";  // untranslated
Blockly.Msg.ARD_BUZOUTPUT_DEFAULT_NAME = "MyBuzzer1";  // untranslated
Blockly.Msg.ARD_BUZOUTPUT_TIP = "This component is a Buzzer or a Loudspeaker. You can connect it to a digital pin of the Arduino.";  // untranslated
Blockly.Msg.ARD_BUZSELECTPITCH = "Pitch";  // untranslated
Blockly.Msg.ARD_BUZSELECTPITCH_TIP = "Select the pitch you want. This block returns a number which is the frequency of the selected pitch.";  // untranslated
Blockly.Msg.ARD_BUZSETPITCH = "with pitch";  // untranslated
Blockly.Msg.ARD_BUZSETTONE = "Set tone on buzzer";  // untranslated
Blockly.Msg.ARD_BUZZEROUTPUT = "Buzzer/Speaker";  // untranslated
Blockly.Msg.ARD_COMMENT = "Comment";  // untranslated
Blockly.Msg.ARD_COMMENT_TIP = "Add the given text as comment to the Arduino code";  // untranslated
Blockly.Msg.ARD_COMPONENT_BOARD = "a specific Arduino Board";  // untranslated
Blockly.Msg.ARD_COMPONENT_BOARD_HUB_TIP = "Set the Arduino board you work with, and to what it connects";  // untranslated
Blockly.Msg.ARD_COMPONENT_BOARD_TIP = "Set which Arduino board you work with, and connect components to the pins.";  // untranslated
Blockly.Msg.ARD_COMPONENT_WARN1 = "A %1 configuration block with the same %2 name must be added to use this block!";  // untranslated
Blockly.Msg.ARD_CONTROLS_EFFECT_ELSEIF_TOOLTIP = "Add an extra effect time at which statements must be done";  // untranslated
Blockly.Msg.ARD_CONTROLS_EFFECT_ELSE_TOOLTIP = "Add a block for statements when the effect is finished.";  // untranslated
Blockly.Msg.ARD_CONTROLS_EFFECT_MSG_ELSE = "at the end do";  // untranslated
Blockly.Msg.ARD_CONTROLS_EFFECT_MSG_ELSEIF = "if effect time becomes greater than";  // untranslated
Blockly.Msg.ARD_CONTROLS_EFFECT_MSG_FIRST1 = "Effect";  // untranslated
Blockly.Msg.ARD_CONTROLS_EFFECT_MSG_FIRST2 = "with total duration (ms) =";  // untranslated
Blockly.Msg.ARD_CONTROLS_EFFECT_MSG_IF = "at the start do";  // untranslated
Blockly.Msg.ARD_CONTROLS_EFFECT_TOOLTIP_1 = "At the start of an effect, do some statements";  // untranslated
Blockly.Msg.ARD_CONTROLS_EFFECT_TOOLTIP_2 = "At the start of an effect, do some statements, and at the end of the effect too";  // untranslated
Blockly.Msg.ARD_CONTROLS_EFFECT_TOOLTIP_3 = "At the start of an effect, do some statements, if the effect time becomes larger than the given time, do the next statements.";  // untranslated
Blockly.Msg.ARD_CONTROLS_EFFECT_TOOLTIP_4 = "At the start of an effect, do some statements, if the effect time becomes larger than the given time, do the next statements. Ath end of the effect the final statements are done.";  // untranslated
Blockly.Msg.ARD_DEFINE = "Define";  // untranslated
Blockly.Msg.ARD_DHTHUB = "Temperature and humidity sensor";  // untranslated
Blockly.Msg.ARD_DHTHUB_READHEATINDEX = "Heat Index at";  // untranslated
Blockly.Msg.ARD_DHTHUB_READRH = "Relative Humidity at";  // untranslated
Blockly.Msg.ARD_DHTHUB_READTEMP = "°C temperature at";  // untranslated
Blockly.Msg.ARD_DHTHUB_TIP = "Block to assign to an Arduino pin a DHT type sensor";  // untranslated
Blockly.Msg.ARD_DHT_COMPONENT = "DHT sensor";  // untranslated
Blockly.Msg.ARD_DHT_DEFAULT_NAME = "TempRH_Sensor";  // untranslated
Blockly.Msg.ARD_DHT_READHEATINDEX_TIP = "Obtain the Heat Index ( human-perceived equivalent temperature in °C) of a DHT sensor";  // untranslated
Blockly.Msg.ARD_DHT_READRH_TIP = "Obtain the RH (Relative Humidity in %) as a value from 0 to 100 a DHT sensor";  // untranslated
Blockly.Msg.ARD_DHT_READTEMP_TIP = "Obtain the temperature in degree Celcius of a DHT sensor";  // untranslated
Blockly.Msg.ARD_DIGINPUT = "Digital input";  // untranslated
Blockly.Msg.ARD_DIGINPUT_COMPONENT = "Digital Input";  // untranslated
Blockly.Msg.ARD_DIGINPUT_DEFAULT_NAME = "DigInput1";  // untranslated
Blockly.Msg.ARD_DIGINPUT_READ = "Read digital input";  // untranslated
Blockly.Msg.ARD_DIGINPUT_TIP = "Connect a digital input to a digital pin, so as to read its value. The digital state can then be read, corresponding to 0V or 5V on the pin for an Arduino UNO.";  // untranslated
Blockly.Msg.ARD_DIGITALREAD = "read digital pin#";  // untranslated
Blockly.Msg.ARD_DIGITALREAD_TIP = "Read digital value on a pin: HIGH or LOW";  // untranslated
Blockly.Msg.ARD_DIGITALWRITE = "set digitial pin#";  // untranslated
Blockly.Msg.ARD_DIGITALWRITEVAR_TIP = "Write digital value to a Port, the value and port can be computed variables";  // untranslated
Blockly.Msg.ARD_DIGITALWRITE_TIP = "Write digital value HIGH or LOW to a specific Port";  // untranslated
Blockly.Msg.ARD_DIGOUTPUT = "Digital output";  // untranslated
Blockly.Msg.ARD_DIGOUTPUT_COMPONENT = "Digital Output";  // untranslated
Blockly.Msg.ARD_DIGOUTPUT_DEFAULT_NAME = "DigOutput1";  // untranslated
Blockly.Msg.ARD_DIGOUTPUT_TIP = "Connect a generic digital ouput to a digital pin, so as to write to that pin. The digital state can be set to LOW or HIGH, corresponding to 0V and 5V on the pin for an Arduino UNO.";  // untranslated
Blockly.Msg.ARD_DIGOUTPUT_WRITE = "Write to digital output";  // untranslated
Blockly.Msg.ARD_DIORAMA_BOARD_TIP = "The Ingegno Diorama board - See manual for info";  // untranslated
Blockly.Msg.ARD_DIORAMA_BTN_TIP = "Diorama button code, executed in a loop once the button has been pressed";  // untranslated
Blockly.Msg.ARD_DIO_BOARD_MISSING = "No Diorama board present. Add it to the canvas!";  // untranslated
Blockly.Msg.ARD_DIO_DISPLAYTEXT = "Show on display: ";  // untranslated
Blockly.Msg.ARD_DIO_DISPLAYTEXT_TIP = "Give a text of 8 characters to show on the diorama display";  // untranslated
Blockly.Msg.ARD_DIO_DISPLAYTEXT_WARNING = "Text can only be 8 long, not longer!";  // untranslated
Blockly.Msg.ARD_DIO_LESSLOUD = "Diorama: less loud output";  // untranslated
Blockly.Msg.ARD_DIO_LOUDER = "Diorama: louder output";  // untranslated
Blockly.Msg.ARD_DIO_PLAYTRACK = "Play track number ";  // untranslated
Blockly.Msg.ARD_DIO_RESETBTN = "stop buttons";  // untranslated
Blockly.Msg.ARD_DIO_RESETBTNNR_TIP = "Stop action of the given button.";  // untranslated
Blockly.Msg.ARD_DIO_RESETBTN_TIP = "Reset the buttons, so no button is considered pressed.";  // untranslated
Blockly.Msg.ARD_DIO_SETLOUDNESS = "Diorama: set volume to (0-10):";  // untranslated
Blockly.Msg.ARD_DIO_SOUND_TIP = "Change sound output of the Diorama board. If louder or quieter, we stop processing the button after the call.";  // untranslated
Blockly.Msg.ARD_DIO_SOUND_WARNING = "Volume must be between 0 and 10!";  // untranslated
Blockly.Msg.ARD_DIO_STOPBTN = "Pushbutton 8: stop";  // untranslated
Blockly.Msg.ARD_DIO_STOPTRACK = "Stop playing";  // untranslated
Blockly.Msg.ARD_DIO_STOPTRACK_TIP = "Immediately stop playing the track that is playing";  // untranslated
Blockly.Msg.ARD_DIO_TRACKPLAYING = "track is playing";  // untranslated
Blockly.Msg.ARD_DIO_TRACKPLAYING_TIP = "Return true if a track is still playing, false otherwise";  // untranslated
Blockly.Msg.ARD_DIO_TRACK_TIP = "If number 1, then play a track stored on SD card as 'track001.mp3'";  // untranslated
Blockly.Msg.ARD_DIO_TRACK_WARNING = "Track must be a number between 1 and 100!";  // untranslated
Blockly.Msg.ARD_FUN_RUN_DECL = "Arduino define up front:";  // untranslated
Blockly.Msg.ARD_FUN_RUN_DECL_TIP = "Code you want to declare up front (use this e.g. for variables you need in setup)";  // untranslated
Blockly.Msg.ARD_FUN_RUN_LOOP = "Arduino loop forever:";  // untranslated
Blockly.Msg.ARD_FUN_RUN_SETUP = "Arduino run first:";  // untranslated
Blockly.Msg.ARD_FUN_RUN_TIP = "Defines the Arduino setup() and loop() functions.";  // untranslated
Blockly.Msg.ARD_HIGH = "HIGH";  // untranslated
Blockly.Msg.ARD_HIGHLOW_TIP = "Set a pin state logic High or Low.";  // untranslated
Blockly.Msg.ARD_LEDLEG = "LED";  // untranslated
Blockly.Msg.ARD_LEDLEGNEG = "minus";  // untranslated
Blockly.Msg.ARD_LEDLEGPOL = "leg polarity";  // untranslated
Blockly.Msg.ARD_LEDLEGPOS = "plus";  // untranslated
Blockly.Msg.ARD_LEDLEG_COMPONENT = "LED";  // untranslated
Blockly.Msg.ARD_LEDLEG_DEFAULT_NAME = "Led1";  // untranslated
Blockly.Msg.ARD_LEDLEG_OFF = "OFF";  // untranslated
Blockly.Msg.ARD_LEDLEG_ON = "ON";  // untranslated
Blockly.Msg.ARD_LEDLEG_SET = "Set LED";  // untranslated
Blockly.Msg.ARD_LEDLEG_TIP = "A LED light, on of the legs (the positive or negative) is connected to the Arduino. Can be ON or OFF.";  // untranslated
Blockly.Msg.ARD_LEDUP_GADGET = "Gadget LedUpKidz";  // untranslated
Blockly.Msg.ARD_LEDUP_HUB = "LedUpKidz, destination: ";  // untranslated
Blockly.Msg.ARD_LEDUP_HUB_TIP = "LedUpKidz is a gadget with 6 LED that you can program. There is a big prototype connected to an Arduino UNO, choose 'prototype' for code destined for this. The gadget itself works on a small attiny85 microchip, for code with that destination, select destination 'gadget'";  // untranslated
Blockly.Msg.ARD_LEDUP_LED0 = "LED 0";  // untranslated
Blockly.Msg.ARD_LEDUP_LED1 = "LED 1";  // untranslated
Blockly.Msg.ARD_LEDUP_LED2 = "LED 2";  // untranslated
Blockly.Msg.ARD_LEDUP_LED3 = "LED 3";  // untranslated
Blockly.Msg.ARD_LEDUP_LED4 = "LED 4";  // untranslated
Blockly.Msg.ARD_LEDUP_LED5 = "LED 5";  // untranslated
Blockly.Msg.ARD_LEDUP_LED_ONOFF1 = "Put LedUp LED";  // untranslated
Blockly.Msg.ARD_LEDUP_LED_ONOFF2 = "on? True/False:";  // untranslated
Blockly.Msg.ARD_LEDUP_LED_ONOFF_TIP = "Set a given LedUpKidz light to on or off using variable blocks";  // untranslated
Blockly.Msg.ARD_LEDUP_PROTO = "Prototype Arduino UNO";  // untranslated
Blockly.Msg.ARD_LOW = "LOW";  // untranslated
Blockly.Msg.ARD_MAP = "Map";  // untranslated
Blockly.Msg.ARD_MAP_TIP = "Re-maps a number from [0-1024] to another.";  // untranslated
Blockly.Msg.ARD_MAP_VAL = "value to [0-";  // untranslated
Blockly.Msg.ARD_MD_180SERVO = "0~180 degree Servo";  // untranslated
Blockly.Msg.ARD_MD_360SERVO = "0~360 degree Servo";  // untranslated
Blockly.Msg.ARD_MD_AAABLOCK = "AAA 3V Battery module";  // untranslated
Blockly.Msg.ARD_MD_AAABLOCK_TIP = "The battery block for Microduino";  // untranslated
Blockly.Msg.ARD_MD_AAASOUNDWARN = "A AAA Battery module must be added to your blocks if you work with sound";  // untranslated
Blockly.Msg.ARD_MD_AMPBLOCK = "Loudspeaker (Amplifier) Module";  // untranslated
Blockly.Msg.ARD_MD_AMPBLOCK_TIP = "Amplifier module, connect the loudspeaker to it to hear sound.";  // untranslated
Blockly.Msg.ARD_MD_AMPWARN = "An Amplifier module must be added to your blocks";  // untranslated
Blockly.Msg.ARD_MD_AUDIOAMPWARN = "An Audio module must be added to your blocks if you work with an amplifier";  // untranslated
Blockly.Msg.ARD_MD_AUDIOBLOCK = "Sound modules (Audio). Mode:";  // untranslated
Blockly.Msg.ARD_MD_AUDIOBLOCK_TIP = "Audio Function Module, Choose a mode and a volume";  // untranslated
Blockly.Msg.ARD_MD_AUDIOSOUNDWARN = "An Audio module must be added to your blocks to be able to work with music.";  // untranslated
Blockly.Msg.ARD_MD_AUDIO_PAUSE = "Pause sound fragment";  // untranslated
Blockly.Msg.ARD_MD_AUDIO_PAUSE_TIP = "Pause the sound fragment that is playing";  // untranslated
Blockly.Msg.ARD_MD_AUDIO_PLAY = "";  // untranslated
Blockly.Msg.ARD_MD_AUDIO_PLAYNR = "Play sound fragment";  // untranslated
Blockly.Msg.ARD_MD_AUDIO_PLAY_TIP = "Write the number of the sound fragment you want to play. On the this number corresponds to the order in which files have been copied to the SD Card. Best: 1/Empty the SD card 2/copy files to SD card in the order you want to play them 3/it is easier if you name the files 001.mp3, 002.mp3, ... and copy them one after the other to the card!";  // untranslated
Blockly.Msg.ARD_MD_AUDIO_REP1 = "Repeat everything";  // untranslated
Blockly.Msg.ARD_MD_AUDIO_REP2 = "Play everything 1 time";  // untranslated
Blockly.Msg.ARD_MD_AUDIO_REP3 = "Repeat  1 track";  // untranslated
Blockly.Msg.ARD_MD_AUDIO_REP4 = "Play 1 track";  // untranslated
Blockly.Msg.ARD_MD_BLOCKS = "Microduino blocks: ";  // untranslated
Blockly.Msg.ARD_MD_COOKIEBUTTON_COMPONENT = "Microduino MCookie CoreUSB";  // untranslated
Blockly.Msg.ARD_MD_COREBLOCK = "Brain (CoreUSB)";  // untranslated
Blockly.Msg.ARD_MD_COREBLOCK_TIP = "The Brain of your construction, the MCookie-CoreUSB";  // untranslated
Blockly.Msg.ARD_MD_COREWARN = "A Brain (CoreUSB) module must be added to your blocks";  // untranslated
Blockly.Msg.ARD_MD_CRASHBUTTON_COMPONENT = "Microduino Crash Button";  // untranslated
Blockly.Msg.ARD_MD_CRASHBUTTON_DEFAULT_NAME = "Crashbutton1";  // untranslated
Blockly.Msg.ARD_MD_CRASHBUTTON_TIP = "The microduino crash-button with which you can detect if you hit something, or that you can use as a push button.";  // untranslated
Blockly.Msg.ARD_MD_HUBBLOCK = "The Cable holder (Sensor Hub)";  // untranslated
Blockly.Msg.ARD_MD_HUBBLOCK01 = "connected to pins:   IIC";  // untranslated
Blockly.Msg.ARD_MD_HUBBLOCK_TIP = "The Hub allows to connect up to 12 sensors to your Microduino";  // untranslated
Blockly.Msg.ARD_MD_NOSERVO = "Geen Servo gekoppeld";  // untranslated
Blockly.Msg.ARD_MD_SERVOBOT_DEFAULT_NAME = "BottomServo1";  // untranslated
Blockly.Msg.ARD_MD_SERVOCON = "Servo Motor Connector.";  // untranslated
Blockly.Msg.ARD_MD_SERVOCON_BOTTOM = "Define bottom Servo";  // untranslated
Blockly.Msg.ARD_MD_SERVOCON_TIP = "Servo Motor Connector, can control two Servo (top and bottom). You have to give the servo a name, and what type it is (no servo attached, a 180 degree servo or a 360 degree servo.";  // untranslated
Blockly.Msg.ARD_MD_SERVOCON_TOP = "Define top Servo";  // untranslated
Blockly.Msg.ARD_MD_SERVOCON_TYPE = "Type:";  // untranslated
Blockly.Msg.ARD_MD_SERVOTOP_DEFAULT_NAME = "TopServo1";  // untranslated
Blockly.Msg.ARD_MD_SERVOTYPE_TIP = "Select the type of Servo you attach to the Servo connnector";  // untranslated
Blockly.Msg.ARD_MD_SERVO_READ = "read Servo ";  // untranslated
Blockly.Msg.ARD_MD_SERVO_STEP_WARN1 = "A Servo configuration block must be added to the hub to use this block!";  // untranslated
Blockly.Msg.ARD_MD_SERVO_STEP_WARN2 = "A Name input must be added to the Servo configuration block!";  // untranslated
Blockly.Msg.ARD_MD_SERVO_STEP_WARN3 = "Selected servo does not exist any more, please select a new one.";  // untranslated
Blockly.Msg.ARD_MD_SERVO_WRITE = "set 180 degree Servo ";  // untranslated
Blockly.Msg.ARD_NEOPIXEL = "NeoPixel LED light";  // untranslated
Blockly.Msg.ARD_NEOPIXEL_BRIGHTNESS = " brightness (%)";  // untranslated
Blockly.Msg.ARD_NEOPIXEL_COMPONENT = "Neopixel strip";  // untranslated
Blockly.Msg.ARD_NEOPIXEL_DEFAULT_NAME = "NeoPixel1";  // untranslated
Blockly.Msg.ARD_NEOPIXEL_HZ = "Frequency:";  // untranslated
Blockly.Msg.ARD_NEOPIXEL_ONCOLOUR = "on colour";  // untranslated
Blockly.Msg.ARD_NEOPIXEL_ONCOLOURVALBLUE = "blue:";  // untranslated
Blockly.Msg.ARD_NEOPIXEL_ONCOLOURVALGREEN = "green:";  // untranslated
Blockly.Msg.ARD_NEOPIXEL_ONCOLOURVALRED = "on colour (0-255) red:";  // untranslated
Blockly.Msg.ARD_NEOPIXEL_PIXEL = "pixel";  // untranslated
Blockly.Msg.ARD_NEOPIXEL_PIXELS = "Pixels.";  // untranslated
Blockly.Msg.ARD_NEOPIXEL_SET = "Set Neopixel";  // untranslated
Blockly.Msg.ARD_NEOPIXEL_STRIP = "Strip with";  // untranslated
Blockly.Msg.ARD_NEOPIXEL_TIP = "A NEOPIXEL LED light or a strip with multiple neopixels.";  // untranslated
Blockly.Msg.ARD_NEOPIXEL_TYPE = "Type:";  // untranslated
Blockly.Msg.ARD_NOTONE = "Turn off tone on pin #";  // untranslated
Blockly.Msg.ARD_NOTONE_PIN = "No tone PIN#";  // untranslated
Blockly.Msg.ARD_NOTONE_PIN_TIP = "Stop generating a tone on a pin";  // untranslated
Blockly.Msg.ARD_NOTONE_TIP = "Turns the tone off on the selected pin";  // untranslated
Blockly.Msg.ARD_NO_ALLBOT = "No AllBot present";  // untranslated
Blockly.Msg.ARD_OLED = "OLED";  // untranslated
Blockly.Msg.ARD_OLED_CLEAR = "clear display";  // untranslated
Blockly.Msg.ARD_OLED_CLEAR_TIP = "Before writing new text to the display, use this block to clear it first.";  // untranslated
Blockly.Msg.ARD_OLED_CONFIG_TIP = "Define a display of the given resolution to use to write text to";  // untranslated
Blockly.Msg.ARD_OLED_CURSORX = "set cursor position X";  // untranslated
Blockly.Msg.ARD_OLED_CURSORY = "Y";  // untranslated
Blockly.Msg.ARD_OLED_DEFAULT_NAME = "OLED1";  // untranslated
Blockly.Msg.ARD_OLED_FONT_SIZE = "choose font size";  // untranslated
Blockly.Msg.ARD_OLED_FONT_TIP = "Select the font size to use to write text from now on";  // untranslated
Blockly.Msg.ARD_OLED_INIT = "OLED Initialise";  // untranslated
Blockly.Msg.ARD_OLED_PRINT = "print";  // untranslated
Blockly.Msg.ARD_OLED_PRINT_NUMBER = "print number";  // untranslated
Blockly.Msg.ARD_OLED_PRINT_NUMBER_DIGITS = "with #digits:";  // untranslated
Blockly.Msg.ARD_OLED_PRINT_TIP = "Prepare to show the given text on the display in the given size. You need to use the write block to actually see it!";  // untranslated
Blockly.Msg.ARD_OLED_RESOLUTIE = "with resolution";  // untranslated
Blockly.Msg.ARD_OLED_WRITE = "write to display";  // untranslated
Blockly.Msg.ARD_OLED_WRITE_TIP = "After you have printed text on the display, use this block to actually show the text.";  // untranslated
Blockly.Msg.ARD_OUTPUT_WRITE_TO = "value";  // untranslated
Blockly.Msg.ARD_PIN_AN = "analog pin";  // untranslated
Blockly.Msg.ARD_PIN_AN_TIP = "One of the analog pins of the Arduino Board";  // untranslated
Blockly.Msg.ARD_PIN_DIG = "digital pin";  // untranslated
Blockly.Msg.ARD_PIN_DIGDIG = "digital pin1 and pin2";  // untranslated
Blockly.Msg.ARD_PIN_DIGDIG1 = "digital pin1#";  // untranslated
Blockly.Msg.ARD_PIN_DIGDIG2 = "pin2#";  // untranslated
Blockly.Msg.ARD_PIN_DIGDIG_TIP = "Component requiring two digital pins, pin1 and pin2";  // untranslated
Blockly.Msg.ARD_PIN_DIG_TIP = "One of the digital pins of the Arduino Board";  // untranslated
Blockly.Msg.ARD_PIN_PWM = "PWM pin";  // untranslated
Blockly.Msg.ARD_PIN_PWM_TIP = "One of the Pulse Width Modeling (PWM) pins of the Arduino Board";  // untranslated
Blockly.Msg.ARD_PIN_WARN1 = "Pin %1 is needed for %2 as pin %3. Already used as %4.";  // untranslated
Blockly.Msg.ARD_PULSEON = "pulse on pin #";  // untranslated
Blockly.Msg.ARD_PULSEREAD = "Read";  // untranslated
Blockly.Msg.ARD_PULSETIMEOUT = "timeout after";  // untranslated
Blockly.Msg.ARD_PULSETIMEOUT_MS = "";  // untranslated
Blockly.Msg.ARD_PULSETIMEOUT_TIP = "Measures the duration of a pulse on the selected pin, if it is within the timeout.";  // untranslated
Blockly.Msg.ARD_PULSE_READ = "measure %1 pulse on pin #%2";  // untranslated
Blockly.Msg.ARD_PULSE_READ_TIMEOUT = "measure %1 pulse on pin #%2 (timeout after %3 μs)";  // untranslated
Blockly.Msg.ARD_PULSE_TIP = "Measures the duration of a pulse on the selected pin.";  // untranslated
Blockly.Msg.ARD_PWMOUTPUT = "PWM output";  // untranslated
Blockly.Msg.ARD_PWMOUTPUT_COMPONENT = "PWM Output";  // untranslated
Blockly.Msg.ARD_PWMOUTPUT_DEFAULT_NAME = "PWMOutput1";  // untranslated
Blockly.Msg.ARD_PWMOUTPUT_TIP = "Connect a generic PWM (Pulse Width Modulation) ouput to a pwm pin, so as to write an analog value to that pin. The value written should be a number between 0 and 255, and will generate a block pulse over this pin.";  // untranslated
Blockly.Msg.ARD_PWMOUTPUT_WRITE = "Write to PWM output";  // untranslated
Blockly.Msg.ARD_SERIAL_BPS = "bps";  // untranslated
Blockly.Msg.ARD_SERIAL_PRINT = "print";  // untranslated
Blockly.Msg.ARD_SERIAL_PRINT_NEWLINE = "add new line";  // untranslated
Blockly.Msg.ARD_SERIAL_PRINT_TIP = "Prints data to the console/serial port as human-readable ASCII text.";  // untranslated
Blockly.Msg.ARD_SERIAL_PRINT_WARN = "A setup block for %1 must be added to the workspace to use this block!";  // untranslated
Blockly.Msg.ARD_SERIAL_SETUP = "Setup";  // untranslated
Blockly.Msg.ARD_SERIAL_SETUP_TIP = "Selects the speed for a specific Serial peripheral";  // untranslated
Blockly.Msg.ARD_SERIAL_SPEED = ":  speed to";  // untranslated
Blockly.Msg.ARD_SERVOHUB = "Servo motor";  // untranslated
Blockly.Msg.ARD_SERVOHUB_READ = "read Servo ";  // untranslated
Blockly.Msg.ARD_SERVOHUB_TIP = "Servo Motor Connection, which can attach to a PWM pin. You have to give the servo a name, and what type it is (a 180 degree servo or a 360 degree servo.)";  // untranslated
Blockly.Msg.ARD_SERVOHUB_WRITE = "set 180 degree Servo ";  // untranslated
Blockly.Msg.ARD_SERVO_COMPONENT = "servo";  // untranslated
Blockly.Msg.ARD_SERVO_DEFAULT_NAME = "Servo1";  // untranslated
Blockly.Msg.ARD_SERVO_READ = "read SERVO from PIN#";  // untranslated
Blockly.Msg.ARD_SERVO_READ_TIP = "Read a Servo angle";  // untranslated
Blockly.Msg.ARD_SERVO_ROTATE360 = "Rotate 360 degree Servo";  // untranslated
Blockly.Msg.ARD_SERVO_ROTATEPERC = "% (-100 to 100)";  // untranslated
Blockly.Msg.ARD_SERVO_ROTATESPEED = "with speed";  // untranslated
Blockly.Msg.ARD_SERVO_ROTATE_TIP = "Turn a Servo with a specific speed";  // untranslated
Blockly.Msg.ARD_SERVO_TYPE = "Type:";  // untranslated
Blockly.Msg.ARD_SERVO_WRITE = "set SERVO from Pin";  // untranslated
Blockly.Msg.ARD_SERVO_WRITE_DEG_180 = "Degrees (0~180)";  // untranslated
Blockly.Msg.ARD_SERVO_WRITE_TIP = "Set a Servo to an specified angle";  // untranslated
Blockly.Msg.ARD_SERVO_WRITE_TO = "to";  // untranslated
Blockly.Msg.ARD_SETTONE = "Set tone on pin #";  // untranslated
Blockly.Msg.ARD_SPI_SETUP = "Setup";  // untranslated
Blockly.Msg.ARD_SPI_SETUP_CONF = "configuration:";  // untranslated
Blockly.Msg.ARD_SPI_SETUP_DIVIDE = "clock divide";  // untranslated
Blockly.Msg.ARD_SPI_SETUP_LSBFIRST = "LSBFIRST";  // untranslated
Blockly.Msg.ARD_SPI_SETUP_MODE = "SPI mode (idle - edge)";  // untranslated
Blockly.Msg.ARD_SPI_SETUP_MODE0 = "0 (Low - Falling)";  // untranslated
Blockly.Msg.ARD_SPI_SETUP_MODE1 = "1 (Low - Rising)";  // untranslated
Blockly.Msg.ARD_SPI_SETUP_MODE2 = "2 (High - Falling)";  // untranslated
Blockly.Msg.ARD_SPI_SETUP_MODE3 = "3 (High - Rising)";  // untranslated
Blockly.Msg.ARD_SPI_SETUP_MSBFIRST = "MSBFIRST";  // untranslated
Blockly.Msg.ARD_SPI_SETUP_SHIFT = "data shift";  // untranslated
Blockly.Msg.ARD_SPI_SETUP_TIP = "Configures the SPI peripheral.";  // untranslated
Blockly.Msg.ARD_SPI_TRANSRETURN_TIP = "Send a SPI message to an specified slave device and get data back.";  // untranslated
Blockly.Msg.ARD_SPI_TRANS_NONE = "none";  // untranslated
Blockly.Msg.ARD_SPI_TRANS_SLAVE = "to slave pin";  // untranslated
Blockly.Msg.ARD_SPI_TRANS_TIP = "Send a SPI message to an specified slave device.";  // untranslated
Blockly.Msg.ARD_SPI_TRANS_VAL = "transfer";  // untranslated
Blockly.Msg.ARD_SPI_TRANS_WARN1 = "A setup block for %1 must be added to the workspace to use this block!";  // untranslated
Blockly.Msg.ARD_SPI_TRANS_WARN2 = "Old pin value %1 is no longer available.";  // untranslated
Blockly.Msg.ARD_STEPPER_COMPONENT = "stepper";  // untranslated
Blockly.Msg.ARD_STEPPER_DEFAULT_NAME = "MyStepper";  // untranslated
Blockly.Msg.ARD_STEPPER_DEGREES = "degrees";  // untranslated
Blockly.Msg.ARD_STEPPER_FOUR_PINS = "4";  // untranslated
Blockly.Msg.ARD_STEPPER_ISROTATING = "in movement";  // untranslated
Blockly.Msg.ARD_STEPPER_ISROTATING_TIP = "Returns true if the stepper is moving.";  // untranslated
Blockly.Msg.ARD_STEPPER_MOTOR = "stepper motor:";  // untranslated
Blockly.Msg.ARD_STEPPER_NUMBER_OF_PINS = "Number of pins";  // untranslated
Blockly.Msg.ARD_STEPPER_PIN1 = "pin1#";  // untranslated
Blockly.Msg.ARD_STEPPER_PIN2 = "pin2#";  // untranslated
Blockly.Msg.ARD_STEPPER_PIN3 = "pin3#";  // untranslated
Blockly.Msg.ARD_STEPPER_PIN4 = "pin4#";  // untranslated
Blockly.Msg.ARD_STEPPER_RESTART = "Get";  // untranslated
Blockly.Msg.ARD_STEPPER_RESTART_AFTER = "ready";  // untranslated
Blockly.Msg.ARD_STEPPER_RESTART_TIP = "Reset the motor ready after a rotation block has finished, so as to be able to rotate again";  // untranslated
Blockly.Msg.ARD_STEPPER_REVOLVS = "how many steps per revolution";  // untranslated
Blockly.Msg.ARD_STEPPER_ROTATE = "Rotate";  // untranslated
Blockly.Msg.ARD_STEPPER_ROTATE_TIP = "Rotate the stepper motor over a number of degrees in a non-blocking way. This block must be called in the loop. When finished the stepper is blocked, and a call to restart movement is needed for the block to cause a next movement.";  // untranslated
Blockly.Msg.ARD_STEPPER_SETUP = "Setup stepper motor";  // untranslated
Blockly.Msg.ARD_STEPPER_SETUP_TIP = "Configures a stepper motor pinout and other settings.";  // untranslated
Blockly.Msg.ARD_STEPPER_SPEED = "set speed (rpm) to";  // untranslated
Blockly.Msg.ARD_STEPPER_SPEED_TIP = "Sets speed of the stepper motor. The steps are set at the speed needed to have the set RPM speed based on the given steps per revolution in the constructor.";  // untranslated
Blockly.Msg.ARD_STEPPER_STEP = "move stepper";  // untranslated
Blockly.Msg.ARD_STEPPER_STEPS = "steps";  // untranslated
Blockly.Msg.ARD_STEPPER_STEP_TIP = "Turns the stepper motor a specific number of steps.";  // untranslated
Blockly.Msg.ARD_STEPPER_TWO_PINS = "2";  // untranslated
Blockly.Msg.ARD_TFT_BG_COLOUR = "Color of the background";  // untranslated
Blockly.Msg.ARD_TFT_BG_TIP = "Fill the entire screen with the given colour";  // untranslated
Blockly.Msg.ARD_TFT_CIRC_HEIGHT = "Height";  // untranslated
Blockly.Msg.ARD_TFT_CIRC_RADIUS = "Radius";  // untranslated
Blockly.Msg.ARD_TFT_CIRC_TIP = "Draw a circle on the screen with the given coordinates in the given colour. If Filled is checked the circle is filled, otherwise only an outline";  // untranslated
Blockly.Msg.ARD_TFT_CIRC_XPOS = "X Position Center";  // untranslated
Blockly.Msg.ARD_TFT_CIRC_YPOS = "Y Position Center";  // untranslated
Blockly.Msg.ARD_TFT_COMPONENT = "TFT-Scherm";  // untranslated
Blockly.Msg.ARD_TFT_COMPONENT_TIP = "The ST7735 1.8" Color TFT scherm. Scherm is 128x160 pixels.";  // untranslated
Blockly.Msg.ARD_TFT_FILLED = "Fill the drawing";  // untranslated
Blockly.Msg.ARD_TFT_LINE_COLOUR = "Colour";  // untranslated
Blockly.Msg.ARD_TFT_LINE_TIP = "Draw a line on the screen with the given coordinates in the given colour.";  // untranslated
Blockly.Msg.ARD_TFT_LINE_XPOSBEGIN = "X Position Start";  // untranslated
Blockly.Msg.ARD_TFT_LINE_XPOSEND = "X Position End";  // untranslated
Blockly.Msg.ARD_TFT_LINE_YPOSBEGIN = "Y Position Start";  // untranslated
Blockly.Msg.ARD_TFT_LINE_YPOSEND = "Y Position End";  // untranslated
Blockly.Msg.ARD_TFT_MAKE_CIRC = "Draw Circle";  // untranslated
Blockly.Msg.ARD_TFT_MAKE_LINE = "Draw Line";  // untranslated
Blockly.Msg.ARD_TFT_MAKE_RECT = "Draw Rectangle";  // untranslated
Blockly.Msg.ARD_TFT_RECT_COLOUR = "Colour";  // untranslated
Blockly.Msg.ARD_TFT_RECT_HEIGHT = "Height";  // untranslated
Blockly.Msg.ARD_TFT_RECT_TIP = "Draw a rectangle on the screen with the given coordinates in the given colour. If Filled is checked the rectangle is filled, otherwise only an outline";  // untranslated
Blockly.Msg.ARD_TFT_RECT_WIDTH = "Width";  // untranslated
Blockly.Msg.ARD_TFT_RECT_XPOSBEGIN = "X Position Top Left";  // untranslated
Blockly.Msg.ARD_TFT_RECT_YPOSBEGIN = "Y Position Top Left";  // untranslated
Blockly.Msg.ARD_TFT_SPRITE_NAME = "Sprite named";  // untranslated
Blockly.Msg.ARD_TFT_TEXT_COLOUR = "Colour of the text";  // untranslated
Blockly.Msg.ARD_TFT_TEXT_SIZE = "Size";  // untranslated
Blockly.Msg.ARD_TFT_TEXT_TIP = "Write a text to the screen in the given colour at the given position.";  // untranslated
Blockly.Msg.ARD_TFT_TEXT_WRITE = "Write text";  // untranslated
Blockly.Msg.ARD_TFT_TEXT_XPOS = "X Position";  // untranslated
Blockly.Msg.ARD_TFT_TEXT_YPOS = "Y Position";  // untranslated
Blockly.Msg.ARD_TIME_DELAY = "wait";  // untranslated
Blockly.Msg.ARD_TIME_DELAY_MICROS = "microseconds";  // untranslated
Blockly.Msg.ARD_TIME_DELAY_MICRO_TIP = "Wait specific time in microseconds";  // untranslated
Blockly.Msg.ARD_TIME_DELAY_TIP = "Wait specific time in milliseconds";  // untranslated
Blockly.Msg.ARD_TIME_INF = "wait forever (end program)";  // untranslated
Blockly.Msg.ARD_TIME_INF_TIP = "Wait indefinitely, stopping the program.";  // untranslated
Blockly.Msg.ARD_TIME_MICROS = "current elapsed Time (microseconds)";  // untranslated
Blockly.Msg.ARD_TIME_MICROS_TIP = "Returns the number of microseconds since the Arduino board began running the current program. Has to be stored in a positive long integer";  // untranslated
Blockly.Msg.ARD_TIME_MILLIS = "current elapsed Time (milliseconds)";  // untranslated
Blockly.Msg.ARD_TIME_MILLIS_TIP = "Returns the number of milliseconds since the Arduino board began running the current program. Has to be stored in a positive long integer";  // untranslated
Blockly.Msg.ARD_TIME_MS = "milliseconds";  // untranslated
Blockly.Msg.ARD_TONEDURATION = "and duration (ms)";  // untranslated
Blockly.Msg.ARD_TONEDURATION_TIP = "Sets tone on a buzzer to the specified frequency within range 31 - 65535 and given duration in milliseconds. Careful: a durations continues, also during delays, a new tone can only be given if a previous tone is terminated!";  // untranslated
Blockly.Msg.ARD_TONEFREQ = "at frequency";  // untranslated
Blockly.Msg.ARD_TONEPITCH_TIP = "Sets tone on a buzzer to the specified pitch and given duration in milliseconds. Careful: a durations continues, also during delays, a new tone can only be given if a previous tone is terminated!";  // untranslated
Blockly.Msg.ARD_TONE_FREQ = "frequency";  // untranslated
Blockly.Msg.ARD_TONE_PIN = "Tone PIN#";  // untranslated
Blockly.Msg.ARD_TONE_PIN_TIP = "Generate audio tones on a pin";  // untranslated
Blockly.Msg.ARD_TONE_TIP = "Sets tone on pin to specified frequency within range 31 - 65535";  // untranslated
Blockly.Msg.ARD_TONE_WARNING = "Frequency must be in range 31 - 65535";  // untranslated
Blockly.Msg.ARD_TONE_WARNING2 = "A duration must be positive (>0)";  // untranslated
Blockly.Msg.ARD_TYPE_ARRAY = "Array";  // untranslated
Blockly.Msg.ARD_TYPE_BOOL = "Boolean";  // untranslated
Blockly.Msg.ARD_TYPE_CHAR = "Character";  // untranslated
Blockly.Msg.ARD_TYPE_CHILDBLOCKMISSING = "ChildBlockMissing";  // untranslated
Blockly.Msg.ARD_TYPE_DECIMAL = "Decimal";  // untranslated
Blockly.Msg.ARD_TYPE_LONG = "Large Number";  // untranslated
Blockly.Msg.ARD_TYPE_NULL = "Null";  // untranslated
Blockly.Msg.ARD_TYPE_NUMBER = "Number";  // untranslated
Blockly.Msg.ARD_TYPE_SHORT = "Short Number";  // untranslated
Blockly.Msg.ARD_TYPE_TEXT = "Text";  // untranslated
Blockly.Msg.ARD_TYPE_UNDEF = "Undefined";  // untranslated
Blockly.Msg.ARD_UNKNOWN_ALLBOTJOINT = "The old joint value %1 is no longer available";  // untranslated
Blockly.Msg.ARD_VAR_AS = "as";  // untranslated
Blockly.Msg.ARD_VAR_AS_TIP = "Sets a value to a specific type";  // untranslated
Blockly.Msg.ARD_WRITE_TO = "to";  // untranslated
Blockly.Msg.B4A_COMPILE_EMPTY = "Compiler returned empty file - Device not flashed";  // untranslated
Blockly.Msg.B4A_ERROR = "ERROR!";  // untranslated
Blockly.Msg.B4A_FLASHING = "Flashing to device";  // untranslated
Blockly.Msg.B4A_MSG_EXTENSION = "Message from extension: ";  // untranslated
Blockly.Msg.B4A_NO_CHROME = "You need to use Google Chrome to use this Upload functionality";  // untranslated
Blockly.Msg.B4A_NO_EXTENSION = "Chrome Extension is not installed";  // untranslated
Blockly.Msg.B4A_SET_IP_COMPILER = "New IP Address Compiler";  // untranslated
Blockly.Msg.B4A_SUCCESS = "SUCCESS!";  // untranslated
Blockly.Msg.B4A_UPLOAD_FAIL = "Upload failed. Chrome Extension is not installed";  // untranslated
Blockly.Msg.B4A_VERIFY_FAIL = "Verify failed. Chrome Extension is not installed";  // untranslated
Blockly.Msg.COLOUR_RGB255_TOOLTIP = "Create a colour with the specified amount of red, green, and blue. All values must be between 0 and 255. See https://www.google.be/search?q=color+picker";  // untranslated
Blockly.Msg.NEW_INSTANCE = "New instance...";  // untranslated
Blockly.Msg.NEW_INSTANCE_TITLE = "New instance name:";  // untranslated
Blockly.Msg.RENAME_INSTANCE = "Rename instance...";  // untranslated
Blockly.Msg.RENAME_INSTANCE_TITLE = "Rename all '%1' instances to:";  // untranslated
Blockly.Msg.REPLACE_EXISTING_BLOCKS = "Replace existing blocks? 'Cancel' will merge.";  // untranslated
Blockly.Msg.UPLOAD_CLICK_1 = "To Upload your code to Arduino:";  // untranslated
Blockly.Msg.UPLOAD_CLICK_2 = "  1. click on the Arduino tab";  // untranslated
Blockly.Msg.UPLOAD_CLICK_3 = "  2. select all the code, and copy (CTRL+A and CTRL+C)";  // untranslated
Blockly.Msg.UPLOAD_CLICK_4 = "  3. In the Arduino IDE or in a http://codebender.cc sketch, paste the code (CTRL+V)";  // untranslated
Blockly.Msg.UPLOAD_CLICK_5 = "  4. Upload to your connected Arduino";  // untranslated
Blockly.Msg.ARD_CONTROLS_EFFECT_MSG_THEN = Blockly.Msg.CONTROLS_REPEAT_INPUT_DO;
Blockly.Msg.ARD_CONTROLS_EFFECT_IF_TITLE_IF = Blockly.Msg.ARD_CONTROLS_EFFECT_MSG_IF;
Blockly.Msg.ARD_CONTROLS_EFFECT_IF_TOOLTIP = Blockly.Msg.CONTROLS_IF_IF_TOOLTIP;
Blockly.Msg.ARD_CONTROLS_EFFECT_ELSEIF_TITLE_ELSEIF = Blockly.Msg.ARD_CONTROLS_EFFECT_MSG_ELSEIF;
Blockly.Msg.ARD_CONTROLS_EFFECT_ELSE_TITLE_ELSE = Blockly.Msg.ARD_CONTROLS_EFFECT_MSG_ELSE;


text:
<?php

namespace Magento\Framework\Autoload;

use Composer\Autoload\ClassLoader;

/**
 * Wrapper designed to insulate the autoloader class provided by Composer
 */
class ClassLoaderWrapper implements AutoloaderInterface
{
    /**
     * Using the autoloader class provided by Composer
     *
     * @var ClassLoader
     */
    protected $autoloader;

    /**
     * @param ClassLoader $autoloader
     */
    public function __construct(ClassLoader $autoloader)
    {
        $this->autoloader = $autoloader;
    }

    /**
     * {@inheritdoc}
     */
    public function addPsr4($nsPrefix, $paths, $prepend = false)
    {
        $this->autoloader->addPsr4($nsPrefix, $paths, $prepend);
    }

    /**
     * {@inheritdoc}
     */
    public function addPsr0($nsPrefix, $paths, $prepend = false)
    {
        $this->autoloader->add($nsPrefix, $paths, $prepend);
    }

    /**
     * {@inheritdoc}
     */
    public function setPsr0($nsPrefix, $paths)
    {
        $this->autoloader->set($nsPrefix, $paths);
    }

    /**
     * {@inheritdoc}
     */
    public function setPsr4($nsPrefix, $paths)
    {
        $this->autoloader->setPsr4($nsPrefix, $paths);
    }

    /**
     * {@inheritdoc}
     * @codeCoverageIgnore
     */
    public function loadClass($className)
    {
        return $this->autoloader->loadClass($className) === true;
    }

    /**
     * {@inheritdoc}
     * @codeCoverageIgnore
     */
    public function findFile($className)
    {
        /**
         * Composer remembers that files don't exist even after they are generated. This clears the entry for
         * $className so we can check the filesystem again for class existence.
         */
        if ($className[0] === '\\') {
            $className = substr($className, 1);
        }
        $this->autoloader->addClassMap([$className => null]);
        return $this->autoloader->findFile($className);
    }
}


text:
"""Provides data for the flowers dataset.
The dataset scripts used to create the dataset can be found at:
tensorflow/models/slim/datasets/download_and_convert_flowers.py
"""

import os
import tensorflow as tf

import dataset_utils

slim = tf.contrib.slim

_FILE_PATTERN = '%s.tfrecord'

SPLITS_TO_SIZES = {'train': 200000, 'test': 1000}

_NUM_CLASSES = 10

_ITEMS_TO_DESCRIPTIONS = {
    'image': 'A gray image of varying size.',
    'label': 'A single integer between 0 and 10',
}

def get_split(split_name, dataset_dir, file_pattern=None, reader=None):
  """Gets a dataset tuple with instructions for reading flowers.
  Args:
    split_name: A train/validation split name.
    dataset_dir: The base directory of the dataset sources.
    file_pattern: The file pattern to use when matching the dataset sources.
      It is assumed that the pattern contains a '%s' string so that the split
      name can be inserted.
    reader: The TensorFlow reader type.
  Returns:
    A `Dataset` namedtuple.
  Raises:
    ValueError: if `split_name` is not a valid train/validation split.
  """
  if split_name not in SPLITS_TO_SIZES:
    raise ValueError('split name %s was not recognized.' % split_name)

  if not file_pattern:
    file_pattern = _FILE_PATTERN
  file_pattern = os.path.join(dataset_dir, file_pattern % split_name)

  # Allowing None in the signature so that dataset_factory can use the default.
  if reader is None:
    reader = tf.TFRecordReader

  keys_to_features = {
      'image/encoded': tf.FixedLenFeature((), tf.string, default_value=''),
      'image/format': tf.FixedLenFeature((), tf.string, default_value='png'),
      'image/class/label': tf.FixedLenFeature(
          [], tf.int64, default_value=tf.zeros([], dtype=tf.int64)),
  }

  items_to_handlers = {
      'image': slim.tfexample_decoder.Image(channels=1),
      'label': slim.tfexample_decoder.Tensor('image/class/label'),
  }

  decoder = slim.tfexample_decoder.TFExampleDecoder(
      keys_to_features, items_to_handlers)

  labels_to_names = None
  if dataset_utils.has_labels(dataset_dir):
    labels_to_names = dataset_utils.read_label_file(dataset_dir)

  return slim.dataset.Dataset(
      data_sources=file_pattern,
      reader=reader,
      decoder=decoder,
      num_samples=SPLITS_TO_SIZES[split_name],
      items_to_descriptions=_ITEMS_TO_DESCRIPTIONS,
      num_classes=_NUM_CLASSES,
      labels_to_names=labels_to_names)