//     Backbone.js 1.1.2

//     (c) 2010-2014 Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors

//     Backbone may be freely distributed under the MIT license.

//     For all details and documentation:

//     http://backbonejs.org

(function(root, factory) {

  // Set up Backbone appropriately for the environment. Start with AMD.

  if (typeof define === 'function' && define.amd) {

    define(['underscore', 'jquery', 'exports'], function(_, $, exports) {

      // Export global even in AMD case in case this script is loaded with

      // others that may still expect a global Backbone.

      root.Backbone = factory(root, exports, _, $);

    });

  // Next for Node.js or CommonJS. jQuery may not be needed as a module.

  } else if (typeof exports !== 'undefined') {

    var _ = require('underscore');

    factory(root, exports, _);

  // Finally, as a browser global.

  } else {

    root.Backbone = factory(root, {}, root._, (root.jQuery || root.Zepto || root.ender || root.$));

  }

}(this, function(root, Backbone, _, $) {

  // Initial Setup

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

  // Save the previous value of the `Backbone` variable, so that it can be

  // restored later on, if `noConflict` is used.

  var previousBackbone = root.Backbone;

  // Create local references to array methods we'll want to use later.

  var array = [];

  var push = array.push;

  var slice = array.slice;

  var splice = array.splice;

  // Current version of the library. Keep in sync with `package.json`.

  Backbone.VERSION = '1.1.2';

  // For Backbone's purposes, jQuery, Zepto, Ender, or My Library (kidding) owns

  // the `$` variable.

  Backbone.$ = $;

  // Runs Backbone.js in *noConflict* mode, returning the `Backbone` variable

  // to its previous owner. Returns a reference to this Backbone object.

  Backbone.noConflict = function() {

    root.Backbone = previousBackbone;

    return this;

  };

  // Turn on `emulateHTTP` to support legacy HTTP servers. Setting this option

  // will fake `"PATCH"`, `"PUT"` and `"DELETE"` requests via the `_method` parameter and

  // set a `X-Http-Method-Override` header.

  Backbone.emulateHTTP = false;

  // Turn on `emulateJSON` to support legacy servers that can't deal with direct

  // `application/json` requests ... will encode the body as

  // `application/x-www-form-urlencoded` instead and will send the model in a

  // form param named `model`.

  Backbone.emulateJSON = false;

  // Backbone.Events

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

  // A module that can be mixed in to *any object* in order to provide it with

  // custom events. You may bind with `on` or remove with `off` callback

  // functions to an event; `trigger`-ing an event fires all callbacks in

  // succession.

  //

  //     var object = {};

  //     _.extend(object, Backbone.Events);

  //     object.on('expand', function(){ alert('expanded'); });

  //     object.trigger('expand');

  //

  var Events = Backbone.Events = {

    // Bind an event to a `callback` function. Passing `"all"` will bind

    // the callback to all events fired.

    on: function(name, callback, context) {

      if (!eventsApi(this, 'on', name, [callback, context]) || !callback) return this;

      this._events || (this._events = {});

      var events = this._events[name] || (this._events[name] = []);

      events.push({callback: callback, context: context, ctx: context || this});

      return this;

    },

    // Bind an event to only be triggered a single time. After the first time

    // the callback is invoked, it will be removed.

    once: function(name, callback, context) {

      if (!eventsApi(this, 'once', name, [callback, context]) || !callback) return this;

      var self = this;

      var once = _.once(function() {

        self.off(name, once);

        callback.apply(this, arguments);

      });

      once._callback = callback;

      return this.on(name, once, context);

    },

    // Remove one or many callbacks. If `context` is null, removes all

    // callbacks with that function. If `callback` is null, removes all

    // callbacks for the event. If `name` is null, removes all bound

    // callbacks for all events.

    off: function(name, callback, context) {

      var retain, ev, events, names, i, l, j, k;

      if (!this._events || !eventsApi(this, 'off', name, [callback, context])) return this;

      if (!name && !callback && !context) {

        this._events = void 0;

        return this;

      }

      names = name ? [name] : _.keys(this._events);

      for (i = 0, l = names.length; i < l; i++) {

        name = names[i];

        if (events = this._events[name]) {

          this._events[name] = retain = [];

          if (callback || context) {

            for (j = 0, k = events.length; j < k; j++) {

              ev = events[j];

              if ((callback && callback !== ev.callback && callback !== ev.callback._callback) ||

                  (context && context !== ev.context)) {

                retain.push(ev);

              }

            }

          }

          if (!retain.length) delete this._events[name];

        }

      }

      return this;

    },

    // Trigger one or many events, firing all bound callbacks. Callbacks are

    // passed the same arguments as `trigger` is, apart from the event name

    // (unless you're listening on `"all"`, which will cause your callback to

    // receive the true name of the event as the first argument).

    trigger: function(name) {

      if (!this._events) return this;

      var args = slice.call(arguments, 1);

      if (!eventsApi(this, 'trigger', name, args)) return this;

      var events = this._events[name];

      var allEvents = this._events.all;

      if (events) triggerEvents(events, args);

      if (allEvents) triggerEvents(allEvents, arguments);

      return this;

    },

    // Tell this object to stop listening to either specific events ... or

    // to every object it's currently listening to.

    stopListening: function(obj, name, callback) {

      var listeningTo = this._listeningTo;

      if (!listeningTo) return this;

      var remove = !name && !callback;

      if (!callback && typeof name === 'object') callback = this;

      if (obj) (listeningTo = {})[obj._listenId] = obj;

      for (var id in listeningTo) {

        obj = listeningTo[id];

        obj.off(name, callback, this);

        if (remove || _.isEmpty(obj._events)) delete this._listeningTo[id];

      }

      return this;

    }

  };

  // Regular expression used to split event strings.

  var eventSplitter = /\s+/;

  // Implement fancy features of the Events API such as multiple event

  // names `"change blur"` and jQuery-style event maps `{change: action}`

  // in terms of the existing API.

  var eventsApi = function(obj, action, name, rest) {

    if (!name) return true;

    // Handle event maps.

    if (typeof name === 'object') {

      for (var key in name) {

        obj[action].apply(obj, [key, name[key]].concat(rest));

      }

      return false;

    }

    // Handle space separated event names.

    if (eventSplitter.test(name)) {

      var names = name.split(eventSplitter);

      for (var i = 0, l = names.length; i < l; i++) {

        obj[action].apply(obj, [names[i]].concat(rest));

      }

      return false;

    }

    return true;

  };

  // A difficult-to-believe, but optimized internal dispatch function for

  // triggering events. Tries to keep the usual cases speedy (most internal

  // Backbone events have 3 arguments).

  var triggerEvents = function(events, args) {

    var ev, i = -1, l = events.length, a1 = args[0], a2 = args[1], a3 = args[2];

    switch (args.length) {

      case 0: while (++i < l) (ev = events[i]).callback.call(ev.ctx); return;

      case 1: while (++i < l) (ev = events[i]).callback.call(ev.ctx, a1); return;

      case 2: while (++i < l) (ev = events[i]).callback.call(ev.ctx, a1, a2); return;

      case 3: while (++i < l) (ev = events[i]).callback.call(ev.ctx, a1, a2, a3); return;

      default: while (++i < l) (ev = events[i]).callback.apply(ev.ctx, args); return;

    }

  };

  var listenMethods = {listenTo: 'on', listenToOnce: 'once'};

  // Inversion-of-control versions of `on` and `once`. Tell *this* object to

  // listen to an event in another object ... keeping track of what it's

  // listening to.

  _.each(listenMethods, function(implementation, method) {

    Events[method] = function(obj, name, callback) {

      var listeningTo = this._listeningTo || (this._listeningTo = {});

      var id = obj._listenId || (obj._listenId = _.uniqueId('l'));

      listeningTo[id] = obj;

      if (!callback && typeof name === 'object') callback = this;

      obj[implementation](name, callback, this);

      return this;

    };

  });

  // Aliases for backwards compatibility.

  Events.bind   = Events.on;

  Events.unbind = Events.off;

  // Allow the `Backbone` object to serve as a global event bus, for folks who

  // want global "pubsub" in a convenient place.

  _.extend(Backbone, Events);

  // Backbone.Model

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

  // Backbone **Models** are the basic data object in the framework --

  // frequently representing a row in a table in a database on your server.

  // A discrete chunk of data and a bunch of useful, related methods for

  // performing computations and transformations on that data.

  // Create a new model with the specified attributes. A client id (`cid`)

  // is automatically generated and assigned for you.

  var Model = Backbone.Model = function(attributes, options) {

    var attrs = attributes || {};

    options || (options = {});

    this.cid = _.uniqueId('c');

    this.attributes = {};

    if (options.collection) this.collection = options.collection;

    if (options.parse) attrs = this.parse(attrs, options) || {};

    attrs = _.defaults({}, attrs, _.result(this, 'defaults'));

    this.set(attrs, options);

    this.changed = {};

    this.initialize.apply(this, arguments);

  };

  // Attach all inheritable methods to the Model prototype.

  _.extend(Model.prototype, Events, {

    // A hash of attributes whose current and previous value differ.

    changed: null,

    // The value returned during the last failed validation.

    validationError: null,

    // The default name for the JSON `id` attribute is `"id"`. MongoDB and

    // CouchDB users may want to set this to `"_id"`.

    idAttribute: 'id',

    // Initialize is an empty function by default. Override it with your own

    // initialization logic.

    initialize: function(){},

    // Return a copy of the model's `attributes` object.

    toJSON: function(options) {

      return _.clone(this.attributes);

    },

    // Proxy `Backbone.sync` by default -- but override this if you need

    // custom syncing semantics for *this* particular model.

    sync: function() {

      return Backbone.sync.apply(this, arguments);

    },

    // Get the value of an attribute.

    get: function(attr) {

      return this.attributes[attr];

    },

    // Get the HTML-escaped value of an attribute.

    escape: function(attr) {

      return _.escape(this.get(attr));

    },

    // Returns `true` if the attribute contains a value that is not null

    // or undefined.

    has: function(attr) {

      return this.get(attr) != null;

    },

    // Set a hash of model attributes on the object, firing `"change"`. This is

    // the core primitive operation of a model, updating the data and notifying

    // anyone who needs to know about the change in state. The heart of the beast.

    set: function(key, val, options) {

      var attr, attrs, unset, changes, silent, changing, prev, current;

      if (key == null) return this;

      // Handle both `"key", value` and `{key: value}` -style arguments.

      if (typeof key === 'object') {

        attrs = key;

        options = val;

      } else {

        (attrs = {})[key] = val;

      }

      options || (options = {});

      // Run validation.

      if (!this._validate(attrs, options)) return false;

      // Extract attributes and options.

      unset           = options.unset;

      silent          = options.silent;

      changes         = [];

      changing        = this._changing;

      this._changing  = true;

      if (!changing) {

        this._previousAttributes = _.clone(this.attributes);

        this.changed = {};

      }

      current = this.attributes, prev = this._previousAttributes;

      // Check for changes of `id`.

      if (this.idAttribute in attrs) this.id = attrs[this.idAttribute];

      // For each `set` attribute, update or delete the current value.

      for (attr in attrs) {

        val = attrs[attr];

        if (!_.isEqual(current[attr], val)) changes.push(attr);

        if (!_.isEqual(prev[attr], val)) {

          this.changed[attr] = val;

        } else {