text:
(function webpackUniversalModuleDefinition(root, factory) {
	if(typeof exports === 'object' && typeof module === 'object')
		module.exports = factory(require("_"), require("Backbone"));
	else if(typeof define === 'function' && define.amd)
		define(["_", "Backbone"], factory);
	else if(typeof exports === 'object')
		exports["Core"] = factory(require("_"), require("Backbone"));
	else
		root["ThreeNodes"] = root["ThreeNodes"] || {}, root["ThreeNodes"]["Core"] = factory(root["_"], root["Backbone"]);
})(this, function(__WEBPACK_EXTERNAL_MODULE_2__, __WEBPACK_EXTERNAL_MODULE_3__) {
return /******/ (function(modules) { // webpackBootstrap
/******/ 	// The module cache
/******/ 	var installedModules = {};
/******/
/******/ 	// The require function
/******/ 	function __webpack_require__(moduleId) {
/******/
/******/ 		// Check if module is in cache
/******/ 		if(installedModules[moduleId])
/******/ 			return installedModules[moduleId].exports;
/******/
/******/ 		// Create a new module (and put it into the cache)
/******/ 		var module = installedModules[moduleId] = {
/******/ 			exports: {},
/******/ 			id: moduleId,
/******/ 			loaded: false
/******/ 		};
/******/
/******/ 		// Execute the module function
/******/ 		modules[moduleId].call(module.exports, module, module.exports, __webpack_require__);
/******/
/******/ 		// Flag the module as loaded
/******/ 		module.loaded = true;
/******/
/******/ 		// Return the exports of the module
/******/ 		return module.exports;
/******/ 	}
/******/
/******/
/******/ 	// expose the modules object (__webpack_modules__)
/******/ 	__webpack_require__.m = modules;
/******/
/******/ 	// expose the module cache
/******/ 	__webpack_require__.c = installedModules;
/******/
/******/ 	// __webpack_public_path__
/******/ 	__webpack_require__.p = "assets/";
/******/
/******/ 	// Load entry module and return exports
/******/ 	return __webpack_require__(0);
/******/ })
/************************************************************************/
/******/ ({

/***/ 0:
/***/ function(module, exports, __webpack_require__) {

	var Core, GroupDefinitions, Nodes;

	Nodes = __webpack_require__(11);

	GroupDefinitions = __webpack_require__(4);

	Core = (function() {
	  Core.fields = {
	    models: {},
	    views: {}
	  };

	  Core.nodes = {
	    models: {},
	    views: {}
	  };

	  function Core(options) {
	    var settings;
	    settings = {
	      test: false,
	      player_mode: false
	    };
	    this.settings = $.extend({}, settings, options);
	    this.group_definitions = new GroupDefinitions([]);
	    this.nodes = new Nodes([], {
	      settings: this.settings
	    });
	    this.group_definitions.bind("definition:created", this.nodes.createGroup);
	    this.group_definitions.bind("remove", this.nodes.removeGroupsByDefinition);
	  }

	  Core.addFieldType = function(fieldName, field) {
	    Core.fields.models[fieldName] = field;
	    return true;
	  };

	  Core.addFieldView = function(fieldName, fieldView) {
	    Core.fields.views[fieldName] = fieldView;
	    return true;
	  };

	  Core.addNodeType = function(nodeName, nodeType) {
	    Core.nodes.models[nodeName] = nodeType;
	    return true;
	  };

	  Core.addNodeView = function(viewName, nodeView) {
	    Core.nodes.views[viewName] = nodeView;
	    return true;
	  };

	  Core.prototype.setNodes = function(json_object) {
	    var connection, def, delay, grp, grp_def, i, j, k, len, len1, len2, node, ref, ref1, ref2;
	    this.nodes.removeAll();
	    if (json_object.groups) {
	      ref = json_object.groups;
	      for (i = 0, len = ref.length; i < len; i++) {
	        grp_def = ref[i];
	        this.group_definitions.create(grp_def);
	      }
	    }
	    ref1 = json_object.nodes;
	    for (j = 0, len1 = ref1.length; j < len1; j++) {
	      node = ref1[j];
	      if (node.type !== "Group") {
	        this.nodes.createNode(node);
	      } else {
	        def = this.group_definitions.getByGid(node.definition_id);
	        if (def) {
	          node.definition = def;
	          grp = this.nodes.createGroup(node);
	        } else {
	          console.log("can't find the GroupDefinition: " + node.definition_id);
	        }
	      }
	    }
	    ref2 = json_object.connections;
	    for (k = 0, len2 = ref2.length; k < len2; k++) {
	      connection = ref2[k];
	      this.nodes.createConnectionFromObject(connection);
	    }
	    this.nodes.indexer.uid = json_object.uid;
	    delay = function(ms, func) {
	      return setTimeout(func, ms);
	    };
	    return delay(1, (function(_this) {
	      return function() {
	        return _this.nodes.renderAllConnections();
	      };
	    })(this));
	  };

	  return Core;

	})();

	module.exports = Core;

/***/ },

/***/ 2:
/***/ function(module, exports, __webpack_require__) {

	module.exports = __WEBPACK_EXTERNAL_MODULE_2__;

/***/ },

/***/ 3:
/***/ function(module, exports, __webpack_require__) {

	module.exports = __WEBPACK_EXTERNAL_MODULE_3__;

/***/ },

/***/ 4:
/***/ function(module, exports, __webpack_require__) {

	var Backbone, GroupDefinition, GroupDefinitions, Indexer, _,
	  bind = function(fn, me){ return function(){ return fn.apply(me, arguments); }; },
	  extend = function(child, parent) { for (var key in parent) { if (hasProp.call(parent, key)) child[key] = parent[key]; } function ctor() { this.constructor = child; } ctor.prototype = parent.prototype; child.prototype = new ctor(); child.__super__ = parent.prototype; return child; },
	  hasProp = {}.hasOwnProperty;

	_ = __webpack_require__(2);

	Backbone = __webpack_require__(3);

	Indexer = __webpack_require__(43);

	GroupDefinition = __webpack_require__(44);

	GroupDefinitions = (function(superClass) {
	  extend(GroupDefinitions, superClass);

	  function GroupDefinitions() {
	    this.removeAll = bind(this.removeAll, this);
	    this.groupSelectedNodes = bind(this.groupSelectedNodes, this);
	    this.create = bind(this.create, this);
	    this.render = bind(this.render, this);
	    this.getByGid = bind(this.getByGid, this);
	    this.removeAll = bind(this.removeAll, this);
	    this.initialize = bind(this.initialize, this);
	    return GroupDefinitions.__super__.constructor.apply(this, arguments);
	  }

	  GroupDefinitions.prototype.model = GroupDefinition;

	  GroupDefinitions.prototype.initialize = function() {
	    this.indexer = new Indexer();
	    return this.bind("group:removed", (function(_this) {
	      return function(c) {
	        return _this.remove(c);
	      };
	    })(this));
	  };

	  GroupDefinitions.prototype.removeAll = function() {
	    var models;
	    models = this.models.concat();
	    _.invoke(models, "remove");
	    this.reset([]);
	    return this.indexer.reset();
	  };

	  GroupDefinitions.prototype.getByGid = function(gid) {
	    return this.find(function(def) {
	      return def.get("gid") === gid;
	    });
	  };

	  GroupDefinitions.prototype.render = function() {
	    return this.each(function(c) {
	      return c.render();
	    });
	  };

	  GroupDefinitions.prototype.create = function(model, options) {
	    if (!options) {
	      options = {};
	    }
	    options.indexer = this.indexer;
	    model = this._prepareModel(model, options);
	    if (!model) {
	      return false;
	    }
	    this.add(model, options);
	    return model;
	  };

	  GroupDefinitions.prototype.groupSelectedNodes = function(selected_nodes) {
	    var already_exists, average_position, connection, connection_description, dx, dy, external_connections, external_objects, field, group_def, i, indx1, indx2, j, k, l, len, len1, len2, len3, model, node, ref, ref1;
	    if (selected_nodes == null) {
	      selected_nodes = false;
	    }
	    if (!selected_nodes) {
	      selected_nodes = this.getSelectedNodes();
	    }
	    average_position = this.getNodesAveragePosition(selected_nodes);
	    dx = average_position.x;
	    dy = average_position.y;
	    group_def = new GroupDefinition({
	      fromSelectedNodes: selected_nodes,
	      indexer: this.indexer
	    });
	    this.add(group_def);
	    external_connections = [];
	    external_objects = [];
	    for (i = 0, len = selected_nodes.length; i < len; i++) {
	      node = selected_nodes[i];
	      ref = node.fields.models;
	      for (j = 0, len1 = ref.length; j < len1; j++) {
	        field = ref[j];
	        ref1 = field.connections;
	        for (k = 0, len2 = ref1.length; k < len2; k++) {
	          connection = ref1[k];
	          indx1 = selected_nodes.indexOf(connection.from_field.node);
	          indx2 = selected_nodes.indexOf(connection.to_field.node);
	          if (indx1 === -1 || indx2 === -1) {
	            already_exists = external_connections.indexOf(connection);
	            if (already_exists === -1) {
	              external_connections.push(connection);
	              connection_description = connection.toJSON();
	              connection_description.to_subfield = indx1 === -1;
	              external_objects.push(connection_description);
	            }
	          }
	        }
	      }
	    }
	    for (l = 0, len3 = selected_nodes.length; l < len3; l++) {
	      node = selected_nodes[l];
	      node.remove();
	    }
	    model = {
	      type: "Group",
	      definition: group_def,
	      x: dx,
	      y: dy
	    };
	    this.trigger("definition:created", model, external_objects);
	    return group_def;
	  };

	  GroupDefinitions.prototype.getSelectedNodes = function() {
	    var $selected, selected_nodes;
	    selected_nodes = [];
	    $selected = $(".node.ui-selected").not(".node .node");
	    $selected.each(function() {
	      var node;
	      node = $(this).data("object");
	      return selected_nodes.push(node);
	    });
	    return selected_nodes;
	  };

	  GroupDefinitions.prototype.getNodesAveragePosition = function(selected_nodes) {
	    var $selected, dx, dy, i, len, max_x, max_y, min_x, min_y, node;
	    min_x = 0;
	    min_y = 0;
	    max_x = 0;
	    max_y = 0;
	    $selected = $(".node.ui-selected");
	    if ($selected.length < 1 && selected_nodes.length === 0) {
	      return false;
	    }
	    for (i = 0, len = selected_nodes.length; i < len; i++) {
	      node = selected_nodes[i];
	      min_x = Math.min(min_x, node.get("x"));
	      max_x = Math.max(max_x, node.get("x"));
	      min_y = Math.min(min_y, node.get("y"));
	      max_y = Math.max(max_y, node.get("y"));
	    }
	    dx = (min_x + max_x) / 2;
	    dy = (min_y + max_y) / 2;
	    return {
	      x: dx,
	      y: dy
	    };
	  };

	  GroupDefinitions.prototype.removeAll = function() {
	    return this.remove(this.models);
	  };

	  return GroupDefinitions;

	})(Backbone.Collection);

	module.exports = GroupDefinitions;

/***/ },

/***/ 11:
/***/ function(module, exports, __webpack_require__) {

	var Backbone, Connections, Indexer, Nodes, _,
	  bind = function(fn, me){ return function(){ return fn.apply(me, arguments); }; },
	  extend = function(child, parent) { for (var key in parent) { if (hasProp.call(parent, key)) child[key] = parent[key]; } function ctor() { this.constructor = child; } ctor.prototype = parent.prototype; child.prototype = new ctor(); child.__super__ = parent.prototype; return child; },
	  hasProp = {}.hasOwnProperty;

	_ = __webpack_require__(2);

	Backbone = __webpack_require__(3);

	Indexer = __webpack_require__(43);

	Connections = __webpack_require__(57);

	Nodes = (function(superClass) {
	  extend(Nodes, superClass);

	  function Nodes() {
	    this.stopSound = bind(this.stopSound, this);
	    this.startSound = bind(this.startSound, this);
	    this.showNodesAnimation = bind(this.showNodesAnimation, this);
	    this.getNodeByNid = bind(this.getNodeByNid, this);
	    this.renderAllConnections = bind(this.renderAllConnections, this);
	    this.removeGroupsByDefinition = bind(this.removeGroupsByDefinition, this);
	    this.createGroup = bind(this.createGroup, this);
	    this.createConnectionFromObject = bind(this.createConnectionFromObject, this);
	    this.render = bind(this.render, this);
	    this.createNode = bind(this.createNode, this);
	    this.find = bind(this.find, this);
	    this.bindTimelineEvents = bind(this.bindTimelineEvents, this);
	    this.destroy = bind(this.destroy, this);
	    this.clearWorkspace = bind(this.clearWorkspace, this);
	    this.initialize = bind(this.initialize, this);
	    return Nodes.__super__.constructor.apply(this, arguments);
	  }

	  Nodes.prototype.initialize = function(models, options) {
	    var self;
	    this.settings = options.settings;
	    self = this;
	    this.materials = [];
	    this.indexer = new Indexer();
	    this.connections = new Connections([], {
	      indexer: this.indexer
	    });
	    this.parent = options.parent;
	    this.connections.bind("add", function(connection) {
	      return self.trigger("nodeslist:rebuild", self);
	    });
	    this.bind("remove", (function(_this) {
	      return function(node) {
	        var indx;
	        indx = _this.materials.indexOf(node);
	        if (indx !== -1) {
	          _this.materials.splice(indx, 1);
	        }
	        return self.trigger("nodeslist:rebuild", self);
	      };
	    })(this));
	    this.bind("RebuildAllShaders", (function(_this) {
	      return function() {
	        var i, len, node, ref, results;
	        ref = _this.materials;
	        results = [];
	        for (i = 0, len = ref.length; i < len; i++) {
	          node = ref[i];
	          results.push(node.rebuildShader());
	        }
	        return results;
	      };
	    })(this));
	    this.connections.bind("remove", function(connection) {
	      return self.trigger("nodeslist:rebuild", self);
	    });
	    this.bind("add", function(node) {
	      if (node.is_material && node.is_material === true) {
	        this.materials.push(node);
	      }
	      return self.trigger("nodeslist:rebuild", self);
	    });
	    return this.bind("createConnection", (function(_this) {
	      return function(field1, field2) {
	        return _this.connections.create({
	          from_field: field1,
	          to_field: field2
	        });
	      };
	    })(this));
	  };

	  Nodes.prototype.clearWorkspace = function() {
	    this.removeConnections();
	    this.removeAll();
	    $("#webgl-window canvas").remove();
	    this.materials = [];
	    this.indexer.reset();
	    return this;
	  };

	  Nodes.prototype.destroy = function() {
	    this.removeConnections();
	    this.removeAll();
	    delete this.materials;
	    delete this.indexer;
	    return delete this.connections;
	  };

	  Nodes.prototype.bindTimelineEvents = function(timeline) {
	    if (this.timeline) {
	      this.timeline.off("tfieldsRebuild", this.showNodesAnimation);
	      this.timeline.off("startSound", this.startSound);
	      this.timeline.off("stopSound", this.stopSound);
	    }
	    this.timeline = timeline;
	    this.timeline.on("tfieldsRebuild", this.showNodesAnimation);
	    this.timeline.on("startSound", this.startSound);
	    return this.timeline.on("stopSound", this.stopSound);
	  };

	  Nodes.prototype.find = function(node_name) {
	    return this.where({
	      name: node_name
	    });
	  };

	  Nodes.prototype.createNode = function(options) {
	    var n;
	    if ($.type(options) === "string") {
	      options = {
	        type: options
	      };
	    }
	    options.timeline = this.timeline;
	    options.settings = this.settings;
	    options.indexer = this.indexer;
	    options.parent = this.parent;
	    if (!ThreeNodes.Core.nodes.models[options.type]) {
	      console.error("Node type doesn't exists: " + options.type);
	      return false;
	    }
	    n = new ThreeNodes.Core.nodes.models[options.type](options);
	    this.add(n);
	    return n;
	  };

	  Nodes.prototype.render = function() {
	    var buildNodeArrays, evaluateSubGraph, invalidNodes, nid, terminalNodes;
	    invalidNodes = {};
	    terminalNodes = {};
	    buildNodeArrays = function(nodes) {
	      var i, len, node, results;
	      results = [];
	      for (i = 0, len = nodes.length; i < len; i++) {
	        node = nodes[i];
	        if (node.hasOutConnection() === false || node.auto_evaluate || node.delays_output) {
	          terminalNodes[node.attributes["nid"] + "/" + node.attributes["gid"]] = node;
	        }
	        invalidNodes[node.attributes["nid"] + "/" + node.attributes["gid"]] = node;
	        if (node.nodes) {
	          results.push(buildNodeArrays(node.nodes.models));
	        } else {
	          results.push(void 0);
	        }
	      }
	      return results;
	    };
	    buildNodeArrays(this.models);
	    evaluateSubGraph = function(node) {
	      var i, len, upnode, upstreamNodes;
	      upstreamNodes = node.getUpstreamNodes();
	      for (i = 0, len = upstreamNodes.length; i < len; i++) {
	        upnode = upstreamNodes[i];
	        if (invalidNodes[upnode.attributes["nid"] + "/" + upnode.attributes["gid"]] && !upnode.delays_output) {
	          evaluateSubGraph(upnode);
	        }
	      }
	      if (node.dirty || node.auto_evaluate) {
	        node.compute();
	        node.dirty = false;
	        node.fields.setFieldInputUnchanged();
	      }
	      delete invalidNodes[node.attributes["nid"] + "/" + node.attributes["gid"]];
	      return true;
	    };
	    for (nid in terminalNodes) {
	      if (invalidNodes[nid]) {
	        evaluateSubGraph(terminalNodes[nid]);
	      }
	    }
	    return true;
	  };

	  Nodes.prototype.createConnectionFromObject = function(connection) {
	    var c, from, from_gid, from_node, tmp, to, to_gid, to_node;
	    from_gid = connection.from_node_gid ? connection.from_node_gid.toString() : "-1";
	    from_node = this.getNodeByNid(connection.from_node.toString(), from_gid);
	    from = from_node.fields.outputs[connection.from.toString()];
	    to_gid = connection.to_node_gid ? connection.to_node_gid.toString() : "-1";
	    to_node = this.getNodeByNid(connection.to_node.toString(), to_gid);
	    to = to_node.fields.inputs[connection.to.toString()];
	    if (!from || !to) {
	      tmp = from_node;
	      from_node = to_node;
	      to_node = tmp;
	      from = from_node.fields.outputs[connection.to.toString()];
	      to = to_node.fields.inputs[connection.from.toString()];
	    }
	    c = this.connections.create({
	      from_field: from,
	      to_field: to,
	      cid: connection.id
	    });
	    return c;
	  };

	  Nodes.prototype.createGroup = function(model, external_objects) {
	    var c, connection, from, grp, i, len, target_node, to;
	    if (external_objects == null) {
	      external_objects = [];
	    }
	    grp = this.createNode(model);
	    for (i = 0, len = external_objects.length; i < len; i++) {
	      connection = external_objects[i];
	      from = false;
	      to = false;
	      if (connection.to_subfield) {
	        from = this.getNodeByNid(connection.from_node).fields.getField(connection.from, true);
	        target_node = this.getNodeByNid(connection.to_node);
	        if (target_node) {
	          to = target_node.fields.getField(connection.to, false);
	        }
	      } else {
	        target_node = this.getNodeByNid(connection.from_node);
	        if (target_node) {
	          from = target_node.fields.getField(connection.from, true);
	        }
	        to = this.getNodeByNid(connection.to_node).fields.getField(connection.to);
	      }
	      c = this.connections.create({
	        from_field: from,
	        to_field: to
	      });
	    }
	    return grp;
	  };

	  Nodes.prototype.removeGroupsByDefinition = function(def) {
	    var _nodes;
	    _nodes = this.models.concat();
	    return _.each(_nodes, function(node) {
	      if (node.definition && node.definition.gid === def.gid) {
	        return node.remove();
	      }
	    });
	  };

	  Nodes.prototype.renderAllConnections = function() {
	    return this.connections.render();
	  };

	  Nodes.prototype.removeConnection = function(c) {
	    return this.connections.remove(c);
	  };

	  Nodes.prototype.getNodeByNid = function(nid, gid) {
	    var i, len, node, ref, res;
	    if (gid == null) {
	      gid = "-1";
	    }
	    ref = this.models;
	    for (i = 0, len = ref.length; i < len; i++) {
	      node = ref[i];
	      if (node.get("nid").toString() === nid.toString()) {
	        if (gid === "-1" || node.get("gid").toString() === gid.toString()) {
	          return node;
	        }
	      }
	      if (node.nodes) {
	        res = node.nodes.getNodeByNid(nid, gid);
	        if (res) {
	          return res;
	        }
	      }
	    }
	    return false;
	  };

	  Nodes.prototype.showNodesAnimation = function() {
	    return this.invoke("showNodeAnimation");
	  };

	  Nodes.prototype.startSound = function(time) {
	    return this.each(function(node) {
	      if (node.playSound instanceof Function) {
	        return node.playSound(time);
	      }
	    });
	  };

	  Nodes.prototype.stopSound = function() {
	    return this.each(function(node) {
	      if (node.stopSound instanceof Function) {
	        return node.stopSound();
	      }
	    });
	  };

	  Nodes.prototype.removeSelectedNodes = function() {
	    var i, len, node, ref, results;
	    ref = $(".node.ui-selected");
	    results = [];
	    for (i = 0, len = ref.length; i < len; i++) {
	      node = ref[i];
	      results.push($(node).data("object").remove());
	    }
	    return results;
	  };

	  Nodes.prototype.removeAll = function() {
	    var models;
	    $("#tab-attribute").html("");
	    models = this.models.concat();
	    _.invoke(models, "remove");
	    this.reset([]);
	    return true;
	  };

	  Nodes.prototype.removeConnections = function() {
	    return this.connections.removeAll();
	  };

	  return Nodes;

	})(Backbone.Collection);

	module.exports = Nodes;

/***/ },

/***/ 34:
/***/ function(module, exports, __webpack_require__) {

	var Utils;

	Utils = (function() {
	  function Utils() {}

	  Utils.flatArraysAreEquals = function(arr1, arr2) {
	    var i, j, k, len;
	    if (arr1.length !== arr2.length) {
	      return false;
	    }
	    for (i = j = 0, len = arr1.length; j < len; i = ++j) {
	      k = arr1[i];
	      if (arr1[i] !== arr2[i]) {
	        return false;
	      }
	    }
	    return true;
	  };

	  return Utils;

	})();

	module.exports = Utils;

/***/ },

/***/ 43:
/***/ function(module, exports, __webpack_require__) {

	var Indexer;

	Indexer = (function() {
	  function Indexer() {
	    this.uid = 0;
	  }

	  Indexer.prototype.getUID = function(increment) {
	    if (increment == null) {
	      increment = true;
	    }
	    if (increment) {
	      return this.uid += 1;
	    } else {
	      return this.uid;
	    }
	  };

	  Indexer.prototype.reset = function() {
	    return this.uid = 0;
	  };

	  return Indexer;

	})();

	module.exports = Indexer;

/***/ },

/***/ 44:
/***/ function(module, exports, __webpack_require__) {

	var Backbone, GroupDefinition, Utils, _,
	  bind = function(fn, me){ return function(){ return fn.apply(me, arguments); }; },
	  extend = function(child, parent) { for (var key in parent) { if (hasProp.call(parent, key)) child[key] = parent[key]; } function ctor() { this.constructor = child; } ctor.prototype = parent.prototype; child.prototype = new ctor(); child.__super__ = parent.prototype; return child; },
	  hasProp = {}.hasOwnProperty;

	_ = __webpack_require__(2);

	Backbone = __webpack_require__(3);

	Utils = __webpack_require__(34);

	/* GroupDefinition model */

	GroupDefinition = (function(superClass) {
	  extend(GroupDefinition, superClass);

	  function GroupDefinition() {
	    this.fromSelectedNodes = bind(this.fromSelectedNodes, this);
	    this.initialize = bind(this.initialize, this);
	    this.getUID = bind(this.getUID, this);
	    this.sync = bind(this.sync, this);
	    return GroupDefinition.__super__.constructor.apply(this, arguments);
	  }

	  GroupDefinition.prototype.defaults = {
	    nodes: [],
	    connections: [],
	    name: "Group",
	    gid: -1
	  };

	  GroupDefinition.prototype.sync = function() {};

	  GroupDefinition.prototype.getUID = function() {
	    this.internal_uid += 1;
	    return this.internal_uid;
	  };

	  GroupDefinition.prototype.initialize = function(options) {
	    var indexer;
	    GroupDefinition.__super__.initialize.apply(this, arguments);
	    this.internal_uid = 0;
	    indexer = options.indexer;
	    if (this.get("gid") === -1) {
	      this.set("gid", indexer.getUID());
	    }
	    if (options.fromSelectedNodes && options.fromSelectedNodes !== false) {
	      return this.fromSelectedNodes(options.fromSelectedNodes);
	    }
	  };

	  GroupDefinition.prototype.fromSelectedNodes = function(selected_nodes) {
	    var already_exists, connection, field, indx1, indx2, internal_connections, j, k, l, len, len1, len2, node, ref, ref1;
	    internal_connections = [];
	    for (j = 0, len = selected_nodes.length; j < len; j++) {
	      node = selected_nodes[j];
	      ref = node.fields.models;
	      for (k = 0, len1 = ref.length; k < len1; k++) {
	        field = ref[k];
	        ref1 = field.connections;
	        for (l = 0, len2 = ref1.length; l < len2; l++) {
	          connection = ref1[l];
	          indx1 = selected_nodes.indexOf(connection.from_field.node);
	          indx2 = selected_nodes.indexOf(connection.to_field.node);
	          if (indx1 !== -1 && indx2 !== -1) {
	            already_exists = internal_connections.indexOf(connection);
	            if (already_exists === -1) {
	              internal_connections.push(connection);
	            }
	          }
	        }
	      }
	    }
	    this.attributes.nodes = jQuery.map(selected_nodes, function(n, i) {
	      return n.toJSON();
	    });
	    return this.attributes.connections = jQuery.map(internal_connections, function(c, i) {
	      return c.toJSON();
	    });
	  };

	  GroupDefinition.prototype.toJSON = function() {
	    var res;
	    res = {
	      gid: this.get("gid"),
	      name: this.get("name"),
	      connections: this.get("connections"),
	      nodes: this.get("nodes")
	    };
	    return res;
	  };

	  GroupDefinition.prototype.toCode = function() {
	    var res;
	    res = "";
	    return res;
	  };

	  return GroupDefinition;

	})(Backbone.Model);

	module.exports = GroupDefinition;

/***/ },

/***/ 57:
/***/ function(module, exports, __webpack_require__) {

	var Backbone, Connection, Connections,
	  bind = function(fn, me){ return function(){ return fn.apply(me, arguments); }; },
	  extend = function(child, parent) { for (var key in parent) { if (hasProp.call(parent, key)) child[key] = parent[key]; } function ctor() { this.constructor = child; } ctor.prototype = parent.prototype; child.prototype = new ctor(); child.__super__ = parent.prototype; return child; },
	  hasProp = {}.hasOwnProperty;

	Backbone = __webpack_require__(3);

	Connection = __webpack_require__(89);

	Connections = (function(superClass) {
	  extend(Connections, superClass);

	  function Connections() {
	    this.removeAll = bind(this.removeAll, this);
	    this.create = bind(this.create, this);
	    this.render = bind(this.render, this);
	    this.initialize = bind(this.initialize, this);
	    return Connections.__super__.constructor.apply(this, arguments);
	  }

	  Connections.prototype.model = Connection;

	  Connections.prototype.initialize = function(models, options) {
	    this.indexer = options.indexer;
	    this.bind("connection:removed", (function(_this) {
	      return function(c) {
	        return _this.remove(c);
	      };
	    })(this));
	    return Connections.__super__.initialize.apply(this, arguments);
	  };

	  Connections.prototype.render = function() {
	    return this.each(function(c) {
	      return c.render();
	    });
	  };

	  Connections.prototype.create = function(model, options) {
	    if (!options) {
	      options = {};
	    }
	    model.indexer = this.indexer;
	    model = this._prepareModel(model, options);
	    if (!model) {
	      return false;
	    }
	    this.add(model, options);
	    return model;
	  };

	  Connections.prototype.removeAll = function() {
	    return this.remove(this.models);
	  };

	  return Connections;

	})(Backbone.Collection);

	module.exports = Connections;

/***/ },

/***/ 89:
/***/ function(module, exports, __webpack_require__) {

	var Backbone, Connection, Indexer,
	  bind = function(fn, me){ return function(){ return fn.apply(me, arguments); }; },
	  extend = function(child, parent) { for (var key in parent) { if (hasProp.call(parent, key)) child[key] = parent[key]; } function ctor() { this.constructor = child; } ctor.prototype = parent.prototype; child.prototype = new ctor(); child.__super__ = parent.prototype; return child; },
	  hasProp = {}.hasOwnProperty;

	Backbone = __webpack_require__(3);

	Indexer = __webpack_require__(43);

	/* Connection model */

	Connection = (function(superClass) {
	  extend(Connection, superClass);

	  function Connection() {
	    this.switchFieldsIfNeeded = bind(this.switchFieldsIfNeeded, this);
	    this.validate = bind(this.validate, this);
	    this.render = bind(this.render, this);
	    this.remove = bind(this.remove, this);
	    this.initialize = bind(this.initialize, this);
	    this.sync = bind(this.sync, this);
	    return Connection.__super__.constructor.apply(this, arguments);
	  }

	  Connection.STATIC_INDEXER = new Indexer();

	  Connection.prototype.defaults = {
	    "cid": -1
	  };

	  Connection.prototype.sync = function() {};

	  Connection.prototype.initialize = function(options) {
	    var indexer;
	    this.options = options;
	    indexer = options.indexer || Connection.STATIC_INDEXER;
	    if (this.get("cid") === -1) {
	      this.set({
	        "cid": indexer.getUID()
	      });
	    }
	    if (this.isValid()) {
	      this.to_field.removeConnections();
	      this.from_field.addConnection(this);
	      this.to_field.addConnection(this);
	      this.to_field.setValue(this.from_field.get("value"));
	      return this.from_field.node.dirty = true;
	    }
	  };

	  Connection.prototype.remove = function() {
	    this.from_field.unregisterConnection(this);
	    this.to_field.unregisterConnection(this);
	    this.to_field.removeConnections();
	    this.to_field.node.dirty = true;
	    this.to_field.changed = true;
	    delete this.from_field;
	    delete this.to_field;
	    this.trigger("connection:removed", this);
	    this.destroy();
	    return false;
	  };

	  Connection.prototype.render = function() {
	    return this.trigger("render", this, this);
	  };

	  Connection.prototype.validate = function(attrs, options) {
	    this.from_field = attrs.from_field;
	    this.to_field = attrs.to_field;
	    if (!this.from_field || !this.to_field) {
	      return true;
	    }
	    if (this.from_field.get("is_output") === this.to_field.get("is_output")) {
	      return true;
	    }
	    if (this.from_field.node.get('nid') === this.to_field.node.get('nid')) {
	      return true;
	    }
	    this.switchFieldsIfNeeded();
	    return false;
	  };

	  Connection.prototype.switchFieldsIfNeeded = function() {
	    var f_out;
	    if (this.from_field.get("is_output") === false) {
	      f_out = this.to_field;
	      this.to_field = this.from_field;
	      this.from_field = f_out;
	    }
	    return this;
	  };

	  Connection.prototype.toJSON = function() {
	    var res;
	    res = {
	      id: this.get("cid"),
	      from_node: this.from_field.node.get("nid"),
	      from_node_gid: this.from_field.node.get("gid"),
	      from: this.from_field.get("machine_name"),
	      to_node: this.to_field.node.get("nid"),
	      to_node_gid: this.to_field.node.get("gid"),
	      to: this.to_field.get("machine_name")
	    };
	    return res;
	  };

	  return Connection;

	})(Backbone.Model);

	module.exports = Connection;

/***/ }

/******/ })
});

