social media network

English

_ga_CEP9QLJYWD

_gcl_au

csrftoken

The domain name 'downdetector.disqus.com' uses the commercial generic top-level domain (.com), featuring subdomain 'downdetector'. Count 6 characters in 'disqus' containing 2 vowels alongside 4 consonants. Segmentation suggests four words: d, is, qu, s. Average segment length settles at 1.5 characters. No strong language cues emerged from the frequency lists.

html/1d/ed/1dedf8aa-89f9-4d7e-b703-bee87d1b1e13_fallback.html.gz

Log In | Disqus

csrfmiddlewaretoken

username

password

g-recaptcha-response

html/1d/ed/1dedf8aa-89f9-4d7e-b703-bee87d1b1e13.html.gz

require-trusted-types-for 'script'; report-uri https://csp.withgoogle.com/csp/recaptcha-scs

script-src 'report-sample' 'nonce-Is8mGZntHnAh1J8E8VghKA' 'unsafe-inline' 'strict-dynamic' https: http: 'unsafe-eval';object-src 'none';base-uri 'self';report-uri https://csp.withgoogle.com/csp/recaptcha/1

script-src 'none'; form-action 'none'; frame-src 'none'; report-uri https://csp.withgoogle.com/csp/scaffolding/ascnsrsggc:112:0

require-trusted-types-for 'script'; report-uri https://csp.withgoogle.com/csp/apps-themes

script-src 'report-sample' 'nonce-k019uD3oWSto-37jqLG9TQ' 'unsafe-inline' 'strict-dynamic' https: http: 'unsafe-eval';object-src 'none';base-uri 'self';report-uri https://csp.withgoogle.com/csp/recaptcha/1

a-wtciqbgcmhzq

reCAPTCHA

c-wtciqbgcmhzq

recaptcha challenge expires in two minutes

e57f8e3a19d89cc9dc02e8e02bb5a1e77de5d0a77d04fc9c80844a7983a5882c

fd272a2b28c77e6c6d4521ae06ccfba9ee96ec48fefb4ceab15f0ab25a8dec5e

18c9db1b52459f530986198aab0fb36b72faebf4d84c09b5a1896419906775c9

557fbc5cbc2876cf63b4f48343a09070cbe0db483f13a759477d36a747bf1daf

9aa6b840d441302d3518aa13857c608e2ccc7cb488040126fba1c8d15f1008b1

1e5a442f8454245a9ec92f4fd0c6bf851a011bea07f982160dc0c36846dabdd7

f43a72e0046e6ca69f6d4f19770282431daa116409848ca006eccf5dd6e8cda5

728f6be27841097ec42707dcc5059ed576ffbfc87ceb34a4a57d771bb79eb4a2

75e384ab2e4b5997cd1d5ebcf49204acab1c6119bd6d170c1c07962e79c1dad5

d53a29bf760442e1b5581dcd18abb3db747dae7a4a82ed63869b2b9a364be4f3

02487ac34920f7a8b237909f0c330d783bceab5503ae091c276e7c021e8d48a2

403498efd70da3fd9898b571d60d10b2f4aa9182ae0137105293f58f9e781df8

1713cc28a121a2f6f897067b0b1f54b4bebe1847122e305fa4557d9f1d3c81b4

55fb00b2f28ef206f983a65a05e54da4b823fcf21ed816b82cded5349963e1f8

5c7c99c3b9470e7849d9383b4e711be6578d33b7271b4c7206b355be974f5352

c2230239c7907e3c9f6f6417f903fbd5734f84c555943bbcc3abd974985108fc

e97b9a5c1d98589a44c450884f66eb8a857f466fcdb18580f6e92086d0ab7816

0e2d17f95b5768da3c659f6040f8ef1eef865e1c13a5717270eb9de772914c5d

245acb0ea4b1c0c9132fa709e086f99f6d23c551f413ac4b67f5d9b01241916b

2dfce630050816df6208cddf39b6b2e7ec81d67f4d695c85a8c4ac7884ef0b6f

ccdd2d231d4fc51186c484d940d8d7eff0e0ab787067fc8aa6a10f014deffa7e

