$(document).ready(function() {

    $(".navBar li a").hover(
      function() {
          $(this).stop().animate({ backgroundColor: "#EFA4A4" }, 400);
      },
      function() {
          $(this).stop().animate({ backgroundColor: "#D1DFD7" }, 700);
      }
    );

    //Current Time

    {

        //location
        //location
        try {
            var lat = geoip_latitude();
            var lon = geoip_longitude();
            var city = geoip_city();


            helixtime = new Date()
            hrstime = helixtime.getHours()
            if (hrstime < 7) { timemsg = "You're up really early! " + "in " + city }
            if (hrstime > 6 && hrstime < 12) { timemsg = "Good morning! " + "to " + city }
            if (hrstime > 11 && hrstime < 18) { timemsg = "Good afternoon! " + "to " + city }
            if (hrstime > 17) { timemsg = "Good evening! " + "to " + city }
        }
        catch (e) {
            return false;
        }

    }

    $('.chornoGreet').text(timemsg);

});

(function() {

    var _typeface_js = {

        faces: {},

        loadFace: function(typefaceData) {

            var familyName = typefaceData.familyName.toLowerCase();

            if (!this.faces[familyName]) {
                this.faces[familyName] = {};
            }
            if (!this.faces[familyName][typefaceData.cssFontWeight]) {
                this.faces[familyName][typefaceData.cssFontWeight] = {};
            }

            var face = this.faces[familyName][typefaceData.cssFontWeight][typefaceData.cssFontStyle] = typefaceData;
            face.loaded = true;
        },

        log: function(message) {

            if (this.quiet) {
                return;
            }

            message = "typeface.js: " + message;

            if (this.customLogFn) {
                this.customLogFn(message);

            } else if (window.console && window.console.log) {
                window.console.log(message);
            }

        },

        pixelsFromPoints: function(face, style, points, dimension) {
            var pixels = points * parseInt(style.fontSize) * 72 / (face.resolution * 100);
            if (dimension == 'horizontal' && style.fontStretchPercent) {
                pixels *= style.fontStretchPercent;
            }
            return pixels;
        },

        pointsFromPixels: function(face, style, pixels, dimension) {
            var points = pixels * face.resolution / (parseInt(style.fontSize) * 72 / 100);
            if (dimension == 'horizontal' && style.fontStretchPrecent) {
                points *= style.fontStretchPercent;
            }
            return points;
        },

        cssFontWeightMap: {
            normal: 'normal',
            bold: 'bold',
            400: 'normal',
            700: 'bold'
        },

        cssFontStretchMap: {
            'ultra-condensed': 0.55,
            'extra-condensed': 0.77,
            'condensed': 0.85,
            'semi-condensed': 0.93,
            'normal': 1,
            'semi-expanded': 1.07,
            'expanded': 1.15,
            'extra-expanded': 1.23,
            'ultra-expanded': 1.45,
            'default': 1
        },

        fallbackCharacter: '.',

        configure: function(args) {
            var configurableOptionNames = ['customLogFn', 'customClassNameRegex', 'customTypefaceElementsList', 'quiet', 'verbose', 'disableSelection'];

            for (var i = 0; i < configurableOptionNames.length; i++) {
                var optionName = configurableOptionNames[i];
                if (args[optionName]) {
                    if (optionName == 'customLogFn') {
                        if (typeof args[optionName] != 'function') {
                            throw "customLogFn is not a function";
                        } else {
                            this.customLogFn = args.customLogFn;
                        }
                    } else {
                        this[optionName] = args[optionName];
                    }
                }
            }
        },

        getTextExtents: function(face, style, text) {
            var extentX = 0;
            var extentY = 0;
            var horizontalAdvance;

            var textLength = text.length;
            for (var i = 0; i < textLength; i++) {
                var glyph = face.glyphs[text.charAt(i)] ? face.glyphs[text.charAt(i)] : face.glyphs[this.fallbackCharacter];
                var letterSpacingAdjustment = this.pointsFromPixels(face, style, style.letterSpacing);
                extentX += Math.max(glyph.ha, glyph.x_max) + letterSpacingAdjustment;
                horizontalAdvance += glyph.ha + letterSpacingAdjustment;
            }
            return {
                x: extentX,
                y: extentY,
                ha: horizontalAdvance

            };
        },

        pixelsFromCssAmount: function(cssAmount, defaultValue, element) {

            var matches = undefined;

            if (cssAmount == 'normal') {
                return defaultValue;

            } else if (matches = cssAmount.match(/([\-\d+\.]+)px/)) {
                return matches[1];

            } else {
                // thanks to Dean Edwards for this very sneaky way to get IE to convert 
                // relative values to pixel values

                var pixelAmount;

                var leftInlineStyle = element.style.left;
                var leftRuntimeStyle = element.runtimeStyle.left;

                element.runtimeStyle.left = element.currentStyle.left;

                if (!cssAmount.match(/\d(px|pt)$/)) {
                    element.style.left = '1em';
                } else {
                    element.style.left = cssAmount || 0;
                }

                pixelAmount = element.style.pixelLeft;

                element.style.left = leftInlineStyle;
                element.runtimeStyle.left = leftRuntimeStyle;

                return pixelAmount || defaultValue;
            }
        },

        capitalizeText: function(text) {
            return text.replace(/(^|\s)[a-z]/g, function(match) { return match.toUpperCase() });
        },

        getElementStyle: function(e) {
            if (window.getComputedStyle) {
                return window.getComputedStyle(e, '');

            } else if (e.currentStyle) {
                return e.currentStyle;
            }
        },

        getRenderedText: function(e) {

            var browserStyle = this.getElementStyle(e.parentNode);

            var inlineStyleAttribute = e.parentNode.getAttribute('style');
            if (inlineStyleAttribute && typeof (inlineStyleAttribute) == 'object') {
                inlineStyleAttribute = inlineStyleAttribute.cssText;
            }

            if (inlineStyleAttribute) {

                var inlineStyleDeclarations = inlineStyleAttribute.split(/\s*\;\s*/);

                var inlineStyle = {};
                for (var i = 0; i < inlineStyleDeclarations.length; i++) {
                    var declaration = inlineStyleDeclarations[i];
                    var declarationOperands = declaration.split(/\s*\:\s*/);
                    inlineStyle[declarationOperands[0]] = declarationOperands[1];
                }
            }

            var style = {
                color: browserStyle.color,
                fontFamily: browserStyle.fontFamily.split(/\s*,\s*/)[0].replace(/(^"|^'|'$|"$)/g, '').toLowerCase(),
                fontSize: this.pixelsFromCssAmount(browserStyle.fontSize, 12, e.parentNode),
                fontWeight: this.cssFontWeightMap[browserStyle.fontWeight],
                fontStyle: browserStyle.fontStyle ? browserStyle.fontStyle : 'normal',
                fontStretchPercent: this.cssFontStretchMap[inlineStyle && inlineStyle['font-stretch'] ? inlineStyle['font-stretch'] : 'default'],
                textDecoration: browserStyle.textDecoration,
                lineHeight: this.pixelsFromCssAmount(browserStyle.lineHeight, 'normal', e.parentNode),
                letterSpacing: this.pixelsFromCssAmount(browserStyle.letterSpacing, 0, e.parentNode),
                textTransform: browserStyle.textTransform
            };

            var face;
            if (
			this.faces[style.fontFamily]
			&& this.faces[style.fontFamily][style.fontWeight]
		) {
                face = this.faces[style.fontFamily][style.fontWeight][style.fontStyle];
            }

            var text = e.nodeValue;

            if (
			e.previousSibling
			&& e.previousSibling.nodeType == 1
			&& e.previousSibling.tagName != 'BR'
			&& this.getElementStyle(e.previousSibling).display.match(/inline/)
		) {
                text = text.replace(/^\s+/, ' ');
            } else {
                text = text.replace(/^\s+/, '');
            }

            if (
			e.nextSibling
			&& e.nextSibling.nodeType == 1
			&& e.nextSibling.tagName != 'BR'
			&& this.getElementStyle(e.nextSibling).display.match(/inline/)
		) {
                text = text.replace(/\s+$/, ' ');
            } else {
                text = text.replace(/\s+$/, '');
            }

            text = text.replace(/\s+/g, ' ');

            if (style.textTransform && style.textTransform != 'none') {
                switch (style.textTransform) {
                    case 'capitalize':
                        text = this.capitalizeText(text);
                        break;
                    case 'uppercase':
                        text = text.toUpperCase();
                        break;
                    case 'lowercase':
                        text = text.toLowerCase();
                        break;
                }
            }

            if (!face) {
                var excerptLength = 12;
                var textExcerpt = text.substring(0, excerptLength);
                if (text.length > excerptLength) {
                    textExcerpt += '...';
                }

                var fontDescription = style.fontFamily;
                if (style.fontWeight != 'normal') fontDescription += ' ' + style.fontWeight;
                if (style.fontStyle != 'normal') fontDescription += ' ' + style.fontStyle;

                this.log("couldn't find typeface font: " + fontDescription + ' for text "' + textExcerpt + '"');
                return;
            }

            var words = text.split(/\b(?=\w)/);

            var containerSpan = document.createElement('span');
            containerSpan.className = 'typeface-js-vector-container';

            var wordsLength = words.length
            for (var i = 0; i < wordsLength; i++) {
                var word = words[i];

                var vector = this.renderWord(face, style, word);

                if (vector) {
                    containerSpan.appendChild(vector.element);

                    if (!this.disableSelection) {
                        var selectableSpan = document.createElement('span');
                        selectableSpan.className = 'typeface-js-selected-text';

                        var wordNode = document.createTextNode(word);
                        selectableSpan.appendChild(wordNode);

                        if (this.vectorBackend != 'vml') {
                            selectableSpan.style.marginLeft = -1 * (vector.width + 1) + 'px';
                        }
                        selectableSpan.targetWidth = vector.width;
                        //selectableSpan.style.lineHeight = 1 + 'px';

                        if (this.vectorBackend == 'vml') {
                            vector.element.appendChild(selectableSpan);
                        } else {
                            containerSpan.appendChild(selectableSpan);
                        }
                    }
                }
            }

            return containerSpan;
        },

        renderDocument: function(callback) {

            if (!callback)
                callback = function(e) { e.style.visibility = 'visible' };

            var elements = document.getElementsByTagName('*');

            var elementsLength = elements.length;
            for (var i = 0; i < elements.length; i++) {
                if (elements[i].className.match(/(^|\s)typeface-js(\s|$)/) || elements[i].tagName.match(/^(H1|H2|H3|H4|H5|H6)$/)) {
                    this.replaceText(elements[i]);
                    if (typeof callback == 'function') {
                        callback(elements[i]);
                    }
                }
            }

            if (this.vectorBackend == 'vml') {
                // lamely work around IE's quirky leaving off final dynamic shapes
                var dummyShape = document.createElement('v:shape');
                dummyShape.style.display = 'none';
                document.body.appendChild(dummyShape);
            }
        },

        replaceText: function(e) {

            var childNodes = [];
            var childNodesLength = e.childNodes.length;

            for (var i = 0; i < childNodesLength; i++) {
                this.replaceText(e.childNodes[i]);
            }

            if (e.nodeType == 3 && e.nodeValue.match(/\S/)) {
                var parentNode = e.parentNode;

                if (parentNode.className == 'typeface-js-selected-text') {
                    return;
                }

                var renderedText = this.getRenderedText(e);

                if (
				parentNode.tagName == 'A'
				&& this.vectorBackend == 'vml'
				&& this.getElementStyle(parentNode).display == 'inline'
			) {
                    // something of a hack, use inline-block to get IE to accept clicks in whitespace regions
                    parentNode.style.display = 'inline-block';
                    parentNode.style.cursor = 'pointer';
                }

                if (this.getElementStyle(parentNode).display == 'inline') {
                    parentNode.style.display = 'inline-block';
                }

                if (renderedText) {
                    if (parentNode.replaceChild) {
                        parentNode.replaceChild(renderedText, e);
                    } else {
                        parentNode.insertBefore(renderedText, e);
                        parentNode.removeChild(e);
                    }
                    if (this.vectorBackend == 'vml') {
                        renderedText.innerHTML = renderedText.innerHTML;
                    }

                    var childNodesLength = renderedText.childNodes.length
                    for (var i; i < childNodesLength; i++) {

                        // do our best to line up selectable text with rendered text

                        var e = renderedText.childNodes[i];
                        if (e.hasChildNodes() && !e.targetWidth) {
                            e = e.childNodes[0];
                        }

                        if (e && e.targetWidth) {
                            var letterSpacingCount = e.innerHTML.length;
                            var wordSpaceDelta = e.targetWidth - e.offsetWidth;
                            var letterSpacing = wordSpaceDelta / (letterSpacingCount || 1);

                            if (this.vectorBackend == 'vml') {
                                letterSpacing = Math.ceil(letterSpacing);
                            }

                            e.style.letterSpacing = letterSpacing + 'px';
                            e.style.width = e.targetWidth + 'px';
                        }
                    }
                }
            }
        },

        applyElementVerticalMetrics: function(face, style, e) {

            if (style.lineHeight == 'normal') {
                style.lineHeight = this.pixelsFromPoints(face, style, face.lineHeight);
            }

            var cssLineHeightAdjustment = style.lineHeight - this.pixelsFromPoints(face, style, face.lineHeight);

            e.style.marginTop = Math.round(cssLineHeightAdjustment / 2) + 'px';
            e.style.marginBottom = Math.round(cssLineHeightAdjustment / 2) + 'px';

        },

        vectorBackends: {

            canvas: {

                _initializeSurface: function(face, style, text) {

                    var extents = this.getTextExtents(face, style, text);

                    var canvas = document.createElement('canvas');
                    if (this.disableSelection) {
                        canvas.innerHTML = text;
                    }

                    canvas.height = Math.round(this.pixelsFromPoints(face, style, face.lineHeight));
                    canvas.width = Math.round(this.pixelsFromPoints(face, style, extents.x, 'horizontal'));

                    this.applyElementVerticalMetrics(face, style, canvas);

                    if (extents.x > extents.ha)
                        canvas.style.marginRight = Math.round(this.pixelsFromPoints(face, style, extents.x - extents.ha, 'horizontal')) + 'px';

                    var ctx = canvas.getContext('2d');

                    var pointScale = this.pixelsFromPoints(face, style, 1);
                    ctx.scale(pointScale * style.fontStretchPercent, -1 * pointScale);
                    ctx.translate(0, -1 * face.ascender);
                    ctx.fillStyle = style.color;

                    return { context: ctx, canvas: canvas };
                },

                _renderGlyph: function(ctx, face, char, style) {

                    var glyph = face.glyphs[char];

                    if (!glyph) {
                        //this.log.error("glyph not defined: " + char);
                        return this.renderGlyph(ctx, face, this.fallbackCharacter, style);
                    }

                    if (glyph.o) {

                        var outline;
                        if (glyph.cached_outline) {
                            outline = glyph.cached_outline;
                        } else {
                            outline = glyph.o.split(' ');
                            glyph.cached_outline = outline;
                        }

                        var outlineLength = outline.length;
                        for (var i = 0; i < outlineLength; ) {

                            var action = outline[i++];

                            switch (action) {
                                case 'm':
                                    ctx.moveTo(outline[i++], outline[i++]);
                                    break;
                                case 'l':
                                    ctx.lineTo(outline[i++], outline[i++]);
                                    break;

                                case 'q':
                                    var cpx = outline[i++];
                                    var cpy = outline[i++];
                                    ctx.quadraticCurveTo(outline[i++], outline[i++], cpx, cpy);
                                    break;
                            }
                        }
                    }
                    if (glyph.ha) {
                        var letterSpacingPoints =
						style.letterSpacing && style.letterSpacing != 'normal' ?
							this.pointsFromPixels(face, style, style.letterSpacing) :
							0;

                        ctx.translate(glyph.ha + letterSpacingPoints, 0);
                    }
                },

                _renderWord: function(face, style, text) {
                    var surface = this.initializeSurface(face, style, text);
                    var ctx = surface.context;
                    var canvas = surface.canvas;
                    ctx.beginPath();
                    ctx.save();

                    var chars = text.split('');
                    var charsLength = chars.length;
                    for (var i = 0; i < charsLength; i++) {
                        this.renderGlyph(ctx, face, chars[i], style);
                    }

                    ctx.fill();

                    if (style.textDecoration == 'underline') {

                        ctx.beginPath();
                        ctx.moveTo(0, face.underlinePosition);
                        ctx.restore();
                        ctx.lineTo(0, face.underlinePosition);
                        ctx.strokeStyle = style.color;
                        ctx.lineWidth = face.underlineThickness;
                        ctx.stroke();
                    }

                    return { element: ctx.canvas, width: Math.floor(canvas.width) };

                }
            },

            vml: {

                _initializeSurface: function(face, style, text) {

                    var shape = document.createElement('v:shape');

                    var extents = this.getTextExtents(face, style, text);

                    shape.style.width = shape.style.height = style.fontSize + 'px';
                    shape.style.marginLeft = '-1px'; // this seems suspect...

                    if (extents.x > extents.ha) {
                        shape.style.marginRight = this.pixelsFromPoints(face, style, extents.x - extents.ha, 'horizontal') + 'px';
                    }

                    this.applyElementVerticalMetrics(face, style, shape);

                    var resolutionScale = face.resolution * 100 / 72;
                    shape.coordsize = (resolutionScale / style.fontStretchPercent) + "," + resolutionScale;

                    shape.coordorigin = '0,' + face.ascender;
                    shape.style.flip = 'y';

                    shape.fillColor = style.color;
                    shape.stroked = false;

                    shape.path = 'hh m 0,' + face.ascender + ' l 0,' + face.descender + ' ';

                    return shape;
                },

                _renderGlyph: function(shape, face, char, offsetX, style, vmlSegments) {

                    var glyph = face.glyphs[char];

                    if (!glyph) {
                        this.log("glyph not defined: " + char);
                        this.renderGlyph(shape, face, this.fallbackCharacter, offsetX, style);
                        return;
                    }

                    vmlSegments.push('m');

                    if (glyph.o) {

                        var outline, outlineLength;

                        if (glyph.cached_outline) {
                            outline = glyph.cached_outline;
                            outlineLength = outline.length;
                        } else {
                            outline = glyph.o.split(' ');
                            outlineLength = outline.length;

                            for (var i = 0; i < outlineLength; ) {

                                switch (outline[i++]) {
                                    case 'q':
                                        outline[i] = Math.round(outline[i++]);
                                        outline[i] = Math.round(outline[i++]);
                                    case 'm':
                                    case 'l':
                                        outline[i] = Math.round(outline[i++]);
                                        outline[i] = Math.round(outline[i++]);
                                        break;
                                }
                            }

                            glyph.cached_outline = outline;
                        }

                        var prevX, prevY;

                        for (var i = 0; i < outlineLength; ) {

                            var action = outline[i++];

                            var x = outline[i++] + offsetX;
                            var y = outline[i++];

                            switch (action) {
                                case 'm':
                                    vmlSegments.push('xm ', x, ',', y);
                                    break;

                                case 'l':
                                    vmlSegments.push('l ', x, ',', y);
                                    break;

                                case 'q':
                                    var cpx = outline[i++] + offsetX;
                                    var cpy = outline[i++];

                                    var cp1x = Math.round(prevX + 2.0 / 3.0 * (cpx - prevX));
                                    var cp1y = Math.round(prevY + 2.0 / 3.0 * (cpy - prevY));

                                    var cp2x = Math.round(cp1x + (x - prevX) / 3.0);
                                    var cp2y = Math.round(cp1y + (y - prevY) / 3.0);

                                    vmlSegments.push('c ', cp1x, ',', cp1y, ',', cp2x, ',', cp2y, ',', x, ',', y);
                                    break;
                            }

                            prevX = x;
                            prevY = y;
                        }
                    }

                    vmlSegments.push('x e');
                    return vmlSegments;
                },

                _renderWord: function(face, style, text) {
                    var offsetX = 0;
                    var shape = this.initializeSurface(face, style, text);

                    var letterSpacingPoints =
					style.letterSpacing && style.letterSpacing != 'normal' ?
						this.pointsFromPixels(face, style, style.letterSpacing) :
						0;

                    letterSpacingPoints = Math.round(letterSpacingPoints);
                    var chars = text.split('');
                    var vmlSegments = [];
                    for (var i = 0; i < chars.length; i++) {
                        var char = chars[i];
                        vmlSegments = this.renderGlyph(shape, face, char, offsetX, style, vmlSegments);
                        offsetX += face.glyphs[char].ha + letterSpacingPoints;
                    }

                    // make sure to preserve trailing whitespace
                    shape.path += vmlSegments.join('') + 'm ' + offsetX + ' 0 l ' + offsetX + ' ' + face.ascender;

                    return {
                        element: shape,
                        width: Math.floor(this.pixelsFromPoints(face, style, offsetX, 'horizontal'))
                    };
                }

            }

        },

        setVectorBackend: function(backend) {

            this.vectorBackend = backend;
            var backendFunctions = ['renderWord', 'initializeSurface', 'renderGlyph'];

            for (var i = 0; i < backendFunctions.length; i++) {
                var backendFunction = backendFunctions[i];
                this[backendFunction] = this.vectorBackends[backend]['_' + backendFunction];
            }
        },

        initialize: function() {

            // quit if this function has already been called
            if (arguments.callee.done) return;

            // flag this function so we don't do the same thing twice
            arguments.callee.done = true;

            // kill the timer
            if (window._typefaceTimer) clearInterval(_typefaceTimer);

            this.renderDocument(function(e) { e.style.visibility = 'visible' });

        }

    };

    // IE won't accept real selectors...
    var typefaceSelectors = ['.typeface-js', 'h1', 'h2', 'h3', 'h4', 'h5', 'h6'];

    if (document.createStyleSheet) {

        var styleSheet = document.createStyleSheet();
        for (var i = 0; i < typefaceSelectors.length; i++) {
            var selector = typefaceSelectors[i];
            styleSheet.addRule(selector, 'visibility: hidden');
        }

        styleSheet.addRule(
		'.typeface-js-selected-text',
		'-ms-filter: \
			"Chroma(color=black) \
			progid:DXImageTransform.Microsoft.MaskFilter(Color=white) \
			progid:DXImageTransform.Microsoft.MaskFilter(Color=blue) \
			alpha(opacity=30)" !important; \
		color: black; \
		font-family: Modern; \
		position: absolute; \
		white-space: pre; \
		filter: alpha(opacity=0);'
	);

        styleSheet.addRule(
		'.typeface-js-vector-container',
		'position: relative'
	);

    } else if (document.styleSheets && document.styleSheets.length) {

        var styleSheet = document.styleSheets[0];
        document.styleSheets[0].insertRule(typefaceSelectors.join(',') + ' { visibility: hidden; }', styleSheet.cssRules.length);

        document.styleSheets[0].insertRule(
		'.typeface-js-selected-text { \
			color: rgba(128, 128, 128, 0); \
			opacity: 0.30; \
			position: absolute; \
			font-family: Arial, sans-serif; \
			white-space: pre \
		}',
		styleSheet.cssRules.length
	);

        try {
            // set selection style for Mozilla / Firefox
            document.styleSheets[0].insertRule(
			'.typeface-js-selected-text::-moz-selection { background: blue; }',
			styleSheet.cssRules.length
		);

        } catch (e) { };

        try {
            // set styles for browsers with CSS3 selectors (Safari, Chrome)
            document.styleSheets[0].insertRule(
			'.typeface-js-selected-text::selection { background: blue; }',
			styleSheet.cssRules.length
		);

        } catch (e) { };

        // most unfortunately, sniff for WebKit's quirky selection behavior
        if (/WebKit/i.test(navigator.userAgent)) {
            document.styleSheets[0].insertRule(
			'.typeface-js-vector-container { position: relative }',
			styleSheet.cssRules.length
		);
        }

    }

    var backend = !!(window.attachEvent && !window.opera) ? 'vml' : window.CanvasRenderingContext2D || document.createElement('canvas').getContext ? 'canvas' : null;

    if (backend == 'vml') {

        document.namespaces.add("v", "urn:schemas-microsoft-com:vml", "#default#VML");

        var styleSheet = document.createStyleSheet();
        styleSheet.addRule('v\\:shape', "display: inline-block;");
    }

    _typeface_js.setVectorBackend(backend);
    window._typeface_js = _typeface_js;

    if (/WebKit/i.test(navigator.userAgent)) {

        var _typefaceTimer = setInterval(function() {
            if (/loaded|complete/.test(document.readyState)) {
                _typeface_js.initialize();
            }
        }, 10);
    }

    if (document.addEventListener) {
        window.addEventListener('DOMContentLoaded', function() { _typeface_js.initialize() }, false);
    }

    /*@cc_on@*/
    /*@if (@_win32)

    document.write("<script id=__ie_onload_typeface defer src=//:><\/script>");
    var script = document.getElementById("__ie_onload_typeface");
    script.onreadystatechange = function() {
        if (this.readyState == "complete") {
            _typeface_js.initialize();
        }
    };

    /*@end@*/

    try { console.log('initializing typeface.js') } catch (e) { };

})();