//# sourceMappingURL=ThreeNodes.Core.js.map


text:
<vector
  xmlns:android="http://schemas.android.com/apk/res/android"
  android:width="32dp"
  android:height="32dp"
  android:tint="?attr/colorControlNormal"
  android:viewportHeight="32"
  android:viewportWidth="32">
  <group
    android:translateX="16"
    android:translateY="16">
    <group android:name="ring_outer">
      <path
        android:name="ring_outer_path"
        android:pathData="@string/checkable_radiobutton_ring_outer_path"
        android:strokeColor="@android:color/white"
        android:strokeWidth="2"/>
    </group>
    <group
      android:name="dot_group"
      android:scaleX="0"
      android:scaleY="0">
      <path
        android:name="dot_path"
        android:fillColor="@android:color/white"
        android:pathData="@string/checkable_radiobutton_dot_path"/>
    </group>
  </group>
</vector>

redpajama_set_name: RedPajamaGithub


text:
import _objectWithoutPropertiesLoose from "@babel/runtime/helpers/esm/objectWithoutPropertiesLoose";
import _extends from "@babel/runtime/helpers/esm/extends";
import * as React from 'react';
import PropTypes from 'prop-types';
import clsx from 'clsx';
import { deepmerge } from '@material-ui/utils';
import { unstable_composeClasses as composeClasses } from '@material-ui/unstyled';
import experimentalStyled from '../styles/experimentalStyled';
import useThemeProps from '../styles/useThemeProps';
import { alpha } from '../styles/colorManipulator';
import dividerClasses, { getDividerUtilityClass } from './dividerClasses';
import { jsx as _jsx } from "react/jsx-runtime";