93a0c74067a61a8776a7ff87535168cdccf26b05f86b9790729c6463261e7bee

b1388948feedf6e1e425c3dbcae50348d07c400ca3c00ddc2f50fcde374ba11e

c849cdeb7d018cb881cb0d8317158780cf57522b098a4dd6e1698b39db2a42d9

a921868893c5619a021cf80397548d8e4410c55408436fb760ef3fa251ace0cd

1b6f1a4263197f2c1249fe4ddc862303f558b6e8c30bca33a7fdf230831a915a

cec72174cceb8d24af1a378c6b9ab1fa9326c116d543cc32c277b716bf98163e

8b7fcc8b3a84c01020b7d121fbe127b51572fc951b1b171c8fb4d06224859959

5649807295e7ae6c56c55cf90f0ef2f7e6f50228b168b00c7902aaa6a6dd66d7

334555c22851b3a4f2e0dc7be3038ad664270da2594615d6288484976f88f978

0ce1a2c09ca86a263ec13575dca5a867858827803edb2947725cd685f2055805

A7vZI3v+Gz7JfuRolKNM4Aff6zaGuT7X0mf3wtoZTnKv6497cVMnhy03KDqX7kBz/q/iidW7srW31oQbBt4VhgoAAACUeyJvcmlnaW4iOiJodHRwczovL3d3dy5nb29nbGUuY29tOjQ0MyIsImZlYXR1cmUiOiJEaXNhYmxlVGhpcmRQYXJ0eVN0b3JhZ2VQYXJ0aXRpb25pbmczIiwiZXhwaXJ5IjoxNzU3OTgwODAwLCJpc1N1YmRvbWFpbiI6dHJ1ZSwiaXNUaGlyZFBhcnR5Ijp0cnVlfQ==

Disqus, disqus.com, comments, blog, blogs, discussion

keywords

google

Disqus is a global comment system that improves discussion on websites and connects conversations across the web.

description

viewport

apple-mobile-web-app-capable

HSTS header missing - vulnerable to protocol downgrade attacks

CSP header missing - vulnerable to XSS attacks

child-src 'none';object-src 'none';require-trusted-types-for 'script';script-src chrome://resources 'self';trusted-types;worker-src blob: 'self';frame-ancestors 'none';

child-src https:  chrome-untrusted://new-tab-page/ chrome-untrusted://ntp-microsoft-auth/;connect-src chrome://resources chrome://theme 'self';default-src 'self';font-src chrome://resources 'self';img-src chrome://resources chrome://theme chrome://image chrome://favicon2 chrome://app-icon chrome://extension-icon chrome://fileicon blob: data: 'self';object-src 'none';require-trusted-types-for 'script';script-src chrome://resources chrome://webui-test 'self';style-src chrome://resources chrome://theme 'self' 'unsafe-inline';trusted-types parse-html-subset sanitize-inner-html static-types webui-test-script webui-test-html polymer-html-literal polymer-template-event-attribute-policy lit-html-desktop;frame-ancestors 'none';

child-src 'none';object-src 'none';require-trusted-types-for 'script';script-src chrome://resources 'self';trusted-types;frame-ancestors 'none';

base-uri 'none';child-src https:;form-action https://ogs.google.com https://*.corp.google.com;object-src 'none';script-src 'self' 'unsafe-inline' https:;frame-ancestors chrome://new-tab-page/

GoDaddy.com, LLC

DISQUS.COM


//
// shared/foundation.js
//
// This file contains the absolute minimum code necessary in order
// to create a new application in the DISQUS namespace.
//
// You should load this file *before* anything that modifies the DISQUS global.
//

/*jshint browser:true, undef:true, strict:true, expr:true, white:true */
/*global DISQUS:true */