/*
* jQuery Color Animations
* Copyright 2007 John Resig
* Released under the MIT and GPL licenses.
*/

(function(jQuery) {

    // We override the animation for all of these color styles
    jQuery.each(['backgroundColor', 'borderBottomColor', 'borderLeftColor', 'borderRightColor', 'borderTopColor', 'color', 'outlineColor'], function(i, attr) {
        jQuery.fx.step[attr] = function(fx) {
        if (fx.state == 0 || fx.start.constructor != Array || fx.end.constructor != Array) {
                fx.start = getColor(fx.elem, attr);
                fx.end = getRGB(fx.end);
            }

            fx.elem.style[attr] = "rgb(" + [
				Math.max(Math.min(parseInt((fx.pos * (fx.end[0] - fx.start[0])) + fx.start[0]), 255), 0),
				Math.max(Math.min(parseInt((fx.pos * (fx.end[1] - fx.start[1])) + fx.start[1]), 255), 0),
				Math.max(Math.min(parseInt((fx.pos * (fx.end[2] - fx.start[2])) + fx.start[2]), 255), 0)
			].join(",") + ")";
        }
    });

    // Color Conversion functions from highlightFade
    // By Blair Mitchelmore
    // http://jquery.offput.ca/highlightFade/

    // Parse strings looking for color tuples [255,255,255]
    function getRGB(color) {
        var result;

        // Check if we're already dealing with an array of colors
        if (color && color.constructor == Array && color.length == 3)
            return color;

        // Look for rgb(num,num,num)
        if (result = /rgb\(\s*([0-9]{1,3})\s*,\s*([0-9]{1,3})\s*,\s*([0-9]{1,3})\s*\)/.exec(color))
            return [parseInt(result[1]), parseInt(result[2]), parseInt(result[3])];

        // Look for rgb(num%,num%,num%)
        if (result = /rgb\(\s*([0-9]+(?:\.[0-9]+)?)\%\s*,\s*([0-9]+(?:\.[0-9]+)?)\%\s*,\s*([0-9]+(?:\.[0-9]+)?)\%\s*\)/.exec(color))
            return [parseFloat(result[1]) * 2.55, parseFloat(result[2]) * 2.55, parseFloat(result[3]) * 2.55];

        // Look for #a0b1c2
        if (result = /#([a-fA-F0-9]{2})([a-fA-F0-9]{2})([a-fA-F0-9]{2})/.exec(color))
            return [parseInt(result[1], 16), parseInt(result[2], 16), parseInt(result[3], 16)];

        // Look for #fff
        if (result = /#([a-fA-F0-9])([a-fA-F0-9])([a-fA-F0-9])/.exec(color))
            return [parseInt(result[1] + result[1], 16), parseInt(result[2] + result[2], 16), parseInt(result[3] + result[3], 16)];

        // Otherwise, we're most likely dealing with a named color
        return colors[jQuery.trim(color).toLowerCase()];
    }

    function getColor(elem, attr) {
        var color;

        do {
            color = jQuery.curCSS(elem, attr);

            // Keep going until we find an element that has color, or we hit the body
            if (color != '' && color != 'transparent' || jQuery.nodeName(elem, "body"))
                break;

            attr = "backgroundColor";
        } while (elem = elem.parentNode);

        return getRGB(color);
    };

    // Some named colors to work with
    // From Interface by Stefan Petre
    // http://interface.eyecon.ro/

    var colors = {
        aqua: [0, 255, 255],
        azure: [240, 255, 255],
        beige: [245, 245, 220],
        black: [0, 0, 0],
        blue: [0, 0, 255],
        brown: [165, 42, 42],
        cyan: [0, 255, 255],
        darkblue: [0, 0, 139],
        darkcyan: [0, 139, 139],
        darkgrey: [169, 169, 169],
        darkgreen: [0, 100, 0],
        darkkhaki: [189, 183, 107],
        darkmagenta: [139, 0, 139],
        darkolivegreen: [85, 107, 47],
        darkorange: [255, 140, 0],
        darkorchid: [153, 50, 204],
        darkred: [139, 0, 0],
        darksalmon: [233, 150, 122],
        darkviolet: [148, 0, 211],
        fuchsia: [255, 0, 255],
        gold: [255, 215, 0],
        green: [0, 128, 0],
        indigo: [75, 0, 130],
        khaki: [240, 230, 140],
        lightblue: [173, 216, 230],
        lightcyan: [224, 255, 255],
        lightgreen: [144, 238, 144],
        lightgrey: [211, 211, 211],
        lightpink: [255, 182, 193],
        lightyellow: [255, 255, 224],
        lime: [0, 255, 0],
        magenta: [255, 0, 255],
        maroon: [128, 0, 0],
        navy: [0, 0, 128],
        olive: [128, 128, 0],
        orange: [255, 165, 0],
        pink: [255, 192, 203],
        purple: [128, 0, 128],
        violet: [128, 0, 128],
        red: [255, 0, 0],
        silver: [192, 192, 192],
        white: [255, 255, 255],
        yellow: [255, 255, 0]
    };

})(jQuery);