const overridesResolver = (props, styles) => {
  const {
    styleProps
  } = props;
  return deepmerge(_extends({}, styleProps.absolute && styles.absolute, styles[styleProps.variant], styleProps.light && styles.light, styleProps.orientation === 'vertical' && styles.vertical, styleProps.flexItem && styles.flexItem, styleProps.children && styles.withChildren, styleProps.children && styleProps.orientation === 'vertical' && styles.withChildrenVertical, styleProps.textAlign === 'right' && styleProps.orientation !== 'vertical' && styles.textAlignRight, styleProps.textAlign === 'left' && styleProps.orientation !== 'vertical' && styles.textAlignLeft, {
    [`& .${dividerClasses.wrapper}`]: _extends({}, styles.wrapper, styleProps.orientation === 'vertical' && styles.wrapperVertical)
  }), styles.root || {});
};

const useUtilityClasses = styleProps => {
  const {
    absolute,
    children,
    classes,
    flexItem,
    light,
    orientation,
    textAlign,
    variant
  } = styleProps;
  const slots = {
    root: ['root', absolute && 'absolute', variant, light && 'light', orientation === 'vertical' && 'vertical', flexItem && 'flexItem', children && 'withChildren', children && orientation === 'vertical' && 'withChildrenVertical', textAlign === 'right' && orientation !== 'vertical' && 'textAlignRight', textAlign === 'left' && orientation !== 'vertical' && 'textAlignLeft'],
    wrapper: ['wrapper', orientation === 'vertical' && 'wrapperVertical']
  };
  return composeClasses(slots, getDividerUtilityClass, classes);
};