var DISQUS = (function (window, undefined) {
    "use strict";

    var DISQUS = window.DISQUS || {};

    // Exception thrown from DISQUS.assert method on failure
    DISQUS.AssertionError = function (message) {
        this.message = message;
    };

    DISQUS.AssertionError.prototype.toString = function () {
        return 'Assertion Error: ' + (this.message || '[no message]');
    };


    // Raises a DISQUS.AssertionError if value is falsy
    DISQUS.assert = function (value, message, soft) {
        if (value)
            return;

        if (soft)
            window.console && window.console.log("DISQUS assertion failed: " + message);
        else
            throw new DISQUS.AssertionError(message);
    };


    // Functions to clean attached modules (used by define and cleanup)
    var cleanFuncs = [];

    // Attaches a new public interface (module) to the DISQUS namespace.
    // For example, if DISQUS object is { 'a': { 'b': {} } }:
    //
    //   DISQUS.define('a.b.c', function () { return { 'd': 'hello' }; }); will transform it into
    //     -> { 'a': { 'b': { 'c': { 'd' : hello' }}}}
    //
    //   and DISQUS.define('a', function () { return { 'x': 'world' }; }); will transform it into
    //     -> { 'a': { 'b': {}}, 'x': 'world' }
    //
    // Attach modules to DISQUS using only this function.

    DISQUS.define = function (name, fn) {
        /*jshint loopfunc:true */
        if (typeof name === 'function') {
            fn = name;
            name = '';
        }

        var parts = name.split('.');
        var part  = parts.shift();
        var cur   = DISQUS;

        var exports = (fn || function () { return {}; }).call({
            overwrites: function (obj) {
                obj.__overwrites__ = true;
                return obj;
            }
        }, window);

        while (part) {
            cur = (cur[part] ? cur[part] : cur[part] = {});
            part = parts.shift();
        }

        for (var key in exports) {
            if (!exports.hasOwnProperty(key))
                continue;

            /*jshint eqnull:true */
            if (!exports.__overwrites__ && cur[key] !== null) {
                DISQUS.assert(!cur.hasOwnProperty(key),
                              'Unsafe attempt to redefine existing module: ' + key,
                              true /* soft assertion */);
            }

            cur[key] = exports[key];
            cleanFuncs.push(function (cur, key) {
                return function () { delete cur[key]; };
            }(cur, key));
        }
        return cur;
    };


    // Alias for DISQUS.define for the sake of semantics.
    // You should use it when you need to get a reference to another
    // DISQUS module before that module is defined:
    //
    //   var collections = DISQUS.use('lounge.collections');
    //
    // DISQUS.use is a single argument function because we don't
    // want to encourage people to use it instead of DISQUS.define.

    DISQUS.use = function (name) {
        return DISQUS.define(name);
    };

    DISQUS.cleanup = function () {
        for (var i = 0; i < cleanFuncs.length; i++) {
            cleanFuncs[i]();
        }
    };

    return DISQUS;
})(window);

/*jshint expr:true, undef:true, strict:true, white:true, browser:true */
/*global DISQUS:false*/
//
// shared/corefuncs.js
//

