docs: function (index, old) {
  				var tick = this,
  					major = !tick.minor,
  					label = tick.label,
  					pos = tick.pos,
  					labelOptions = options.labels,
  					gridLine = tick.gridLine,
  					gridLineWidth = major ? options.gridLineWidth : options.minorGridLineWidth,
  					gridLineColor = major ? options.gridLineColor : options.minorGridLineColor,
  					dashStyle = major ?
  						options.gridLineDashStyle :
  						options.minorGridLineDashStyle,
  					gridLinePath,
  					mark = tick.mark,
  					markPath,
  					tickLength = major ? options.tickLength : options.minorTickLength,
  					tickWidth = major ? options.tickWidth : (options.minorTickWidth || 0),
  					tickColor = major ? options.tickColor : options.minorTickColor,
  					tickPosition = major ? options.tickPosition : options.minorTickPosition,
  					step = labelOptions.step,
  					cHeight = (old && oldChartHeight) || chartHeight,
  					attribs,
  					x,
  					y;
  
  				// get x and y position for ticks and labels
  				x = horiz ?
  					translate(pos + tickmarkOffset, null, null, old) + transB :
  					plotLeft + offset + (opposite ? ((old && oldChartWidth) || chartWidth) - marginRight - plotLeft : 0);
  
  				y = horiz ?
  					cHeight - marginBottom + offset - (opposite ? plotHeight : 0) :
  					cHeight - translate(pos + tickmarkOffset, null, null, old) - transB;
  
  				// create the grid line
  				if (gridLineWidth) {
  					gridLinePath = getPlotLinePath(pos + tickmarkOffset, gridLineWidth, old);
  
  					if (gridLine === UNDEFINED) {
  						attribs = {
  							stroke: gridLineColor,
  							'stroke-width': gridLineWidth
  						};
  						if (dashStyle) {
  							attribs.dashstyle = dashStyle;
  						}
  						if (major) {
  							attribs.zIndex = 1;
  						}
  						tick.gridLine = gridLine =
  							gridLineWidth ?
  								renderer.path(gridLinePath)
  									.attr(attribs).add(gridGroup) :
  								null;
  					}
  
  					// If the parameter 'old' is set, the current call will be followed
  					// by another call, therefore do not do any animations this time
  					if (!old && gridLine && gridLinePath) {
  						gridLine.animate({
  							d: gridLinePath
  						});
  					}
  				}
  
  				// create the tick mark
  				if (tickWidth) {
  
  					// negate the length
  					if (tickPosition === 'inside') {
  						tickLength = -tickLength;
  					}
  					if (opposite) {
  						tickLength = -tickLength;
  					}
  
  					markPath = renderer.crispLine([
  						M,
  						x,
  						y,
  						L,
  						x + (horiz ? 0 : -tickLength),
  						y + (horiz ? tickLength : 0)
  					], tickWidth);
  
  					if (mark) { // updating
  						mark.animate({
  							d: markPath
  						});
  					} else { // first time
  						tick.mark = renderer.path(
  							markPath
  						).attr({
  							stroke: tickColor,
  							'stroke-width': tickWidth
  						}).add(axisGroup);
  					}
  				}
  
  				// the label is created on init - now move it into place
  				if (label && !isNaN(x)) {
  					x = x + labelOptions.x - (tickmarkOffset && horiz ?
  						tickmarkOffset * transA * (reversed ? -1 : 1) : 0);
  					y = y + labelOptions.y - (tickmarkOffset && !horiz ?
  						tickmarkOffset * transA * (reversed ? 1 : -1) : 0);
  
  					// vertically centered
  					if (!defined(labelOptions.y)) {
  						y += pInt(label.styles.lineHeight) * 0.9 - label.getBBox().height / 2;
  					}
  
  
  					// correct for staggered labels
  					if (staggerLines) {
  						y += (index / (step || 1) % staggerLines) * 16;
  					}
  					// apply step
  					if (step) {
  						// show those indices dividable by step
  						label[index % step ? 'hide' : 'show']();
  					}
  
  					label[tick.isNew ? 'attr' : 'animate']({
  						x: x,
  						y: y
  					});
  				}
  
  				tick.isNew = false;
  			}