const DividerRoot = experimentalStyled('div', {}, {
  name: 'MuiDivider',
  slot: 'Root',
  overridesResolver
})(({
  theme,
  styleProps
}) => _extends({
  /* Styles applied to the root element. */
  margin: 0,
  // Reset browser default style.
  flexShrink: 0,
  borderWidth: 0,
  borderStyle: 'solid',
  borderColor: theme.palette.divider,
  borderBottomWidth: 'thin'
}, styleProps.absolute && {
  position: 'absolute',
  bottom: 0,
  left: 0,
  width: '100%'
}, styleProps.light && {
  borderColor: alpha(theme.palette.divider, 0.08)
}, styleProps.variant === 'inset' && {
  marginLeft: 72
}, styleProps.variant === 'middle' && styleProps.orientation === 'horizontal' && {
  marginLeft: theme.spacing(2),
  marginRight: theme.spacing(2)
}, styleProps.variant === 'middle' && styleProps.orientation === 'vertical' && {
  marginTop: theme.spacing(1),
  marginBottom: theme.spacing(1)
}, styleProps.orientation === 'vertical' && {
  height: '100%',
  borderBottomWidth: 0,
  borderRightWidth: 'thin'
}, styleProps.flexItem && {
  alignSelf: 'stretch',
  height: 'auto'
}), ({
  theme,
  styleProps
}) => _extends({}, styleProps.children && {
  display: 'flex',
  whiteSpace: 'nowrap',
  textAlign: 'center',
  border: 0,
  '&::before, &::after': {
    position: 'relative',
    width: '100%',
    borderTop: `thin solid ${theme.palette.divider}`,
    top: '50%',
    content: '""',
    transform: 'translateY(50%)'
  }
}), ({
  theme,
  styleProps
}) => _extends({}, styleProps.children && styleProps.orientation === 'vertical' && {
  flexDirection: 'column',
  '&::before, &::after': {
    height: '100%',
    top: '0%',
    left: '50%',
    borderTop: 0,
    borderLeft: `thin solid ${theme.palette.divider}`,
    transform: 'translateX(0%)'
  }
}), ({
  styleProps
}) => _extends({}, styleProps.textAlign === 'right' && styleProps.orientation !== 'vertical' && {
  '&::before': {
    width: '90%'
  },
  '&::after': {
    width: '10%'
  }
}, styleProps.textAlign === 'left' && styleProps.orientation !== 'vertical' && {
  '&::before': {
    width: '10%'
  },
  '&::after': {
    width: '90%'
  }
}));
const DividerWrapper = experimentalStyled('span', {}, {
  name: 'MuiDivider',
  slot: 'Wrapper'
})(({
  theme,
  styleProps
}) => _extends({
  display: 'inline-block',
  paddingLeft: theme.spacing(1.2),
  paddingRight: theme.spacing(1.2)
}, styleProps.orientation === 'vertical' && {
  paddingTop: theme.spacing(1.2),
  paddingBottom: theme.spacing(1.2)
}));
const Divider = /*#__PURE__*/React.forwardRef(function Divider(inProps, ref) {
  const props = useThemeProps({
    props: inProps,
    name: 'MuiDivider'
  });

  const {
    absolute = false,
    children,
    className,
    component = children ? 'div' : 'hr',
    flexItem = false,
    light = false,
    orientation = 'horizontal',
    role = component !== 'hr' ? 'separator' : undefined,
    textAlign = 'center',
    variant = 'fullWidth'
  } = props,
        other = _objectWithoutPropertiesLoose(props, ["absolute", "children", "className", "component", "flexItem", "light", "orientation", "role", "textAlign", "variant"]);

  const styleProps = _extends({}, props, {
    absolute,
    component,
    flexItem,
    light,
    orientation,
    role,
    textAlign,
    variant
  });

  const classes = useUtilityClasses(styleProps);
  return /*#__PURE__*/_jsx(DividerRoot, _extends({
    as: component,
    className: clsx(classes.root, className),
    role: role,
    ref: ref,
    styleProps: styleProps
  }, other, {
    children: children ? /*#__PURE__*/_jsx(DividerWrapper, {
      className: classes.wrapper,
      styleProps: styleProps,
      children: children
    }) : null
  }));
});
process.env.NODE_ENV !== "production" ? Divider.propTypes
/* remove-proptypes */
= {
  // ----------------------------- Warning --------------------------------
  // | These PropTypes are generated from the TypeScript type definitions |
  // |     To update them edit the d.ts file and run "yarn proptypes"     |
  // ----------------------------------------------------------------------

  /**
   * Absolutely position the element.
   * @default false
   */
  absolute: PropTypes.bool,

  /**
   * The content of the component.
   */
  children: PropTypes.node,

  /**
   * Override or extend the styles applied to the component.
   */
  classes: PropTypes.object,

  /**
   * @ignore
   */
  className: PropTypes.string,

  /**
   * The component used for the root node.
   * Either a string to use a HTML element or a component.
   */
  component: PropTypes.elementType,

  /**
   * If `true`, a vertical divider will have the correct height when used in flex container.
   * (By default, a vertical divider will have a calculated height of `0px` if it is the child of a flex container.)
   * @default false
   */
  flexItem: PropTypes.bool,

  /**
   * If `true`, the divider will have a lighter color.
   * @default false
   */
  light: PropTypes.bool,

  /**
   * The component orientation.
   * @default 'horizontal'
   */
  orientation: PropTypes.oneOf(['horizontal', 'vertical']),

  /**
   * @ignore
   */
  role: PropTypes.string,

  /**
   * The system prop that allows defining system overrides as well as additional CSS styles.
   */
  sx: PropTypes.object,

  /**
   * The text alignment.
   * @default 'center'
   */
  textAlign: PropTypes.oneOf(['center', 'left', 'right']),

  /**
   * The variant to use.
   * @default 'fullWidth'
   */
  variant: PropTypes
  /* @typescript-to-proptypes-ignore */
  .oneOfType([PropTypes.oneOf(['fullWidth', 'inset', 'middle']), PropTypes.string])
} : void 0;
export default Divider;


text:
.. File generated by /hepuser/crlb/Git/cloudscheduler/utilities/cli_doc_to_rst - DO NOT EDIT
..
.. To modify the contents of this file:
..   1. edit the man page file(s) ".../cloudscheduler/cli/man/csv2_metadata_restore.1"
..   2. run the utility ".../cloudscheduler/utilities/cli_doc_to_rst"
..

man(1) page: cloudscheduler metadata restore
============================================


text:
var fs = require('fs');
var path = require('path');

var ConfigError = require(path.resolve(`${__dirname}/Error`));

module.exports = function (logger, options) {

    return new Promise((resolve, reject) => {

        if (!options.configPath) {
            return reject(
                new ConfigError(ConfigError.CODES.NO_CONFIG_PATH)
            );
        }

        var configPath = process.env.CONFIG ? process.env.CONFIG : options.configPath;

        if (!fs.existsSync(configPath)) {
            logger.debug(`fs: config file not found ${configPath}`);

            if (options.useDefaultConfig) {
                logger.debug(`useDefaultConfig = true, using default config`);
                return resolve({});
            }

            return reject(
                ConfigError.createError(ConfigError.CODES.NO_CONFIG, {path: configPath})
            );
        }

        logger.info(`fs: found config ${configPath}`);

        resolve(require(configPath));
    });

};


text:
Interface and Helper Functions to implement Maschine Learning Algorithms for an automated time-based processing.
## Puropose
The Libary provides an abstract class called "algorithm". By inheriting from this class it is possible to build algorithms which can be processed in a so called processing engine triggered by events (e.g. at a certain time). This gets easily possible because Algorithms derived from the abstract algorithm class implement a particular interface which can be accessed by the engine.

The interface provides

- A method "Setup" which is used to prepare algorithms in terms of training, parameter estimation, etc.
- A method "Run" which is used to process data and write results to an output

In addition Attributes are available which characterize properties as