DISQUS.define(function (window, undefined) {
    "use strict";

    var DISQUS     = window.DISQUS;
    var document   = window.document;
    var head       = document.getElementsByTagName('head')[0] ||
                     document.body;
    var jobs       = { running: false, timer: null, queue: [] };
    var uid        = 0;

    // Taken from _.uniqueId
    DISQUS.getUid = function (prefix) {
        var id = ++uid + '';
        return prefix ? prefix + id : id;
    };

    /* Defers func() execution until cond() is true */
    DISQUS.defer = function (cond, func) {
        function beat() {
            /*jshint boss:true */
            var queue = jobs.queue;

            if (queue.length === 0) {
                jobs.running = false;
                clearInterval(jobs.timer);
            }

            for (var i = 0, pair; pair = queue[i]; i++) {
                if (pair[0]()) {
                    queue.splice(i--, 1);
                    pair[1]();
                }
            }
        }

        jobs.queue.push([cond, func]);
        beat();

        if (!jobs.running) {
            jobs.running = true;
            jobs.timer = setInterval(beat, 100);
        }
    };

    DISQUS.isOwn = function (obj, key) {
        // The object.hasOwnProperty method fails when the
        // property under consideration is named 'hasOwnProperty'.
        return Object.prototype.hasOwnProperty.call(obj, key);
    };

    DISQUS.isString = function (str) {
        return Object.prototype.toString.call(str) === "[object String]";
    };

    /*
     * Iterates over an object or a collection and calls a callback
     * function with each item as a parameter.
     */
    DISQUS.each = function (collection, callback) {
        var length = collection.length,
            forEach = Array.prototype.forEach;

        if (!isNaN(length)) {
            // Treat collection as an array
            if (forEach) {
                forEach.call(collection, callback);
            } else {
                for (var i = 0; i < length; i++) {
                    callback(collection[i], i, collection);
                }
            }
        } else {
            // Treat collection as an object
            for (var key in collection) {
                if (DISQUS.isOwn(collection, key)) {
                    callback(collection[key], key, collection);
                }
            }
        }
    };

    // Borrowed from underscore
    DISQUS.extend = function (obj) {
        DISQUS.each(Array.prototype.slice.call(arguments, 1), function (source) {
            for (var prop in source) {
                obj[prop] = source[prop];
            }
        });
        return obj;
    };

    DISQUS.serializeArgs = function (params) {
        var pcs = [];
        DISQUS.each(params, function (val, key) {
            if (val !== undefined) {
                pcs.push(key + (val !== null ? '=' + encodeURIComponent(val) : ''));
            }
        });
        return pcs.join('&');
    };

    DISQUS.serialize = function (url, params, nocache) {
        if (params) {
            url += (~url.indexOf('?') ?
                        (url.charAt(url.length - 1) == '&' ? '': '&') : '?');
            url += DISQUS.serializeArgs(params);
        }

        if (nocache) {
            var ncp = {};
            ncp[(new Date()).getTime()] = null;
            return DISQUS.serialize(url, ncp);
        }

        var len = url.length;
        return (url.charAt(len - 1) == "&" ? url.slice(0, len - 1) : url);
    };

    var TIMEOUT_DURATION = 2e4; // 20 seconds
    var addEvent, removeEvent;

    // select the correct event listener function. all of our supported
    // browsers will use one of these
    if ('addEventListener' in window) {
        addEvent = function (node, event, handler) {
            node.addEventListener(event, handler, false);
        };
        removeEvent = function (node, event, handler) {
            node.removeEventListener(event, handler, false);
        };
    }
    else {
        addEvent = function (node, event, handler) {
            node.attachEvent('on' + event, handler);
        };
        removeEvent = function (node, event, handler) {
            node.detachEvent('on' + event, handler);
        };
    }

    DISQUS.require = function (url, params, nocache, success, failure) {
        var script = document.createElement('script');
        var evName = script.addEventListener ? 'load' : 'readystatechange';
        var timeout = null;

        script.src = DISQUS.serialize(url, params, nocache);
        script.async = true;
        script.charset = 'UTF-8';

        function handler(ev) {
            ev = ev || window.event;
            if (!ev.target) {
                ev.target = ev.srcElement;
            }

            if (ev.type != 'load' && !/^(complete|loaded)$/.test(ev.target.readyState)) {
                return; // Not ready yet
            }

            if (success) {
                success();
            }

            if (timeout) {
                clearTimeout(timeout);
            }

            removeEvent(ev.target, evName, handler);
        }

        if (success || failure) {
            addEvent(script, evName, handler);
        }

        if (failure) {
            timeout = setTimeout(function () {
                failure();
            }, TIMEOUT_DURATION);
        }

        head.appendChild(script);
        return DISQUS;
    };

    DISQUS.requireStylesheet = function (url, params, nocache) {
        var link = document.createElement('link');
        link.rel = 'stylesheet';
        link.type = 'text/css';
        link.href = DISQUS.serialize(url, params, nocache);
        head.appendChild(link);
        return DISQUS;
    };

    DISQUS.requireSet = function (urls, nocache, callback) {
        var remaining = urls.length;
        DISQUS.each(urls, function (url) {
            DISQUS.require(url, {}, nocache, function () {
                if (--remaining === 0) { callback(); }
            });
        });
    };

    DISQUS.injectCss = function (css) {
        var style = document.createElement('style');
        style.setAttribute('type', 'text/css');

        // Make inline CSS more readable by splitting each rule onto a separate line
        css = css.replace(/\}/g, "}\n");

        if (window.location.href.match(/^https/))
            css = css.replace(/http:\/\//g, 'https://');

        if (style.styleSheet) { // Internet Explorer only
            style.styleSheet.cssText = css;
        } else {
            style.appendChild(document.createTextNode(css));
        }

        head.appendChild(style);
    };

    DISQUS.isString = function (val) {
        return Object.prototype.toString.call(val) === '[object String]';
    };
});

