text: /*! AutoFill 1.2.1
   * ©2008-2014 SpryMedia Ltd - datatables.net/license
   */
  
  /**
   * @summary     AutoFill
   * @description Add Excel like click and drag auto-fill options to DataTables
   * @version     1.2.1
   * @file        dataTables.autoFill.js
   * @author      SpryMedia Ltd (www.sprymedia.co.uk)
   * @contact     www.sprymedia.co.uk/contact
   * @copyright   Copyright 2010-2014 SpryMedia Ltd.
   *
   * This source file is free software, available under the following license:
   *   MIT license - http://datatables.net/license/mit
   *
   * This source file is distributed in the hope that it will be useful, but
   * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
   * or FITNESS FOR A PARTICULAR PURPOSE. See the license files for details.
   *
   * For details please refer to: http://www.datatables.net
   */
  
  (function (window, document, undefined) {
  
      var factory = function ($, DataTable) {
          "use strict";
  
          /**
           * AutoFill provides Excel like auto-fill features for a DataTable
           *
           * @class AutoFill
           * @constructor
           * @param {object} oTD DataTables settings object
           * @param {object} oConfig Configuration object for AutoFill
           */
          var AutoFill = function (oDT, oConfig) {
              /* Sanity check that we are a new instance */
              if (!(this instanceof AutoFill)) {
                  throw("Warning: AutoFill must be initialised with the keyword 'new'");
              }
  
              if (!$.fn.dataTableExt.fnVersionCheck('1.7.0')) {
                  throw("Warning: AutoFill requires DataTables 1.7 or greater");
              }
  
  
              /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
               * Public class variables
               * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
  
              this.c = {};
  
              /**
               * @namespace Settings object which contains customisable information for AutoFill instance
               */
              this.s = {
                  /**
                   * @namespace Cached information about the little dragging icon (the filler)
                   */
                  "filler": {
                      "height": 0,
                      "width": 0
                  },
  
                  /**
                   * @namespace Cached information about the border display
                   */
                  "border": {
                      "width": 2
                  },
  
                  /**
                   * @namespace Store for live information for the current drag
                   */
                  "drag": {
                      "startX": -1,
                      "startY": -1,
                      "startTd": null,
                      "endTd": null,
                      "dragging": false
                  },
  
                  /**
                   * @namespace Data cache for information that we need for scrolling the screen when we near
                   *   the edges
                   */
                  "screen": {
                      "interval": null,
                      "y": 0,
                      "height": 0,
                      "scrollTop": 0
                  },
  
                  /**
                   * @namespace Data cache for the position of the DataTables scrolling element (when scrolling
                   *   is enabled)
                   */
                  "scroller": {
                      "top": 0,
                      "bottom": 0
                  },
  
                  /**
                   * @namespace Information stored for each column. An array of objects
                   */
                  "columns": []
              };
  
  
              /**
               * @namespace Common and useful DOM elements for the class instance
               */
              this.dom = {
                  "table": null,
                  "filler": null,
                  "borderTop": null,
                  "borderRight": null,
                  "borderBottom": null,
                  "borderLeft": null,
                  "currentTarget": null
              };
  
  
              /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
               * Public class methods
               * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
  
              /**
               * Retreieve the settings object from an instance
               *  @method fnSettings
               *  @returns {object} AutoFill settings object
               */
              this.fnSettings = function () {
                  return this.s;
              };
  
  
              /* Constructor logic */
              this._fnInit(oDT, oConfig);
              return this;
          };
  
  
          AutoFill.prototype = {
              /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
               * Private methods (they are of course public in JS, but recommended as private)
               * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
  
              /**
               * Initialisation
               *  @method _fnInit
               *  @param {object} dt DataTables settings object
               *  @param {object} config Configuration object for AutoFill
               *  @returns void
               */
              "_fnInit": function (dt, config) {
                  var
                      that = this,
                      i, iLen;
  
                  // Use DataTables API to get the settings allowing selectors, instances
                  // etc to be used, or for backwards compatibility get from the old
                  // fnSettings method
                  this.s.dt = DataTable.Api ?
                      new DataTable.Api(dt).settings()[0] :
                      dt.fnSettings();
                  this.s.init = config || {};
                  this.dom.table = this.s.dt.nTable;
  
                  $.extend(true, this.c, AutoFill.defaults, config);
  
                  /* Add and configure the columns */
                  this._initColumns();
  
                  /* Auto Fill click and drag icon */
                  var filler = $('<div/>', {
                      'class': 'AutoFill_filler'
                  })
                      .appendTo('body');
                  this.dom.filler = filler[0];
  
                  // Get the height / width of the click element
                  this.s.filler.height = filler.height();
                  this.s.filler.width = filler.width();
                  filler[0].style.display = "none";
  
                  /* Border display - one div for each side. We can't just use a single
                   * one with a border, as we want the events to effectively pass through
                   * the transparent bit of the box
                   */
                  var border;
                  var appender = document.body;
                  if (that.s.dt.oScroll.sY !== "") {
                      that.s.dt.nTable.parentNode.style.position = "relative";
                      appender = that.s.dt.nTable.parentNode;
                  }
  
                  border = $('<div/>', {
                      "class": "AutoFill_border"
                  });
                  this.dom.borderTop = border.clone().appendTo(appender)[0];
                  this.dom.borderRight = border.clone().appendTo(appender)[0];
                  this.dom.borderBottom = border.clone().appendTo(appender)[0];
                  this.dom.borderLeft = border.clone().appendTo(appender)[0];
  
                  /* Events */
                  filler.on('mousedown.DTAF', function (e) {
                      this.onselectstart = function () {
                          return false;
                      };
                      that._fnFillerDragStart.call(that, e);
                      return false;
                  });
  
                  $('tbody', this.dom.table).on(
                      'mouseover.DTAF mouseout.DTAF',
                      '>tr>td, >tr>th',
                      function (e) {
                          that._fnFillerDisplay.call(that, e);
                      }
                  );
  
                  $(this.dom.table).on('destroy.dt.DTAF', function () {
                      filler.off('mousedown.DTAF').remove();
                      $('tbody', this.dom.table).off('mouseover.DTAF mouseout.DTAF');
                  });
              },
  
  
              _initColumns: function () {
                  var that = this;
                  var i, ien;
                  var dt = this.s.dt;
                  var config = this.s.init;
  
                  for (i = 0, ien = dt.aoColumns.length; i < ien; i++) {
                      this.s.columns[i] = $.extend(true, {}, AutoFill.defaults.column);
                  }
  
                  dt.oApi._fnApplyColumnDefs(
                      dt,
                      config.aoColumnDefs || config.columnDefs,
                      config.aoColumns || config.columns,
                      function (colIdx, def) {
                          that._fnColumnOptions(colIdx, def);
                      }
                  );
  
                  // For columns which don't have read, write, step functions defined,
                  // use the default ones
                  for (i = 0, ien = dt.aoColumns.length; i < ien; i++) {
                      var column = this.s.columns[i];
  
                      if (!column.read) {
                          column.read = this._fnReadCell;
                      }
                      if (!column.write) {
                          column.read = this._fnWriteCell;
                      }
                      if (!column.step) {
                          column.read = this._fnStep;
                      }
                  }
              },
  
  
              "_fnColumnOptions": function (i, opts) {
                  var column = this.s.columns[i];
                  var set = function (outProp, inProp) {
                      if (opts[inProp[0]] !== undefined) {
                          column[outProp] = opts[inProp[0]];
                      }
                      if (opts[inProp[1]] !== undefined) {
                          column[outProp] = opts[inProp[1]];
                      }
                  };
  
                  // Compatibility with the old Hungarian style of notation
                  set('enable', ['bEnable', 'enable']);
                  set('read', ['fnRead', 'read']);
                  set('write', ['fnWrite', 'write']);
                  set('step', ['fnStep', 'step']);
                  set('increment', ['bIncrement', 'increment']);
              },
  
  
              /**
               * Find out the coordinates of a given TD cell in a table
               *  @method  _fnTargetCoords
               *  @param   {Node} nTd
               *  @returns {Object} x and y properties, for the position of the cell in the tables DOM
               */
              "_fnTargetCoords": function (nTd) {
                  var nTr = $(nTd).parents('tr')[0];
                  var position = this.s.dt.oInstance.fnGetPosition(nTd);
  
                  return {
                      "x": $('td', nTr).index(nTd),
                      "y": $('tr', nTr.parentNode).index(nTr),
                      "row": position[0],
                      "column": position[2]
                  };
              },
  
  
              /**
               * Display the border around one or more cells (from start to end)
               *  @method  _fnUpdateBorder
               *  @param   {Node} nStart Starting cell
               *  @param   {Node} nEnd Ending cell
               *  @returns void
               */
              "_fnUpdateBorder": function (nStart, nEnd) {
                  var
                      border = this.s.border.width,
                      offsetStart = $(nStart).offset(),
                      offsetEnd = $(nEnd).offset(),
                      x1 = offsetStart.left - border,
                      x2 = offsetEnd.left + $(nEnd).outerWidth(),
                      y1 = offsetStart.top - border,
                      y2 = offsetEnd.top + $(nEnd).outerHeight(),
                      width = offsetEnd.left + $(nEnd).outerWidth() - offsetStart.left + (2 * border),
                      height = offsetEnd.top + $(nEnd).outerHeight() - offsetStart.top + (2 * border),
                      oStyle;
  
                  // Recalculate start and end (when dragging "backwards")
                  if (offsetStart.left > offsetEnd.left) {
                      x1 = offsetEnd.left - border;
                      x2 = offsetStart.left + $(nStart).outerWidth();
                      width = offsetStart.left + $(nStart).outerWidth() - offsetEnd.left + (2 * border);
                  }
  
                  if (this.s.dt.oScroll.sY !== "") {
                      /* The border elements are inside the DT scroller - so position relative to that */
                      var
                          offsetScroll = $(this.s.dt.nTable.parentNode).offset(),
                          scrollTop = $(this.s.dt.nTable.parentNode).scrollTop(),
                          scrollLeft = $(this.s.dt.nTable.parentNode).scrollLeft();
  
                      x1 -= offsetScroll.left - scrollLeft;
                      x2 -= offsetScroll.left - scrollLeft;
                      y1 -= offsetScroll.top - scrollTop;
                      y2 -= offsetScroll.top - scrollTop;
                  }
  
                  /* Top */
                  oStyle = this.dom.borderTop.style;
                  oStyle.top = y1 + "px";
                  oStyle.left = x1 + "px";
                  oStyle.height = this.s.border.width + "px";
                  oStyle.width = width + "px";
  
                  /* Bottom */
                  oStyle = this.dom.borderBottom.style;
                  oStyle.top = y2 + "px";
                  oStyle.left = x1 + "px";
                  oStyle.height = this.s.border.width + "px";
                  oStyle.width = width + "px";
  
                  /* Left */
                  oStyle = this.dom.borderLeft.style;
                  oStyle.top = y1 + "px";
                  oStyle.left = x1 + "px";
                  oStyle.height = height + "px";
                  oStyle.width = this.s.border.width + "px";
  
                  /* Right */
                  oStyle = this.dom.borderRight.style;
                  oStyle.top = y1 + "px";
                  oStyle.left = x2 + "px";
                  oStyle.height = height + "px";
                  oStyle.width = this.s.border.width + "px";
              },
  
  
              /**
               * Mouse down event handler for starting a drag
               *  @method  _fnFillerDragStart
               *  @param   {Object} e Event object
               *  @returns void
               */
              "_fnFillerDragStart": function (e) {
                  var that = this;
                  var startingTd = this.dom.currentTarget;
  
                  this.s.drag.dragging = true;
  
                  that.dom.borderTop.style.display = "block";
                  that.dom.borderRight.style.display = "block";
                  that.dom.borderBottom.style.display = "block";
                  that.dom.borderLeft.style.display = "block";
  
                  var coords = this._fnTargetCoords(startingTd);
                  this.s.drag.startX = coords.x;
                  this.s.drag.startY = coords.y;
  
                  this.s.drag.startTd = startingTd;
                  this.s.drag.endTd = startingTd;
  
                  this._fnUpdateBorder(startingTd, startingTd);
  
                  $(document).bind('mousemove.AutoFill', function (e) {
                      that._fnFillerDragMove.call(that, e);
                  });
  
                  $(document).bind('mouseup.AutoFill', function (e) {
                      that._fnFillerFinish.call(that, e);
                  });
  
                  /* Scrolling information cache */
                  this.s.screen.y = e.pageY;
                  this.s.screen.height = $(window).height();
                  this.s.screen.scrollTop = $(document).scrollTop();
  
                  if (this.s.dt.oScroll.sY !== "") {
                      this.s.scroller.top = $(this.s.dt.nTable.parentNode).offset().top;
                      this.s.scroller.bottom = this.s.scroller.top + $(this.s.dt.nTable.parentNode).height();
                  }
  
                  /* Scrolling handler - we set an interval (which is cancelled on mouse up) which will fire
                   * regularly and see if we need to do any scrolling
                   */
                  this.s.screen.interval = setInterval(function () {
                      var iScrollTop = $(document).scrollTop();
                      var iScrollDelta = iScrollTop - that.s.screen.scrollTop;
                      that.s.screen.y += iScrollDelta;
  
                      if (that.s.screen.height - that.s.screen.y + iScrollTop < 50) {
                          $('html, body').animate({
                              "scrollTop": iScrollTop + 50
                          }, 240, 'linear');
                      } else if (that.s.screen.y - iScrollTop < 50) {
                          $('html, body').animate({
                              "scrollTop": iScrollTop - 50
                          }, 240, 'linear');
                      }
  
                      if (that.s.dt.oScroll.sY !== "") {
                          if (that.s.screen.y > that.s.scroller.bottom - 50) {
                              $(that.s.dt.nTable.parentNode).animate({
                                  "scrollTop": $(that.s.dt.nTable.parentNode).scrollTop() + 50
                              }, 240, 'linear');
                          } else if (that.s.screen.y < that.s.scroller.top + 50) {
                              $(that.s.dt.nTable.parentNode).animate({
                                  "scrollTop": $(that.s.dt.nTable.parentNode).scrollTop() - 50
                              }, 240, 'linear');
                          }
                      }
                  }, 250);
              },
  
  
              /**
               * Mouse move event handler for during a move. See if we want to update the display based on the
               * new cursor position
               *  @method  _fnFillerDragMove
               *  @param   {Object} e Event object
               *  @returns void
               */
              "_fnFillerDragMove": function (e) {
                  if (e.target && e.target.nodeName.toUpperCase() == "TD" &&
                      e.target != this.s.drag.endTd) {
                      var coords = this._fnTargetCoords(e.target);
  
                      if (this.c.mode == "y" && coords.x != this.s.drag.startX) {
                          e.target = $('tbody>tr:eq(' + coords.y + ')>td:eq(' + this.s.drag.startX + ')', this.dom.table)[0];
                      }
                      if (this.c.mode == "x" && coords.y != this.s.drag.startY) {
                          e.target = $('tbody>tr:eq(' + this.s.drag.startY + ')>td:eq(' + coords.x + ')', this.dom.table)[0];
                      }
  
                      if (this.c.mode == "either") {
                          if (coords.x != this.s.drag.startX) {
                              e.target = $('tbody>tr:eq(' + this.s.drag.startY + ')>td:eq(' + coords.x + ')', this.dom.table)[0];
                          } else if (coords.y != this.s.drag.startY) {
                              e.target = $('tbody>tr:eq(' + coords.y + ')>td:eq(' + this.s.drag.startX + ')', this.dom.table)[0];
                          }
                      }
  
                      // update coords
                      if (this.c.mode !== "both") {
                          coords = this._fnTargetCoords(e.target);
                      }
  
                      var drag = this.s.drag;
                      drag.endTd = e.target;
  
                      if (coords.y >= this.s.drag.startY) {
                          this._fnUpdateBorder(drag.startTd, drag.endTd);
                      } else {
                          this._fnUpdateBorder(drag.endTd, drag.startTd);
                      }
                      this._fnFillerPosition(e.target);
                  }
  
                  /* Update the screen information so we can perform scrolling */
                  this.s.screen.y = e.pageY;
                  this.s.screen.scrollTop = $(document).scrollTop();
  
                  if (this.s.dt.oScroll.sY !== "") {
                      this.s.scroller.scrollTop = $(this.s.dt.nTable.parentNode).scrollTop();
                      this.s.scroller.top = $(this.s.dt.nTable.parentNode).offset().top;
                      this.s.scroller.bottom = this.s.scroller.top + $(this.s.dt.nTable.parentNode).height();
                  }
              },
  
  
              /**
               * Mouse release handler - end the drag and take action to update the cells with the needed values
               *  @method  _fnFillerFinish
               *  @param   {Object} e Event object
               *  @returns void
               */
              "_fnFillerFinish": function (e) {
                  var that = this, i, iLen, j;
  
                  $(document).unbind('mousemove.AutoFill mouseup.AutoFill');
  
                  this.dom.borderTop.style.display = "none";
                  this.dom.borderRight.style.display = "none";
                  this.dom.borderBottom.style.display = "none";
                  this.dom.borderLeft.style.display = "none";
  
                  this.s.drag.dragging = false;
  
                  clearInterval(this.s.screen.interval);
  
                  var cells = [];
                  var table = this.dom.table;
                  var coordsStart = this._fnTargetCoords(this.s.drag.startTd);
                  var coordsEnd = this._fnTargetCoords(this.s.drag.endTd);
                  var columnIndex = function (visIdx) {
                      return that.s.dt.oApi._fnVisibleToColumnIndex(that.s.dt, visIdx);
                  };
  
                  // xxx - urgh - there must be a way of reducing this...
                  if (coordsStart.y <= coordsEnd.y) {
                      for (i = coordsStart.y; i <= coordsEnd.y; i++) {
                          if (coordsStart.x <= coordsEnd.x) {
                              for (j = coordsStart.x; j <= coordsEnd.x; j++) {
                                  cells.push({
                                      node: $('tbody>tr:eq(' + i + ')>td:eq(' + j + ')', table)[0],
                                      x: j - coordsStart.x,
                                      y: i - coordsStart.y,
                                      colIdx: columnIndex(j)
                                  });
                              }
                          } else {
                              for (j = coordsStart.x; j >= coordsEnd.x; j--) {
                                  cells.push({
                                      node: $('tbody>tr:eq(' + i + ')>td:eq(' + j + ')', table)[0],
                                      x: j - coordsStart.x,
                                      y: i - coordsStart.y,
                                      colIdx: columnIndex(j)
                                  });
                              }
                          }
                      }
                  } else {
                      for (i = coordsStart.y; i >= coordsEnd.y; i--) {
                          if (coordsStart.x <= coordsEnd.x) {
                              for (j = coordsStart.x; j <= coordsEnd.x; j++) {
                                  cells.push({
                                      node: $('tbody>tr:eq(' + i + ')>td:eq(' + j + ')', table)[0],
                                      x: j - coordsStart.x,
                                      y: i - coordsStart.y,
                                      colIdx: columnIndex(j)
                                  });
                              }
                          } else {
                              for (j = coordsStart.x; j >= coordsEnd.x; j--) {
                                  cells.push({
                                      node: $('tbody>tr:eq(' + i + ')>td:eq(' + j + ')', table)[0],
                                      x: coordsStart.x - j,
                                      y: coordsStart.y - i,
                                      colIdx: columnIndex(j)
                                  });
                              }
                          }
                      }
                  }
  
                  // An auto-fill requires 2 or more cells
                  if (cells.length <= 1) {
                      return;
                  }
  
                  var edited = [];
                  var previous;
  
                  for (i = 0, iLen = cells.length; i < iLen; i++) {
                      var cell = cells[i];
                      var column = this.s.columns[cell.colIdx];
                      var read = column.read.call(column, cell.node);
                      var stepValue = column.step.call(column, cell.node, read, previous, i, cell.x, cell.y);
  
                      column.write.call(column, cell.node, stepValue);
  
                      previous = stepValue;
                      edited.push({
                          cell: cell,
                          colIdx: cell.colIdx,
                          newValue: stepValue,
                          oldValue: read
                      });
                  }
  
                  if (this.c.complete !== null) {
                      this.c.complete.call(this, edited);
                  }
  
                  // In 1.10 we can do a static draw
                  if (DataTable.Api) {
                      new DataTable.Api(this.s.dt).draw(false);
                  } else {
                      this.s.dt.oInstance.fnDraw();
                  }
              },
  
  
              /**
               * Display the drag handle on mouse over cell
               *  @method  _fnFillerDisplay
               *  @param   {Object} e Event object
               *  @returns void
               */
              "_fnFillerDisplay": function (e) {
                  var filler = this.dom.filler;
  
                  /* Don't display automatically when dragging */
                  if (this.s.drag.dragging) {
                      return;
                  }
  
                  /* Check that we are allowed to AutoFill this column or not */
                  var nTd = (e.target.nodeName.toLowerCase() == 'td') ? e.target : $(e.target).parents('td')[0];
                  var iX = this._fnTargetCoords(nTd).column;
                  if (!this.s.columns[iX].enable) {
                      filler.style.display = "none";
                      return;
                  }
  
                  if (e.type == 'mouseover') {
                      this.dom.currentTarget = nTd;
                      this._fnFillerPosition(nTd);
  
                      filler.style.display = "block";
                  } else if (!e.relatedTarget || !e.relatedTarget.className.match(/AutoFill/)) {
                      filler.style.display = "none";
                  }
              },
  
  
              /**
               * Position the filler icon over a cell
               *  @method  _fnFillerPosition
               *  @param   {Node} nTd Cell to position filler icon over
               *  @returns void
               */
              "_fnFillerPosition": function (nTd) {
                  var offset = $(nTd).offset();
                  var filler = this.dom.filler;
                  filler.style.top = (offset.top - (this.s.filler.height / 2) - 1 + $(nTd).outerHeight()) + "px";
                  filler.style.left = (offset.left - (this.s.filler.width / 2) - 1 + $(nTd).outerWidth()) + "px";
              }
          };
  
  
  // Alias for access
          DataTable.AutoFill = AutoFill;
          DataTable.AutoFill = AutoFill;
  
  
          /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
           * Constants
           * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
  
          /**
           * AutoFill version
           *  @constant  version
           *  @type      String
           *  @default   See code
           */
          AutoFill.version = "1.2.1";
  
  
          /**
           * AutoFill defaults
           *  @namespace
           */
          AutoFill.defaults = {
              /**
               * Mode for dragging (restrict to y-axis only, x-axis only, either one or none):
               *
               *  * `y`      - y-axis only (default)
               *  * `x`      - x-axis only
               *  * `either` - either one, but not both axis at the same time
               *  * `both`   - multiple cells allowed
               *
               * @type {string}
               * @default `y`
               */
              mode: 'y',
  
              complete: null,
  
              /**
               * Column definition defaults
               *  @namespace
               */
              column: {
                  /**
                   * If AutoFill should be enabled on this column
                   *
                   * @type {boolean}
                   * @default true
                   */
                  enable: true,
  
                  /**
                   * Allow automatic increment / decrement on this column if a number
                   * is found.
                   *
                   * @type {boolean}
                   * @default true
                   */
                  increment: true,
  
                  /**
                   * Cell read function
                   *
                   * Default function will simply read the value from the HTML of the
                   * cell.
                   *
                   * @type   {function}
                   * @param  {node} cell `th` / `td` element to read the value from
                   * @return {string}    Data that has been read
                   */
                  read: function (cell) {
                      return $(cell).html();
                  },
  
                  /**
                   * Cell write function
                   *
                   * Default function will simply write to the HTML and tell the DataTable
                   * to update.
                   *
                   * @type   {function}
                   * @param  {node} cell `th` / `td` element to write the value to
                   * @return {string}    Data two write
                   */
                  write: function (cell, val) {
                      var table = $(cell).parents('table');
                      if (DataTable.Api) {
                          // 1.10
                          table.DataTable().cell(cell).data(val);
                      } else {
                          // 1.9
                          var dt = table.dataTable();
                          var pos = dt.fnGetPosition(cell);
                          dt.fnUpdate(val, pos[0], pos[2], false);
                      }
                  },
  
                  /**
                   * Step function. This provides the ability to customise how the values
                   * are incremented.
                   *
                   * @param  {node} cell `th` / `td` element that is being operated upon
                   * @param  {string} read Cell value from `read` function
                   * @param  {string} last Value of the previous cell
                   * @param  {integer} i Loop counter
                   * @param  {integer} x Cell x-position in the current auto-fill. The
                   *   starting cell is coordinate 0 regardless of its physical position
                   *   in the DataTable.
                   * @param  {integer} y Cell y-position in the current auto-fill. The
                   *   starting cell is coordinate 0 regardless of its physical position
                   *   in the DataTable.
                   * @return {string} Value to write
                   */
                  step: function (cell, read, last, i, x, y) {
                      // Increment a number if it is found
                      var re = /(\-?\d+)/;
                      var match = this.increment && last ? last.match(re) : null;
                      if (match) {
                          return last.replace(re, parseInt(match[1], 10) + (x < 0 || y < 0 ? -1 : 1));
                      }
                      return last === undefined ?
                          read :
                          last;
                  }
              }
          };
  
          return AutoFill;
      };
  
  
  // Define as an AMD module if possible
      if (typeof define === 'function' && define.amd) {
          define(['jquery', 'datatables'], factory);
      } else if (typeof exports === 'object') {
          // Node/CommonJS
          factory(require('jquery'), require('datatables'));
      } else if (jQuery && !jQuery.fn.dataTable.AutoFill) {
          // Otherwise simply initialise as normal, stopping multiple evaluation
          factory(jQuery, jQuery.fn.dataTable);
      }
  
  
  }(window, document));
  
  