- Input (e.g. a timesseries)
- Output (e.g. a single number such as the mean of the provided input series)
- Parameter (e.g. a configuration parameter for a particular algorithm

## Example

A basic implementation example is provided within the code and can be executed with the unit test projet.

```
namespace ProcessingEngine.Algorithm.Sample
{
	[PEAlgorithm("Sample")]
	[Serializable]
	public class SampleAlgorithm:IAlgorithm
	{
		[Parameter("Faktor")]
		public int Parameter { get; set; }

		[Input("Input")]
		public int Input { get; set; }

		[Output("Output")]
		public int Output { get; set; }

		public void Run()
		{
			Output = Input * Parameter;
		}

		public void Setup()
		{
			throw new NotNecessaryException("This Algorithm doesn't need a Setup!");
		}
	}
}
```
The implementation has one parameter which is used as a factor multyplied with the input by running "Run". We have one input property and one output property while within the run method the input property is multyplied with the factor and then assigned to the output. All properties are charaterized via a name (e.g. Result for the OutputAttribute). The method "Setup" is not implemented in this example case.


text:
<?xml version="1.0" ?>
<INPUT>

	<MEDALS>
		<MEDAL Id="1" MEDAL_THRESHOLD="52000" TYPE="Gold"/>
		<MEDAL Id="2" MEDAL_THRESHOLD="79000" TYPE="Silver"/>
		<MEDAL Id="3" MEDAL_THRESHOLD="102000" TYPE="Bronze"/>

	</MEDALS>

	<SpeedSettings Default="18" Max="150" Min="0"/>

	<PenaltySettings SpeedLost="0.1" TimeLost="15"/>

	<PROBLEM_SET>
		<PROBLEM_SUBSET>
			<TARGET TYPE="String">
				<ContentSettings string="0.6"/>
			</TARGET>
			<QUESTION INDEX="1">
				<Content TYPE="Fraction">
					<ContentSettings denominator="4" numerator="3"/>
				</Content>
				<Content TYPE="Fraction">
					<ContentSettings denominator="100" numerator="92"/>
				</Content>
				<Answer VALUE="0"/>
			</QUESTION>
			<QUESTION INDEX="2">
				<Content TYPE="Fraction">
					<ContentSettings denominator="8" numerator="6"/>
				</Content>
				<Content TYPE="Fraction">
					<ContentSettings denominator="12" numerator="11"/>
				</Content>
				<Answer VALUE="0"/>
			</QUESTION>
			<QUESTION INDEX="3">
				<Content TYPE="Fraction">
					<ContentSettings denominator="4" numerator="0"/>
				</Content>
				<Content TYPE="Fraction">
					<ContentSettings denominator="1000" numerator="645"/>
				</Content>
				<Answer VALUE="1"/>
			</QUESTION>
		</PROBLEM_SUBSET>
		<PROBLEM_SUBSET>
			<TARGET TYPE="String">
				<ContentSettings string="0.2"/>
			</TARGET>
			<QUESTION INDEX="4">
				<Content TYPE="Fraction">
					<ContentSettings denominator="3" numerator="0"/>
				</Content>
				<Content TYPE="Fraction">
					<ContentSettings denominator="1000" numerator="719"/>
				</Content>
				<Answer VALUE="1"/>
			</QUESTION>
			<QUESTION INDEX="5">
				<Content TYPE="Fraction">
					<ContentSettings denominator="4" numerator="3"/>
				</Content>
				<Content TYPE="Fraction">
					<ContentSettings denominator="5" numerator="4"/>
				</Content>
				<Answer VALUE="0"/>
			</QUESTION>
			<QUESTION INDEX="6">
				<Content TYPE="Fraction">
					<ContentSettings denominator="12" numerator="1"/>
				</Content>
				<Content TYPE="Fraction">
					<ContentSettings denominator="10" numerator="7"/>
				</Content>
				<Answer VALUE="1"/>
			</QUESTION>
		</PROBLEM_SUBSET>
		<PROBLEM_SUBSET>
			<TARGET TYPE="String">
				<ContentSettings string="0.5"/>
			</TARGET>
			<QUESTION INDEX="7">
				<Content TYPE="Fraction">
					<ContentSettings denominator="1000" numerator="788"/>
				</Content>
				<Content TYPE="Fraction">
					<ContentSettings denominator="100" numerator="86"/>
				</Content>
				<Answer VALUE="0"/>
			</QUESTION>
			<QUESTION INDEX="8">
				<Content TYPE="Fraction">
					<ContentSettings denominator="4" numerator="0"/>
				</Content>
				<Content TYPE="Fraction">
					<ContentSettings denominator="8" numerator="7"/>
				</Content>
				<Answer VALUE="1"/>
			</QUESTION>
			<QUESTION INDEX="9">
				<Content TYPE="Fraction">
					<ContentSettings denominator="8" numerator="3"/>
				</Content>
				<Content TYPE="Fraction">
					<ContentSettings denominator="100" numerator="45"/>
				</Content>
				<Answer VALUE="2"/>
			</QUESTION>
		</PROBLEM_SUBSET>
		<PROBLEM_SUBSET>
			<TARGET TYPE="String">
				<ContentSettings string="0.5"/>
			</TARGET>
			<QUESTION INDEX="10">
				<Content TYPE="Fraction">
					<ContentSettings denominator="2" numerator="0"/>
				</Content>
				<Content TYPE="Fraction">
					<ContentSettings denominator="12" numerator="8"/>
				</Content>
				<Answer VALUE="1"/>
			</QUESTION>
			<QUESTION INDEX="11">
				<Content TYPE="Fraction">
					<ContentSettings denominator="100" numerator="57"/>
				</Content>
				<Content TYPE="Fraction">
					<ContentSettings denominator="5" numerator="4"/>
				</Content>
				<Answer VALUE="0"/>
			</QUESTION>
			<QUESTION INDEX="12">
				<Content TYPE="Fraction">
					<ContentSettings denominator="12" numerator="2"/>
				</Content>
				<Content TYPE="Fraction">
					<ContentSettings denominator="8" numerator="7"/>
				</Content>
				<Answer VALUE="1"/>
			</QUESTION>
		</PROBLEM_SUBSET>
		<PROBLEM_SUBSET>
			<TARGET TYPE="String">
				<ContentSettings string="0.429"/>
			</TARGET>
			<QUESTION INDEX="13">
				<Content TYPE="Fraction">
					<ContentSettings denominator="100" numerator="46"/>
				</Content>
				<Content TYPE="Fraction">
					<ContentSettings denominator="5" numerator="3"/>
				</Content>
				<Answer VALUE="0"/>
			</QUESTION>
			<QUESTION INDEX="14">
				<Content TYPE="Fraction">
					<ContentSettings denominator="2" numerator="0"/>
				</Content>
				<Content TYPE="Fraction">
					<ContentSettings denominator="5" numerator="1"/>
				</Content>
				<Answer VALUE="2"/>
			</QUESTION>
			<QUESTION INDEX="15">
				<Content TYPE="Fraction">
					<ContentSettings denominator="1000" numerator="419"/>
				</Content>
				<Content TYPE="Fraction">
					<ContentSettings denominator="100" numerator="90"/>
				</Content>
				<Answer VALUE="1"/>
			</QUESTION>
		</PROBLEM_SUBSET>
		<PROBLEM_SUBSET>
			<TARGET TYPE="String">
				<ContentSettings string="0.375"/>
			</TARGET>
			<QUESTION INDEX="16">
				<Content TYPE="Fraction">
					<ContentSettings denominator="12" numerator="1"/>
				</Content>
				<Content TYPE="Fraction">
					<ContentSettings denominator="100" numerator="78"/>
				</Content>
				<Answer VALUE="1"/>
			</QUESTION>
			<QUESTION INDEX="17">
				<Content TYPE="Fraction">
					<ContentSettings denominator="4" numerator="0"/>
				</Content>
				<Content TYPE="Fraction">
					<ContentSettings denominator="8" numerator="4"/>
				</Content>
				<Answer VALUE="1"/>
			</QUESTION>
			<QUESTION INDEX="18">
				<Content TYPE="Fraction">
					<ContentSettings denominator="8" numerator="1"/>
				</Content>
				<Content TYPE="Fraction">
					<ContentSettings denominator="3" numerator="1"/>
				</Content>
				<Answer VALUE="2"/>
			</QUESTION>
		</PROBLEM_SUBSET>

	</PROBLEM_SET>

</INPUT>


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

using Microsoft.Azure.Commands.Common.Authentication;
using Microsoft.Azure.Commands.Common.Authentication.Models;

namespace Microsoft.Azure.Commands.ResourceManager.Cmdlets.Implementation
{
    using Common;
    using Microsoft.Azure.Commands.ResourceManager.Cmdlets.Components;
    using Microsoft.Azure.Commands.ResourceManager.Cmdlets.Entities.ErrorResponses;
    using Microsoft.Azure.Commands.ResourceManager.Cmdlets.Entities.Resources;
    using Microsoft.Azure.Commands.ResourceManager.Cmdlets.Extensions;
    using Microsoft.Azure.Commands.ResourceManager.Cmdlets.RestClients;
    using Newtonsoft.Json.Linq;
    using System;
    using System.Collections.Generic;
    using Microsoft.Azure.Commands.ResourceManager.Cmdlets.SdkClient;
    using System.Threading;
    using System.Linq;
    using System.Management.Automation;
    using System.Runtime.ExceptionServices;
    using System.Threading.Tasks;

    /// <summary>
    /// The base class for resource manager cmdlets.
    /// </summary>
    public abstract class ResourceManagerCmdletBase : AzureRMCmdlet
    {
        /// <summary>
        /// The cancellation source.
        /// </summary>
        private CancellationTokenSource cancellationSource;

        /// <summary>
        /// Gets the cancellation source.
        /// </summary>
        protected CancellationToken? CancellationToken
        {
            get
            {
                return this.cancellationSource == null ? null : (CancellationToken?)this.cancellationSource.Token;
            }
        }

        /// <summary>
        /// Field that holds the resource client instance
        /// </summary>
        private ResourceManagerSdkClient resourceManagerSdkClient;

        /// <summary>
        /// Field that holds the subscripotions client instance
        /// </summary>
        private SubscriptionSdkClient subscriptionSdkClient;

        /// <summary>
        /// Gets or sets the API version.
        /// </summary>
        [Parameter(Mandatory = false, HelpMessage = "When set, indicates the version of the resource provider API to use. If not specified, the API version is automatically determined as the latest available.")]
        [ValidateNotNullOrEmpty]
        public string ApiVersion { get; set; }

        /// <summary>
        /// Gets or sets the switch that indicates if pre-release API version should be considered.
        /// </summary>
        [Parameter(Mandatory = false, HelpMessage = "When set, indicates that the cmdlet should use pre-release API versions when automatically determining which version to use.")]
        public SwitchParameter Pre { get; set; }

        /// <summary>
        /// The <c>BeginProcessing</c> method.
        /// </summary>
        protected override void BeginProcessing()
        {
            try
            {
                if (this.cancellationSource == null)
                {
                    this.cancellationSource = new CancellationTokenSource();
                }

                base.BeginProcessing();
                this.OnBeginProcessing();
            }
            catch (Exception ex)
            {
                if (ex.IsFatal())
                {
                    throw;
                }

                var capturedException = ExceptionDispatchInfo.Capture(ex);
                this.HandleException(capturedException: capturedException);
            }
        }

        /// <summary>
        /// The <c>StopProcessing</c> method.
        /// </summary>
        protected override void StopProcessing()
        {
            try
            {
                if (this.cancellationSource != null && !this.cancellationSource.IsCancellationRequested)
                {
                    this.cancellationSource.Cancel();
                }

                this.OnStopProcessing();
                base.StopProcessing();
            }
            catch (Exception ex)
            {
                if (ex.IsFatal())
                {
                    throw;
                }

                var capturedException = ExceptionDispatchInfo.Capture(ex);
                this.HandleException(capturedException: capturedException);
            }
            finally
            {
                this.DisposeOfCancellationSource();
            }
        }

        /// <summary>
        /// The <c>EndProcessing</c> method.
        /// </summary>
        protected override void EndProcessing()
        {
            try
            {
                this.OnEndProcessing();
                base.EndProcessing();
            }
            catch (Exception ex)
            {
                if (ex.IsFatal())
                {
                    throw;
                }

                var capturedException = ExceptionDispatchInfo.Capture(ex);
                this.HandleException(capturedException: capturedException);
            }
            finally
            {
                this.DisposeOfCancellationSource();
            }
        }

        /// <summary>
        /// The <c>ProcessRecord</c> method.
        /// </summary>
        public override void ExecuteCmdlet()
        {
            try
            {
                base.ExecuteCmdlet();
                this.OnProcessRecord();
            }
            catch (Exception ex)
            {
                if (ex.IsFatal())
                {
                    throw;
                }

                var capturedException = ExceptionDispatchInfo.Capture(ex);
                this.HandleException(capturedException: capturedException);
            }
        }

        /// <summary>
        /// When overridden, allows child classes to be called when the <c>ProcessRecord</c> method is invoked.
        /// </summary>
        protected virtual void OnProcessRecord()
        {
            // no-op
        }

        /// <summary>
        /// When overridden, allows child classes to be called when the <c>EndProcessing</c> method is invoked.
        /// </summary>
        protected virtual void OnEndProcessing()
        {
            // no-op
        }

        /// <summary>
        /// When overridden, allows child classes to be called when the <c>BeginProcessing</c> method is invoked.
        /// </summary>
        protected virtual void OnBeginProcessing()
        {
            // no-op
        }

        /// <summary>
        /// When overridden, allows child classes to be called when the <c>StopProcessing</c> method is invoked.
        /// </summary>
        protected virtual void OnStopProcessing()
        {
            // no-op
        }

        /// <summary>
        /// Determines the API version.
        /// </summary>
        /// <param name="resourceId">The resource Id.</param>
        /// <param name="pre">When specified, indicates if pre-release API versions should be considered.</param>
        protected Task<string> DetermineApiVersion(string resourceId, bool? pre = null)
        {
            return string.IsNullOrWhiteSpace(this.ApiVersion)
                ? ApiVersionHelper.DetermineApiVersion(
                    context: DefaultContext,
                    resourceId: resourceId,
                    cancellationToken: this.CancellationToken.Value,
                    pre: pre ?? this.Pre,
                    cmdletHeaderValues: this.GetCmdletHeaders())
                : Task.FromResult(this.ApiVersion);
        }

        /// <summary>
        /// Determines the API version.
        /// </summary>
        /// <param name="providerNamespace">The provider namespace.</param>
        /// <param name="resourceType">The resource type.</param>
        /// <param name="pre">When specified, indicates if pre-release API versions should be considered.</param>
        protected Task<string> DetermineApiVersion(string providerNamespace, string resourceType, bool? pre = null)
        {
            return string.IsNullOrWhiteSpace(this.ApiVersion)
                ? ApiVersionHelper.DetermineApiVersion(
                    DefaultContext,
                    providerNamespace: providerNamespace,
                    resourceType: resourceType,
                    cancellationToken: this.CancellationToken.Value,
                    pre: pre ?? this.Pre,
                    cmdletHeaderValues: this.GetCmdletHeaders())
                : Task.FromResult(this.ApiVersion);
        }

        /// <summary>
        /// Gets a new instance of the <see cref="ResourceManagerRestRestClient"/>.
        /// </summary>
        public ResourceManagerRestRestClient GetResourcesClient()
        {
            var endpoint = DefaultContext.Environment.GetEndpoint(AzureEnvironment.Endpoint.ResourceManager);

            if (string.IsNullOrWhiteSpace(endpoint))
            {
                throw new ApplicationException(
                    "The endpoint for the Azure Resource Manager service is not set. Please report this issue via GitHub or contact Microsoft customer support.");
            }

            var endpointUri = new Uri(endpoint, UriKind.Absolute);

            return new ResourceManagerRestRestClient(
                endpointUri: endpointUri,
                httpClientHelper: HttpClientHelperFactory.Instance
                .CreateHttpClientHelper(
                        credentials: AzureSession.AuthenticationFactory.GetSubscriptionCloudCredentials(DefaultContext),
                        headerValues: AzureSession.ClientFactory.UserAgents,
                        cmdletHeaderValues: this.GetCmdletHeaders()));
        }

        /// <summary>
        /// Gets or sets the resource manager sdk client
        /// </summary>
        public ResourceManagerSdkClient ResourceManagerSdkClient
        {
            get
            {
                if (this.resourceManagerSdkClient == null)
                {
                    this.resourceManagerSdkClient = new ResourceManagerSdkClient(DefaultContext)
                    {
                        VerboseLogger = WriteVerboseWithTimestamp,
                        ErrorLogger = WriteErrorWithTimestamp,
                        WarningLogger = WriteWarningWithTimestamp
                    };
                }
                return this.resourceManagerSdkClient;
            }

            set { this.resourceManagerSdkClient = value; }
        }

        /// <summary>
        /// Gets or sets the subscription sdk client
        /// </summary>
        public SubscriptionSdkClient SubscriptionSdkClient
        {
            get
            {
                if (this.subscriptionSdkClient == null)
                {
                    this.subscriptionSdkClient = new SubscriptionSdkClient(DefaultContext)
                    {
                        VerboseLogger = WriteVerboseWithTimestamp,
                        ErrorLogger = WriteErrorWithTimestamp,
                        WarningLogger = WriteWarningWithTimestamp
                    };
                }
                return this.subscriptionSdkClient;
            }

            set { this.subscriptionSdkClient = value; }
        }

        private Dictionary<string, string> GetCmdletHeaders()
        {
            return new Dictionary<string, string>
            {
                {"ParameterSetName", this.ParameterSetName },
                {"CommandName", this.CommandRuntime.ToString() }
            };
        }

        /// <summary>
        /// Writes the object
        /// </summary>
        /// <param name="resultString">The result as a string</param>
        protected void TryConvertAndWriteObject(string resultString)
        {
            JToken resultJToken;
            if (resultString.TryConvertTo<JToken>(out resultJToken))
            {
                this.WriteObject(resultJToken);
            }
            else
            {
                this.WriteObject(resultString);
            }
        }

        /// <summary>
        /// Writes the object
        /// </summary>
        /// <param name="resultString">The result as a string</param>
        protected void TryConvertToResourceAndWriteObject(string resultString)
        {
            Resource<JToken> resultResource;
            if (resultString.TryConvertTo<Resource<JToken>>(out resultResource))
            {
                this.WriteObject(resultResource.ToPsObject());
            }
            else
            {
                this.WriteObject(resultString);
            }
        }

        /// <summary>
        /// Writes a <see cref="JToken"/> object as a <see cref="PSObject"/>.
        /// </summary>
        /// <param name="result">The result of the action.</param>
        protected void WriteObject(JToken result)
        {
            this.WriteObject(sendToPipeline: result.ToPsObject(), enumerateCollection: true);
        }

        /// <summary>
        /// Gets a new instance of the long running operation helper.
        /// </summary>
        /// <param name="activityName">The name of the action.</param>
        /// <param name="isResourceCreateOrUpdate">When set to true, indicates that the tracker will be used to track a resource creation request.</param>
        internal LongRunningOperationHelper GetLongRunningOperationTracker(string activityName, bool isResourceCreateOrUpdate)
        {
            return new LongRunningOperationHelper(
                activityName: activityName,
                resourcesClientFactory: () => this.GetResourcesClient(),
                writeProgressAction: progress => this.WriteProgress(progress),
                cancellationToken: this.CancellationToken.Value,
                isResourceCreateOrUpdate: isResourceCreateOrUpdate);
        }

        /// <summary>
        /// Disposes of the <see cref="CancellationTokenSource"/>.
        /// </summary>
        private void DisposeOfCancellationSource()
        {
            if (this.cancellationSource != null)
            {
                if (!this.cancellationSource.IsCancellationRequested)
                {
                    this.cancellationSource.Cancel();
                }

                this.cancellationSource.Dispose();
                this.cancellationSource = null;
            }
        }

        /// <summary>
        /// Provides specialized exception handling.
        /// </summary>
        /// <param name="capturedException">The captured exception</param>
        private void HandleException(ExceptionDispatchInfo capturedException)
        {
            try
            {
                var errorResponseException = capturedException.SourceException as ErrorResponseMessageException;
                if (errorResponseException != null)
                {
                    this.ThrowTerminatingError(errorResponseException.ToErrorRecord());
                }

                var aggregateException = capturedException.SourceException as AggregateException;
                if (aggregateException != null)
                {
                    if (aggregateException.InnerExceptions.CoalesceEnumerable().Any() &&
                        aggregateException.InnerExceptions.Count == 1)
                    {
                        errorResponseException = aggregateException.InnerExceptions.Single() as ErrorResponseMessageException;
                        if (errorResponseException != null)
                        {
                            this.ThrowTerminatingError(errorResponseException.ToErrorRecord());
                        }

                        this.ThrowTerminatingError(aggregateException.InnerExceptions.Single().ToErrorRecord());
                    }
                    else
                    {
                        this.ThrowTerminatingError(aggregateException.ToErrorRecord());
                    }
                }

                capturedException.Throw();
            }
            finally
            {
                this.DisposeOfCancellationSource();
            }
        }

        /// <summary>
        /// Determines the parameter set name.
        /// </summary>
        public virtual string DetermineParameterSetName()
        {
            return this.ParameterSetName;
        }
    }
}


text:
namespace ReportGenerator.Tests.TestFiles.Project
{
    public class CodeContract_Target : CodeContract_Interface
    {
        public int Calculate(int value)
        {
            if (value < 0)
            {
                return 0;
            }
            else
            {
                return 1;
            }
        }
    }
}


text:
#if defined ROMS_HEADER
# include ROMS_HEADER
#else
   CPPDEFS - Choose an appropriate ROMS application.
#endif

/*
**  Include internal CPP definitions.
*/

#include "globaldefs.h"


text:
module Sde
  class BlueprintsManufacturingMaterialsImporter
    attr_reader :file

    def initialize(file)
      @file = file
    end

    def import
      entries = YAML.safe_load(File.read(file))

      entries.each_pair do |key, hash|
        eve_blueprint = Eve::Blueprint.find_by!(type_id: key)

        eve_blueprint.transaction do
          eve_blueprint.blueprint_manufacturing_materials.destroy_all

          manufacturing_materials = hash.dig("activities", "manufacturing", "materials")

          manufacturing_materials&.each do |manufacturing_material|
            Eve::BlueprintManufacturingMaterial.create!(blueprint_id: eve_blueprint.type_id,
              quantity: manufacturing_material["quantity"],
              type_id: manufacturing_material["typeID"])
          end

          eve_blueprint.save!
        end
      end
    end
  end
end


text:
package griffon.plugins.tasks;

/**
 * @author Eike Kettner
 * @since 20.07.11 11:31
 */
public interface TaskListenerSupport {
    /**
     * Add a {@link TaskListener} that receives events for all tasks executed.
     *
     * @param listener
     */
    void addListener(TaskListener listener);

    void removeListener(TaskListener listener);

    /**
     * Add a {@link TaskListener} that will only receive events for tasks with
     * the specified id.
     *
     * @param taskId
     * @param listener
     */
    void addListener(String taskId, TaskListener listener);

    void removeListener(String taskId, TaskListener listener);

    void fireStateChanged(ChangeEvent<Task.State> e);

    void fireProgressChanged(ChangeEvent<Integer> e);

    void firePhaseChanged(ChangeEvent<String> e);
}


text:
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<meta http-equiv="Content-Type" content="text/html;charset=UTF-8">
<title>MagickCore: random.c File Reference</title>
<link href="doxygen.css" rel="stylesheet" type="text/css">
<link href="tabs.css" rel="stylesheet" type="text/css">

magick

random.c File Reference

#include "magick/studio.h"

#include "magick/exception.h"

#include "magick/exception-private.h"

#include "magick/memory_.h"

#include "magick/semaphore.h"

#include "magick/random_.h"

#include "magick/resource_.h"

#include "magick/signature.h"

#include "magick/string_.h"

#include "magick/utility.h"

Data Structures

struct  	_RandomInfo

Typedefs

typedef struct _RandomInfo 	RandomInfo

Functions

static void 	InitializeRandomReservoir (void)

MagickExport void 	DestroyRandomReservoir (void)

MagickExport void 	DistillRandomEvent (const unsigned char *event, const size_t length)

MagickExport void 	GetRandomKey (unsigned char *key, const size_t length)

MagickExport double 	GetRandomValue (void)

MagickExport void 	SeedRandomReservoir (const unsigned long seed)

Variables

static RandomInfo 	random_info = { ~0U, ~0U, ~0U, ~0U }

static SemaphoreInfo * 	random_semaphore = (SemaphoreInfo *) NULL

static SignatureInfo * 	reservoir = (SignatureInfo *) NULL

static unsigned long * 	roulette = (unsigned long *) NULL

Typedef Documentation

          typedef struct _RandomInfo  RandomInfo

Function Documentation

          MagickExport void DestroyRandomReservoir
          (
          void

           )

          MagickExport void DistillRandomEvent
          (
          const unsigned char *
           event,

          const size_t
           length

          )

          MagickExport void GetRandomKey
          (
          unsigned char *
           key,

          const size_t
           length

          )

          MagickExport double GetRandomValue
          (
          void

           )

          static void InitializeRandomReservoir
          (
          void

           )
           [static]

          MagickExport void SeedRandomReservoir
          (
          const unsigned long
           seed
           )

Variable Documentation

          RandomInfo random_info = { ~0U, ~0U, ~0U, ~0U } [static]

          SemaphoreInfo* random_semaphore = (SemaphoreInfo *) NULL [static]

          SignatureInfo* reservoir = (SignatureInfo *) NULL [static]

          unsigned long* roulette = (unsigned long *) NULL [static]

<address style="text-align: right;">Generated on Sat Jan 26 14:50:30 2008 for MagickCore by

 1.5.4 </address>


text:
package com.amazonaws.services.ec2.model;

import java.io.Serializable;
import javax.annotation.Generated;

/**
 *

 * Describes the placement for a Scheduled Instance.
 *

 *
 * @see AWS
 *      API Documentation
 */
@Generated("com.amazonaws:aws-java-sdk-code-generator")
public class ScheduledInstancesPlacement implements Serializable, Cloneable {

    /**
     *

     * The Availability Zone.
     *

     */
    private String availabilityZone;
    /**
     *

     * The name of the placement group.
     *

     */
    private String groupName;

    /**
     *

     * The Availability Zone.
     *

     *
     * @param availabilityZone
     *        The Availability Zone.
     */

    public void setAvailabilityZone(String availabilityZone) {
        this.availabilityZone = availabilityZone;
    }

    /**
     *

     * The Availability Zone.
     *

     *
     * @return The Availability Zone.
     */

    public String getAvailabilityZone() {
        return this.availabilityZone;
    }

    /**
     *

     * The Availability Zone.
     *

     *
     * @param availabilityZone
     *        The Availability Zone.
     * @return Returns a reference to this object so that method calls can be chained together.
     */

    public ScheduledInstancesPlacement withAvailabilityZone(String availabilityZone) {
        setAvailabilityZone(availabilityZone);
        return this;
    }

    /**
     *

     * The name of the placement group.
     *

     *
     * @param groupName
     *        The name of the placement group.
     */

    public void setGroupName(String groupName) {
        this.groupName = groupName;
    }

    /**
     *

     * The name of the placement group.
     *

     *
     * @return The name of the placement group.
     */

    public String getGroupName() {
        return this.groupName;
    }

    /**
     *

     * The name of the placement group.
     *

     *
     * @param groupName
     *        The name of the placement group.
     * @return Returns a reference to this object so that method calls can be chained together.
     */

    public ScheduledInstancesPlacement withGroupName(String groupName) {
        setGroupName(groupName);
        return this;
    }

    /**
     * Returns a string representation of this object. This is useful for testing and debugging. Sensitive data will be
     * redacted from this string using a placeholder value.
     *
     * @return A string representation of this object.
     *
     * @see java.lang.Object#toString()
     */
    @Override
    public String toString() {
        StringBuilder sb = new StringBuilder();
        sb.append("{");
        if (getAvailabilityZone() != null)
            sb.append("AvailabilityZone: ").append(getAvailabilityZone()).append(",");
        if (getGroupName() != null)
            sb.append("GroupName: ").append(getGroupName());
        sb.append("}");
        return sb.toString();
    }

    @Override
    public boolean equals(Object obj) {
        if (this == obj)
            return true;
        if (obj == null)
            return false;

        if (obj instanceof ScheduledInstancesPlacement == false)
            return false;
        ScheduledInstancesPlacement other = (ScheduledInstancesPlacement) obj;
        if (other.getAvailabilityZone() == null ^ this.getAvailabilityZone() == null)
            return false;
        if (other.getAvailabilityZone() != null && other.getAvailabilityZone().equals(this.getAvailabilityZone()) == false)
            return false;
        if (other.getGroupName() == null ^ this.getGroupName() == null)
            return false;
        if (other.getGroupName() != null && other.getGroupName().equals(this.getGroupName()) == false)
            return false;
        return true;
    }

    @Override
    public int hashCode() {
        final int prime = 31;
        int hashCode = 1;

        hashCode = prime * hashCode + ((getAvailabilityZone() == null) ? 0 : getAvailabilityZone().hashCode());
        hashCode = prime * hashCode + ((getGroupName() == null) ? 0 : getGroupName().hashCode());
        return hashCode;
    }

    @Override
    public ScheduledInstancesPlacement clone() {
        try {
            return (ScheduledInstancesPlacement) super.clone();
        } catch (CloneNotSupportedException e) {
            throw new IllegalStateException("Got a CloneNotSupportedException from Object.clone() " + "even though we're Cloneable!", e);
        }
    }

}


text:
package com.hadlink.recyclerviewhelpper;

import android.content.Intent;
import android.os.Bundle;
import android.support.v7.app.AppCompatActivity;
import android.support.v7.widget.Toolbar;
import android.view.View;

import com.hadlink.recyclerviewhelpper.aty.GridViewAty;
import com.hadlink.recyclerviewhelpper.aty.ListViewAty;
import com.hadlink.recyclerviewhelpper.aty.RecyclerViewAty;
import com.hadlink.recyclerviewhelpper.aty.RecyclerViewMulAty;

public class MainActivity extends AppCompatActivity {

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        Toolbar toolbar = (Toolbar) findViewById(R.id.toolbar);
        setSupportActionBar(toolbar);
    }

    public void rv_single(View v) {
        startActivity(new Intent(this, RecyclerViewAty.class));
    }

    public void rv_multi(View v) {
        startActivity(new Intent(this, RecyclerViewMulAty.class));
    }

    public void lv(View v) {
        startActivity(new Intent(this, ListViewAty.class));
    }

    public void gv(View v) {
        startActivity(new Intent(this, GridViewAty.class));
    }

}