/*jshint boss:true*/
/*global DISQUS */
DISQUS.define('Events', function (window, undefined) {
    "use strict";

    // Returns a function that will be executed at most one time, no matter how
    // often you call it. Useful for lazy initialization.
    var once = function (func) {
        var ran = false, memo;
        return function () {
            if (ran) return memo;
            ran = true;
            memo = func.apply(this, arguments);
            func = null;
            return memo;
        };
    };
    var has = DISQUS.isOwn;
    var keys = Object.keys || function (obj) {
        if (obj !== Object(obj)) throw new TypeError('Invalid object');
        var keys = [];
        for (var key in obj) if (has(obj, key)) keys[keys.length] = key;
        return keys;
    };
    var slice = [].slice;

    // 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 = {

        // 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 onced = once(function () {
                self.off(name, onced);
                callback.apply(this, arguments);
            });
            onced._callback = callback;
            return this.on(name, onced, 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 = {};
                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 listeners = this._listeners;
            if (!listeners) return this;
            var deleteListener = !name && !callback;
            if (typeof name === 'object') callback = this;
            if (obj) (listeners = {})[obj._listenerId] = obj;
            for (var id in listeners) {
                listeners[id].off(name, callback, this);
                if (deleteListener) delete this._listeners[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);
            }
        }
    };

    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.
    DISQUS.each(listenMethods, function (implementation, method) {
        Events[method] = function (obj, name, callback) {
            var listeners = this._listeners || (this._listeners = {});
            var id = obj._listenerId || (obj._listenerId = DISQUS.getUid('l'));
            listeners[id] = obj;
            if (typeof name === 'object') callback = this;
            obj[implementation](name, callback, this);
            return this;
        };
    });

    // Aliases for backwards compatibility.
    Events.bind = Events.on;
    Events.unbind = Events.off;

    return Events;
});
 // used for /follow/ /login/ /signup/ social oauth dialogs
// faking the bus
DISQUS.use('Bus');
_.extend(DISQUS.Bus, DISQUS.Events);



    if (window.AB_TESTS === undefined) {
        var AB_TESTS = {};
    }



    // Global tests
    $(document).ready(function() {
        $('a[rel*=facebox]').facebox();
    });




<% var has_custom_avatar = data.avatar_url && data.avatar_url.indexOf('noavatar') < 0; %>
<% var has_custom_username = data.username && data.username.indexOf('disqus_') < 0; %>
<% if (data.username) { %>
    <% if (data.has_forums) { %>
        <li class="admin<% if (has_custom_avatar || !has_custom_username) { %> avatar-menu-admin<% } %>" data-analytics="header admin"><a href="<%= data.urlMap.admin %>"><strong>Admin</strong></a></li>
    <% } %>
    <li class="user-dropdown dropdown-toggle<% if (has_custom_avatar || !has_custom_username) { %> avatar-menu<% } else { %> username-menu<% } %>" data-analytics="header username dropdown" data-floater-marker="<% if (has_custom_avatar || !has_custom_username) { %>square<% } %>">
        <a href="<%= data.urlMap.home %>/<%= data.username %>/">
            <% if (has_custom_avatar) { %>
                <img src="<%= data.avatar_url %>" class="avatar">
            <% } else if (has_custom_username) { %>
                <%= data.username %>
            <% } else { %>
                <img src="<%= data.avatar_url %>" class="avatar">
            <% } %>
            <span class="caret"></span>
        </a>
        <ul class="clearfix dropdown">
            <li data-analytics="header view profile"><a href="<%= data.urlMap.home %>/<%= data.username %>/">View Profile</a></li>
            <li class="js-edit-profile" data-analytics="header edit profile"><a href="<%= data.urlMap.home_settings_profile %>">Edit Profile</a></li>
            <li class="logout" data-analytics="header logout"><a href="<%= data.urlMap.logout %>">Logout</a></li>
        </ul>
    </li>
<% } else { %>
    <li class="link-login" data-analytics="header login"><a href="<%= data.urlMap.login %>?next=<%= encodeURIComponent(document.location.href) %>">Log in</a></li>
<% } %>





            // Global tests
            $(document).ready(function() {
                $('a[rel*=facebox]').facebox();
            });
        