text:
title: "Manjaro 21.1.0 Pahvo released"
layout: post
categories: manjaro release
tags: [manjaro release]
image: /screenshots/Manjaro 21.1.0/00 title-clip.jpg
video: https://youtube.com/embed/oM6B1rmdu6M
---

**The** Manjaro project has announced the release of Manjaro 21.1.0 with the code name Pahvo. Manjaro 21.1.0 brings the latest package updates from the Manjaro repositories and also improves the user experience across different editions.

![Manjaro 21.1.0 featured](/screenshots/Manjaro 21.1.0/00 title-clip.jpg)

The Manjaro 21.1.0 release announcement includes the official editions GNOME, KDE Plasma, and Xfce.

The noteworthy highlights in Manjaro 21 1.0 release are as follows.

> - Manjaro 21.1.0 brings several improvements to Calamares. It includes filesystem selection for automatic partitioning and enhanced support for brtfs. For brtfs, the default subvolume layout is optimized for easier rollback and effective space utilization. Also, brtfs can now support swap space.
- GNOME 40. The default layout more closely follows upstream. For those who prefer the old vertical desktop layout, the Manjaro legacy layout is available in gnome-layout-switcher.
- Firefox appearance is now more consistent with GNOME with a custom theme. This theme can be disabled in gnome-layout-switcher.
- The Plasma edition comes with the latest Plasma 5.22 series, Frameworks 5.85, and Applications (Gear) 21.08. Also, the default theme is updated to match more with the upstream. Plasma Wayland change is continuing in full swing.
- Manjaro 21.1.0 Xfce Edition comes with Xfce 4.16.
- Linux Kernel 5.13 is the default Kernel available. Also, there are minimal ISOs with Linux Kernel 5.4 LTS which offers additional support for older hardware.