(function(w,d,s,l,i){w[l]=w[l]||[];w[l].push({'gtm.start':
        new Date().getTime(),event:'gtm.js'});var f=d.getElementsByTagName(s)[0],
        j=d.createElement(s),dl=l!='dataLayer'?'&l='+l:'';j.async=true;j.src=
        'https://www.googletagmanager.com/gtm.js?id='+i+dl;f.parentNode.insertBefore(j,f);
        })(window,document,'script','dataLayer','GTM-MRHN8JCT');


    var jesterObj = {
        product: 'dotcom',
        zone: 'login',
    };
    
    
    window.DISQUS.jester.pv(jesterObj);



DISQUS.define('web.urls', function () {
    return {
        twitter: 'https://disqus.com/_ax/twitter/begin/?ctkn=c53bzdZNA7TGrtIQegJbnWZJBVFzZIYS&amp;',
        google: 'https://disqus.com/_ax/google/begin/?ctkn=c53bzdZNA7TGrtIQegJbnWZJBVFzZIYS&amp;',
        facebook: 'https://disqus.com/_ax/facebook/begin/?ctkn=c53bzdZNA7TGrtIQegJbnWZJBVFzZIYS&amp;',
        microsoft: 'https://disqus.com/_ax/microsoft/begin/?ctkn=c53bzdZNA7TGrtIQegJbnWZJBVFzZIYS&amp;',
        apple: 'https://disqus.com/_ax/apple/begin/?ctkn=c53bzdZNA7TGrtIQegJbnWZJBVFzZIYS&amp;',
        dashboard: 'http://disqus.com/dashboard/'
    }
});

$(document).ready(function () {
    $("form").submit(function () {
        $(this).find('.button.submit')
               .attr('disabled', 'disabled')
               .addClass('submitted');
        $(this).find('#password-input')
               .attr('readonly', 'readonly');
        $(this).find('#username-input')
               .attr('readonly', 'readonly');
    });
});



        
        data-profile-username="${username}" data-profile-hash="${emailHash}" href="/${username}"
        
    


  DISQUS.ui.config({
    disqusUrl: 'https://disqus.com',
    mediaUrl: '//a.disquscdn.com/1759427398/'
  });


Requests	IP Address	Location	AS Autonomous System
18	146.75.122.49	Frankfurt am Main, Hesse, Germany	AS54113FASTLY
6	142.250.184.195	United States	AS15169GOOGLE
4	142.250.185.68	United States	AS15169GOOGLE
4	216.58.212.136	United States	AS15169GOOGLE
3	146.75.120.134	Frankfurt am Main, Hesse, Germany	AS54113FASTLY
2	157.240.0.6	Frankfurt am Main, Hesse, Germany	AS32934FACEBOOK
2	3.171.214.105	United States	AS16509AMAZON-02
2	216.239.32.36	United States	AS15169GOOGLE
1	216.239.34.36	United States	AS15169GOOGLE
1	3.171.214.104	United States	AS16509AMAZON-02
45	34	-	-

Security Scan Report: downdetector.disqus.com

Summary

AI Security Verdict

Low Risk

Risk Factors

Safety Factors

Details

Screenshot

Page Load Overview

Language Analysis

Primary Language

Detection Details

Website Classification

Primary Category

All Detected Categories

Detected Features

Domain & IP Information

Detected Technologies1

Content Similarity HashesFor malware variant detection

Image Hashes

Perceptual Hashes

Other Hashes

Scan History