For further information, read [Manjaro 21.1.0 Pahvo release announcement](https://forum.manjaro.org/t/manjaro-21-1-0-pahvo-released/78663).

## Manjaro 21.1.0 Pahvo screenshots
{% include image-gallery.html folder="/screenshots/Manjaro 21.1.0" %}


text:
cask 'iterm2' do
  # note: "2" is not a version number, but an intrinsic part of the product name
  version '3.1.3'
  sha256 '4f35d70f4420fa736ed158663ecf114baeb61836b5a8b30652595ab4fcf68544'

  url "https://iterm2.com/downloads/stable/iTerm2-#{version.dots_to_underscores}.zip"
  appcast 'https://iterm2.com/appcasts/final.xml',
          checkpoint: 'f6cde834cc7849656cd6c5a54a582dbd7370a0ed7772f6d2c4af9aaf5ad8c4e8'
  name 'iTerm2'
  homepage 'https://www.iterm2.com/'

  auto_updates true
  depends_on macos: '>= :yosemite'

  app 'iTerm.app'

  zap delete: [
                '~/Library/Application Support/com.apple.sharedfilelist/com.apple.LSSharedFileList.ApplicationRecentDocuments/com.googlecode.iterm2.sfl',
                '~/Library/Caches/com.googlecode.iterm2',
                '~/Library/Saved Application State/com.googlecode.iterm2.savedState',
              ],
      trash:  [
                '~/Library/Application Support/iTerm',
                '~/Library/Application Support/iTerm2',
                '~/Library/Preferences/com.googlecode.iterm2.plist',
              ]
end


text:
 config = require('./Utils/config')

var mongoose =  require('mongoose');
mongoose.Promise = global.Promise;
mongoose.connect(config.dbConection, {
  useMongoClient: true
});

var db = mongoose.connection;
db.on('error', console.error.bind(console, 'connection error:'));
db.once('open', function() {
  console.log('Conectou ao mongoose');
});

module.exports = {
  mongoose:mongoose
}


text:
body { background-color: #eee; font-size: 14px; font-family: 'microsoft yahei'; margin: 0; }
input, select, textarea { padding: 5px; }
.zxx_out_box{width:70%; min-width:700px; border-left:1px solid white; border-right:1px solid white; margin:0 auto; }
.zxx_in_box{min-height:550px; _height:550px; border-left:1px solid #ccc; border-right:1px solid #ccc; background:white; padding:1em 2.5em 0;}
.zxx_header{padding:10px 20px 5px; border-bottom:1px solid #ccc; overflow:hidden; zoom:1;}
.zxx_author_time{float:right; margin-top:34px; color:#787878; font-family:"Courier New", Courier, monospace;}
.zxx_title{font-size:1.6em; text-align:center; margin:20px 0;}
.zxx_main_con{min-height:580px; _height:580px; padding:0 20px 20px;}
.zxx_footer{padding-bottom:25px; padding-top: 25px; font-size: 12px; text-align:center; color: #454455;}
.zxx_test_list{padding:1em; font-size:1.1em; border-bottom:1px dashed #ccc; line-height:1.3; overflow:hidden; zoom:1;}
.zxx_code{display:block; padding:10px; margin:5px 0; background:#eee; border:1px dashed #ccc; clear:both; zoom:1;}
.zxx_code xmp,.zxx_code pre{margin:0; color:#00F; font-size:12px; white-space:pre-wrap; word-wrap:break-word;}
.zxx_btn{display:inline-block;}
.zxx_btn:hover,.zxx_btn a:hover{text-decoration:none; color:#34538b;}

input, textarea{font-size:100%;}
.bar_bg{display:inline-block; width:200px; height:16px; background-color:#e0e0e0;}
.bar_btn{width:20px; height:20px; line-height:20px; margin-top:-3px; margin-left:-10px; border:1px solid #ccc; background-color:#fff; text-align:center; font-size:10px; position:absolute; cursor:pointer;}
.bar_btn:hover{background-color:#f5f5f5;}
.bar_btn:after{display:block; content:attr(data-content);}
.submit{width:100px; height:32px;}


text:
namespace HockeyApp.Common.Enums
{
    public enum FeedbackSorting
    {
        CreateDate,
        Rating,
        ModerateDate
    }
}


text:
module HealthSeven::V2_5
class Rmi < ::HealthSeven::Segment
  # Risk Management Incident Code
  attribute :risk_management_incident_code, Ce, position: "RMI.1"
  # Date/Time Incident
  attribute :date_time_incident, Ts, position: "RMI.2"
  # Incident Type Code
  attribute :incident_type_code, Ce, position: "RMI.3"
end
end


text:
require 'yard'

require 'yard-chef/code_objects/chef_object'
require 'yard-chef/code_objects/cookbook_object'
require 'yard-chef/code_objects/resource_object'
require 'yard-chef/code_objects/provider_object'
require 'yard-chef/code_objects/recipe_object'
require 'yard-chef/code_objects/attribute_object'
require 'yard-chef/code_objects/action_object'
require 'yard-chef/code_objects/dependency_object'

require 'yard-chef/handlers/base'
require 'yard-chef/handlers/action'
require 'yard-chef/handlers/attribute'
require 'yard-chef/handlers/define'
require 'yard-chef/handlers/actions'
require 'yard-chef/handlers/cookbook'
require 'yard-chef/handlers/recipe'
require 'yard-chef/handlers/dependency'

module YARD::CodeObjects::Chef
  # Since 'recipe' files do not have a specific keyword that can be matched,
  # iterate through the list of files to be parsed and register the recipes.
  # Description for every recipe may be found in 'metadata.rb' which can
  # be taken care of in the handler.
  # TODO: Investigate if YARD handlers can be invoked if parser is in a
  # specific directory.
  YARD::Parser::SourceParser.before_parse_list do |files, _globals|
    files.each do |file|
      path_arr = File.expand_path(file).to_s.split('/')
      next if (index = path_arr.index('recipes')).nil?
      # Cookbook name can be derived from file path
      # cookbook/<cookbook_name>/recipes/recipe_name.rb
      cookbook_name = path_arr[index - 1]
      cookbook = ChefObject.register(CHEF, cookbook_name, :cookbook)

      recipe_name = path_arr.last.to_s.sub('.rb', '')
      recipe = ChefObject.register(cookbook, recipe_name, :recipe)

      recipe.source = IO.read(file)
      recipe.add_file(file, 1)
    end
  end

  # Register '@resource' tag for mapping providers with light-weight resources
  YARD::Tags::Library.define_tag(
    'Map Chef Providers with Chef Resources',
    :resource
  )

  # Register template directory for the chef plugin
  template_dir = File.expand_path('../templates', File.dirname(__FILE__))
  YARD::Templates::Engine.register_template_path(template_dir.to_s)
end


text:
"""Tests for the WebKit time implementation."""

import decimal
import unittest

from dfdatetime import webkit_time

class WebKitTimeEpochTest(unittest.TestCase):
  """Tests for the WebKit time epoch."""

  def testInitialize(self):
    """Tests the __init__ function."""
    webkit_epoch = webkit_time.WebKitTimeEpoch()
    self.assertIsNotNone(webkit_epoch)

class WebKitTimeTest(unittest.TestCase):
  """Tests for the WebKit timestamp."""

  # pylint: disable=protected-access

  def testProperties(self):
    """Tests the properties."""
    webkit_time_object = webkit_time.WebKitTime(timestamp=12926120791546875)
    self.assertEqual(webkit_time_object.timestamp, 12926120791546875)

    webkit_time_object = webkit_time.WebKitTime()
    self.assertIsNone(webkit_time_object.timestamp)

  def testGetNormalizedTimestamp(self):
    """Tests the _GetNormalizedTimestamp function."""
    webkit_time_object = webkit_time.WebKitTime(timestamp=12926120791546875)

    normalized_timestamp = webkit_time_object._GetNormalizedTimestamp()
    self.assertEqual(normalized_timestamp, decimal.Decimal('1281647191.546875'))

    webkit_time_object = webkit_time.WebKitTime(
        time_zone_offset=60, timestamp=12926120791546875)

    normalized_timestamp = webkit_time_object._GetNormalizedTimestamp()
    self.assertEqual(normalized_timestamp, decimal.Decimal('1281643591.546875'))

    webkit_time_object = webkit_time.WebKitTime(timestamp=12926120791546875)
    webkit_time_object.time_zone_offset = 60

    normalized_timestamp = webkit_time_object._GetNormalizedTimestamp()
    self.assertEqual(normalized_timestamp, decimal.Decimal('1281643591.546875'))

    webkit_time_object = webkit_time.WebKitTime(timestamp=0x1ffffffffffffffff)

    normalized_timestamp = webkit_time_object._GetNormalizedTimestamp()
    self.assertIsNone(normalized_timestamp)

    webkit_time_object = webkit_time.WebKitTime()

    normalized_timestamp = webkit_time_object._GetNormalizedTimestamp()
    self.assertIsNone(normalized_timestamp)

  def testCopyFromDateTimeString(self):
    """Tests the CopyFromDateTimeString function."""
    webkit_time_object = webkit_time.WebKitTime()

    webkit_time_object.CopyFromDateTimeString('2010-08-12')
    self.assertEqual(webkit_time_object._timestamp, 12926044800000000)
    self.assertEqual(webkit_time_object._time_zone_offset, 0)

    webkit_time_object.CopyFromDateTimeString('2010-08-12 21:06:31')
    self.assertEqual(webkit_time_object._timestamp, 12926120791000000)
    self.assertEqual(webkit_time_object._time_zone_offset, 0)

    webkit_time_object.CopyFromDateTimeString('2010-08-12 21:06:31.546875')
    self.assertEqual(webkit_time_object._timestamp, 12926120791546875)
    self.assertEqual(webkit_time_object._time_zone_offset, 0)

    webkit_time_object.CopyFromDateTimeString(
        '2010-08-12 21:06:31.546875-01:00')
    self.assertEqual(webkit_time_object._timestamp, 12926120791546875)
    self.assertEqual(webkit_time_object._time_zone_offset, -60)

    webkit_time_object.CopyFromDateTimeString(
        '2010-08-12 21:06:31.546875+01:00')
    self.assertEqual(webkit_time_object._timestamp, 12926120791546875)
    self.assertEqual(webkit_time_object._time_zone_offset, 60)

    webkit_time_object.CopyFromDateTimeString('1601-01-02 00:00:00')
    self.assertEqual(webkit_time_object._timestamp, 86400 * 1000000)
    self.assertEqual(webkit_time_object._time_zone_offset, 0)

  def testCopyToDateTimeString(self):
    """Tests the CopyToDateTimeString function."""
    webkit_time_object = webkit_time.WebKitTime(timestamp=12926120791546875)

    date_time_string = webkit_time_object.CopyToDateTimeString()
    self.assertEqual(date_time_string, '2010-08-12 21:06:31.546875')

    webkit_time_object = webkit_time.WebKitTime()

    date_time_string = webkit_time_object.CopyToDateTimeString()
    self.assertIsNone(date_time_string)

  def testCopyToDateTimeStringISO8601(self):
    """Tests the CopyToDateTimeStringISO8601 function."""
    webkit_time_object = webkit_time.WebKitTime(timestamp=12926120791546875)

    date_time_string = webkit_time_object.CopyToDateTimeStringISO8601()
    self.assertEqual(date_time_string, '2010-08-12T21:06:31.546875+00:00')

  def testGetDate(self):
    """Tests the GetDate function."""
    webkit_time_object = webkit_time.WebKitTime(timestamp=12926120791546875)

    date_tuple = webkit_time_object.GetDate()
    self.assertEqual(date_tuple, (2010, 8, 12))

    webkit_time_object = webkit_time.WebKitTime()

    date_tuple = webkit_time_object.GetDate()
    self.assertEqual(date_tuple, (None, None, None))

  def testGetDateWithTimeOfDay(self):
    """Tests the GetDateWithTimeOfDay function."""
    webkit_time_object = webkit_time.WebKitTime(timestamp=12926120791546875)

    date_with_time_of_day_tuple = webkit_time_object.GetDateWithTimeOfDay()
    self.assertEqual(date_with_time_of_day_tuple, (2010, 8, 12, 21, 6, 31))

    webkit_time_object = webkit_time.WebKitTime()

    date_with_time_of_day_tuple = webkit_time_object.GetDateWithTimeOfDay()
    self.assertEqual(
        date_with_time_of_day_tuple, (None, None, None, None, None, None))

  def testGetTimeOfDay(self):
    """Tests the GetTimeOfDay function."""
    webkit_time_object = webkit_time.WebKitTime(timestamp=12926120791546875)

    time_of_day_tuple = webkit_time_object.GetTimeOfDay()
    self.assertEqual(time_of_day_tuple, (21, 6, 31))

    webkit_time_object = webkit_time.WebKitTime()

    time_of_day_tuple = webkit_time_object.GetTimeOfDay()
    self.assertEqual(time_of_day_tuple, (None, None, None))

if __name__ == '__main__':
  unittest.main()


text:
namespace System.CodeDom
{
    [Serializable]
    public class CodeThisReferenceExpression : CodeExpression
    {
    }
}


text:
package org.objenesis.tck.candidates;

import java.io.Serializable;

/**
 * @author Joe Walnes
 */
public class SerializableConstructorWithArguments implements Serializable {

   private static final long serialVersionUID = 1L;

   private final String something;
   private final int another;

   public SerializableConstructorWithArguments(String something, int another) {
      this.something = something;
      this.another = another;
   }

   public String toString() {
      return something + another;
   }
}


text:
<!DOCTYPE html>

Hello from Haskell!