Add files using upload-large-folder tool

.config/wandb/settings

@@ -0,0 +1,2 @@
+[default]
+

.local/share/jupyter/nbextensions/freeze/main.js

@@ -0,0 +1,205 @@
+define([
+    'base/js/namespace',
+    'base/js/events',
+    'notebook/js/codecell',
+    'notebook/js/textcell',
+    'jquery'
+], function (
+    Jupyter,
+    events,
+    codecell,
+    textcell,
+    $
+) {
+    'use strict';
+
+    var CodeCell = codecell.CodeCell;
+    var MarkdownCell = textcell.MarkdownCell;
+
+    var mod_name = 'Freeze';
+    var log_prefix = '[' + mod_name + ']';
+
+    // defaults, overridden by server's config
+    var options = {
+        readonly_color: '#fffef0',
+        frozen_color: '#f0feff'
+    };
+
+    function patch_MarkdownCell_unrender () {
+        console.log('[Freeze] patching MarkdownCell.prototype.unrender');
+        var old_unrender = MarkdownCell.prototype.unrender;
+
+        MarkdownCell.prototype.unrender = function () {
+            // console.log('[Freeze] patched unrender applied');
+            if (this.metadata.run_control === undefined ||
+                !this.metadata.run_control.frozen
+            ) {
+                old_unrender.apply(this, arguments);
+            }
+        };
+    }
+
+    function patch_CodeCell_execute () {
+        console.log('[Freeze] patching CodeCell.prototype.execute');
+        var old_execute = CodeCell.prototype.execute;
+
+        CodeCell.prototype.execute = function () {
+            if (this.metadata.run_control === undefined ||
+                !this.metadata.run_control.frozen
+            ) {
+                old_execute.apply(this, arguments);
+            }
+        };
+    }
+
+    // Migrate old metadata format to new notebook-defined metadata.editable
+    function migrate_state (cell) {
+        if (cell.metadata.run_control !== undefined) {
+            if (cell instanceof CodeCell || cell instanceof MarkdownCell) {
+                if (cell.metadata.run_control.read_only === true) {
+                    cell.metadata.editable = false;
+                }
+            }
+            else {
+                // remove metadata irrelevant to non-code/markdown cells
+                delete cell.metadata.run_control.frozen;
+            }
+            // remove old key replaced by metadata.editable
+            delete cell.metadata.run_control.read_only;
+            // remove whole object if it's now empty
+            if (Object.keys(cell.metadata.run_control).length === 0) {
+                delete cell.metadata.run_control;
+            }
+        }
+    }
+
+    function get_state (cell) {
+        if (cell.metadata.editable === false && (cell instanceof CodeCell || cell instanceof MarkdownCell)) {
+            if (cell.metadata.run_control !== undefined && cell.metadata.run_control.frozen) {
+                return 'frozen';
+            }
+            return 'readonly';
+        }
+        return 'normal';
+    }
+
+    function set_state(cell, state) {
+        if (!(cell instanceof CodeCell || cell instanceof MarkdownCell)) {
+            return;
+        }
+
+        state = state || 'normal';
+        var bg;
+        switch (state) {
+            case 'normal':
+                cell.metadata.editable = true;
+                cell.metadata.deletable = true;
+                if (cell.metadata.run_control !== undefined) {
+                    delete cell.metadata.run_control.frozen;
+                }
+                bg = "";
+                break;
+            case 'read_only':
+            case 'readonly':
+                cell.metadata.editable = false;
+                cell.metadata.deletable = false;
+                if (cell.metadata.run_control !== undefined) {
+                    delete cell.metadata.run_control.frozen;
+                }
+                bg = options.readonly_color;
+                break;
+            case 'frozen':
+                cell.metadata.editable = false;
+                cell.metadata.deletable = false;
+                $.extend(true, cell.metadata, {run_control: {frozen: true}});
+                bg = options.frozen_color;
+                break;
+        }
+        // remove whole object if it's now empty
+        if (cell.metadata.run_control !== undefined && Object.keys(cell.metadata.run_control).length === 0) {
+            delete cell.metadata.run_control;
+        }
+        cell.code_mirror.setOption('readOnly', !cell.metadata.editable);
+        var prompt = cell.element.find('div.input_area');
+        prompt.css("background-color", bg);
+    }
+
+    function set_state_selected (state) {
+        var cells = Jupyter.notebook.get_selected_cells();
+        for (var i = 0; i < cells.length; i++) {
+            set_state(cells[i], state);
+        }
+    }
+
+    function button_callback(state) {
+        set_state_selected(state);
+        var dirty_state = {value: true};
+        events.trigger("set_dirty.Notebook", dirty_state);
+    }
+
+    function make_normal_selected () {
+        button_callback('normal');
+    }
+
+    function make_read_only_selected () {
+        button_callback('read_only');
+    }
+
+    function make_frozen_selected () {
+        button_callback('frozen');
+    }
+
+    function initialize_states () {
+        var cells = Jupyter.notebook.get_cells();
+        for (var i = 0; i < cells.length; i++) {
+            var cell = cells[i];
+            migrate_state(cell);
+            var state = get_state(cell);
+            set_state(cell, state);
+        }
+    }
+
+    function load_extension () {
+        Jupyter.toolbar.add_buttons_group([
+            Jupyter.keyboard_manager.actions.register ({
+                help : 'lift restrictions from selected cells',
+                icon : 'fa-unlock-alt',
+                handler : make_normal_selected
+            }, 'make-cells-normal', mod_name),
+            Jupyter.keyboard_manager.actions.register({
+                help : 'make selected cells read-only',
+                icon: 'fa-lock',
+                handler : make_read_only_selected
+            }, 'make-cells-read-only', mod_name),
+            Jupyter.keyboard_manager.actions.register({
+                help : 'freeze selected cells',
+                icon : 'fa-asterisk',
+                handler : make_frozen_selected
+            }, 'freeze-cells', mod_name)
+        ]);
+
+        patch_CodeCell_execute();
+        patch_MarkdownCell_unrender();
+
+        Jupyter.notebook.config.loaded.then(function on_config_loaded () {
+            $.extend(true, options, Jupyter.notebook.config.data[mod_name]);
+        }, function on_config_load_error (reason) {
+            console.warn(log_prefix, 'Using defaults after error loading config:', reason);
+        }).then(function do_stuff_with_config () {
+            events.on("notebook_loaded.Notebook", initialize_states);
+            if (Jupyter.notebook !== undefined && Jupyter.notebook._fully_loaded) {
+                // notebook already loaded, so we missed the event, so update all
+                initialize_states();
+            }
+        }).catch(function on_error (reason) {
+            console.error(log_prefix, 'Error:', reason);
+        });
+    }
+
+    return {
+        get_state : get_state,
+        set_state : set_state,
+        load_jupyter_extension : load_extension,
+        load_ipython_extension : load_extension
+    };
+});

.local/share/jupyter/nbextensions/gist_it/main.js

@@ -0,0 +1,481 @@
+/**
+ *
+// Avoid server side code :
+// https://github.com/ipython/ipython/issues/2780
+ *
+ * This essentially boils down to the following:
+ * Github authentication requires some server-side code for any 'app' which
+ * wants to authenticate over the Github API.
+ * When registering an app with Github, Github provides the app with what they
+ * call a 'client secret'.
+ * The client secret is then incorporated into the app, and the app sends it to
+ * Github as part of the authentication process, thus proving to Github's
+ * servers that the communicating app was written by someone with appropriate
+ * credentials.
+ *
+ * The issue with writing a single Github app for Gist-ing notebooks, is that
+ * it would need to include such a client secret. Since this would be part of
+ * the extension source code, anyone could use the client secret, potentially
+ * gaining the permissions that any given user has granted to the app.
+ *
+ * As a result, we only support:
+ * - anonymous (non-authenticated) API usage
+ * - client-side authentication using a personal access token
+ *   (see https://github.com/settings/tokens)
+ */
+
+define([
+    'jquery',
+    'base/js/namespace',
+    'base/js/dialog'
+], function (
+    $,
+    Jupyter,
+    dialog
+) {
+    "use strict";
+
+    // define default values for config parameters
+    var params = {
+        gist_it_default_to_public: false,
+        gist_it_personal_access_token: '',
+        github_endpoint: 'github.com'
+    };
+
+    var initialize = function () {
+        update_params();
+        Jupyter.toolbar.add_buttons_group([
+            Jupyter.keyboard_manager.actions.register ({
+                help   : 'Create/Edit Gist of Notebook',
+                icon   : 'fa-github',
+                handler: show_gist_editor_modal
+            }, 'create-gist-from-notebook', 'gist_it')
+        ]);
+    };
+
+    // update params with any specified in the server's config file
+    var update_params = function() {
+        var config = Jupyter.notebook.config;
+        for (var key in params) {
+            if (config.data.hasOwnProperty(key))
+                params[key] = config.data[key];
+        }
+        default_metadata.data.public = Boolean(config.data.gist_it_default_to_public);
+    };
+
+    var default_metadata = {
+        id: '',
+        data: {
+            description: Jupyter.notebook.notebook_path,
+            public: false
+        }
+    };
+
+    function ensure_default_metadata () {
+        Jupyter.notebook.metadata.gist = $.extend(
+            true, // deep-copy
+            default_metadata, //defaults
+            Jupyter.notebook.metadata.gist // overrides
+        );
+    }
+
+    var add_auth_token = function add_auth_token (xhr) {
+        var token = '';
+        if (params.gist_it_personal_access_token !== '') {
+            token = params.gist_it_personal_access_token;
+        }
+        if (token !== '') {
+            xhr.setRequestHeader("Authorization", "token " + token);
+        }
+    };
+
+    function build_alert(alert_class) {
+        return $('<div/>')
+            .addClass('alert alert-dismissable')
+            .addClass(alert_class)
+            .append(
+                $('<button class="close" type="button" data-dismiss="alert" aria-label="Close"/>')
+                    .append($('<span aria-hidden="true"/>').html('&times;'))
+            );
+    }
+
+    function gist_error (jqXHR, textStatus, errorThrown) {
+        console.log('github ajax error:', jqXHR, textStatus, errorThrown);
+        var alert = build_alert('alert-danger')
+            .hide()
+            .append(
+                $('<p/>').text('The ajax request to Github went wrong:')
+            )
+            .append(
+                $('<pre/>').text(jqXHR.responseJSON ? JSON.stringify(jqXHR.responseJSON, null, 2) : errorThrown)
+            );
+        $('#gist_modal').find('.modal-body').append(alert);
+        alert.slideDown('fast');
+    }
+
+    function gist_success (response, textStatus, jqXHR) {
+        // if (Jupyter.notebook.metadata.gist.id === response.id) return;
+
+        Jupyter.notebook.metadata.gist.id = response.id;
+        Jupyter.notebook.metadata._draft = $.extend(
+            true, // deep copy
+            Jupyter.notebook.metadata._draft, // defaults
+            {nbviewer_url: response.html_url} // overrides
+        );
+
+        var d = new Date();
+        var msg_head = d.toLocaleString() + ': Gist ';
+        var msg_tail = response.history.length === 1 ? ' published' : ' updated to revision ' + response.history.length;
+        var alert = build_alert('alert-success')
+            .hide()
+            .append(msg_head)
+            .append(
+                $('<a/>')
+                    .attr('href', response.html_url)
+                    .attr('target', '_blank')
+                    .text(response.id)
+            )
+            .append(msg_tail);
+        $('#gist_modal').find('.modal-body').append(alert);
+        alert.slideDown('fast');
+    }
+
+    function get_github_endpoint() {
+        return params.github_endpoint !== '' ? params.github_endpoint : 'github.com';
+    }
+
+    function get_api_endpoint() {
+        const github_endpoint = get_github_endpoint();
+        if (github_endpoint === 'github.com') {
+            return 'https://api.'+ github_endpoint;
+        } else {
+            // Github Enterprise
+            // https://developer.github.com/enterprise/2.18/v3/enterprise-admin/#endpoint-urls
+            return 'https://' + github_endpoint + '/api/v3'
+        }
+    }
+
+    function gist_id_updated_callback(gist_editor) {
+        if (gist_editor === undefined) gist_editor = $('#gist_editor');
+
+        var id_input = gist_editor.find('#gist_id');
+        var id = id_input.val();
+
+        var help_block  = gist_editor.find('#gist_id ~ .help-block');
+        var help_block_base_text = 'Set the gist id to update an existing gist, ' +
+            'or leave blank to create a new one.';
+
+        var gist_it_button = $('#gist_modal').find('.btn-primary');
+
+        id_input.parent()
+            .removeClass('has-success has-error has-warning')
+            .find('#gist_id ~ .form-control-feedback > i.fa')
+            .removeClass('fa-pencil-square fa-exclamation-circle fa-question-circle');
+
+        if (id === '') {
+            $('#gist_id ~ .form-control-feedback > i.fa')
+                .addClass('fa-plus-circle');
+            help_block.html(
+                '<p>' + help_block_base_text + '</p>' +
+                '<p><i class="fa fa-plus-circle"></i> a new gist will be created</p>'
+            );
+            gist_it_button.prop('disabled', false);
+        }
+        else {
+            $('#gist_id ~ .form-control-feedback > i.fa')
+                .addClass('fa-circle-o-notch fa-spin');
+            // List commits as a way of checking whether the gist exists.
+            // Listing commits appears to give the most concise response.
+
+            $.ajax({
+                url: get_api_endpoint() +'/gists/' + id + '/commits',
+                dataType: 'json',
+                beforeSend: add_auth_token,
+                error: function(jqXHR, textStatus, errorThrown) {
+                    jqXHR.errorThrown = errorThrown;
+                },
+                complete: function(jqXHR, textStatus) {
+                    var success = textStatus === 'success';
+                    var error = !success && jqXHR.status === 404 && jqXHR.responseJSON !== undefined;
+                    var warning = !success && !error;
+
+                    var help_block_html = '<p>' + help_block_base_text + '</p>';
+
+                    gist_it_button.prop('disabled', error);
+                    if (success) {
+                        var single = (jqXHR.responseJSON.length === 1);
+                        help_block_html += '<p>' +
+                            '<i class="fa fa-pencil-square"></i>' +
+                            ' gist ' +
+                            '<a href="https://'+ get_github_endpoint() + '/gist/' + id +
+                            '" target="_blank">' + id + '</a> will be updated' +
+                            ' (' + jqXHR.responseJSON.length +
+                            ' revision' + (single ? '' : 's') +
+                            ' exist' + (single ? 's' : '') + ' so far)' +
+                            '</p>';
+                    }
+                    else if (error) {
+                        help_block_html += '<p>' +
+                            '<i class="fa fa-exclamation-circle"></i>' +
+                            ' no gist exists with the specified id (given current access token)'+
+                            '</p>';
+                    }
+                    else {
+                        help_block_html += '<p>' +
+                            '<i class="fa fa-question-circle"></i>' +
+                            ' can\'t list commits for the specified gist id - you may have problems updating it!' +
+                            '</p>';
+                        help_block_html += '<p>The ajax request to Github went wrong:<p/>' +
+                            '<pre>';
+                        if (jqXHR.responseJSON) {
+                            help_block_html += JSON.stringify(jqXHR.responseJSON, null, 2);
+                        }
+                        else {
+                            help_block_html += jqXHR.errorThrown || textStatus;
+                        }
+                        help_block_html += '</pre>';
+                        console.log('non-404 github ajax error:', jqXHR, textStatus);
+                    }
+                    help_block.html(help_block_html);
+
+                    id_input.parent()
+                        .toggleClass('has-success', success)
+                        .toggleClass('has-error', error)
+                        .toggleClass('has-warning', warning)
+                        .find('#gist_id ~ .form-control-feedback > i.fa')
+                        .removeClass('fa-circle-o-notch fa-spin')
+                        .toggleClass('fa-pencil-square', success)
+                        .toggleClass('fa-exclamation-circle', error)
+                        .toggleClass('fa-question-circle', warning);
+                }
+            });
+        }
+    }
+
+    function update_gist_editor (gist_editor) {
+        if (gist_editor === undefined) gist_editor = $('#gist_editor');
+
+        var id_input = gist_editor.find('#gist_id');
+
+        var have_auth = params.gist_it_personal_access_token !== '';
+        var id = '';
+        var is_public = true;
+        if (have_auth) {
+            id = Jupyter.notebook.metadata.gist.id;
+            is_public = Jupyter.notebook.metadata.gist.data.public;
+            id_input.val(id);
+        }
+        id_input.closest('.form-group').toggle(have_auth);
+
+        gist_editor.find('#gist_public')
+            .prop('checked', is_public)
+            .prop('readonly', !have_auth);
+
+        gist_editor.find('#gist_description')
+            .val(Jupyter.notebook.metadata.gist.data.description);
+
+        if (have_auth) {
+            gist_id_updated_callback(gist_editor);
+        }
+    }
+
+    function build_gist_editor () {
+        ensure_default_metadata();
+
+        var gist_editor = $('#gist_editor');
+
+        if (gist_editor.length > 0) return gist_editor;
+
+        gist_editor = $('<div/>').attr('id', 'gist_editor').append(controls);
+
+        var id = params.gist_it_personal_access_token !== '' ? Jupyter.notebook.metadata.gist.id : '';
+        var controls = $('<form/>')
+            .appendTo(gist_editor)
+            .addClass('form-horizontal');
+
+        $('<div/>')
+            .addClass('has-feedback')
+            .hide()
+            .appendTo(controls)
+            .append(
+                $('<label/>')
+                    .attr('for', 'gist_id')
+                    .text('Gist id')
+            )
+            .append(
+                $('<input/>')
+                    .addClass('form-control')
+                    .attr('id', 'gist_id')
+                    .val(Jupyter.notebook.metadata.gist.id)
+            )
+            .append(
+                $('<span/>')
+                    .addClass('form-control-feedback')
+                    .append(
+                        $('<i/>')
+                            .addClass('fa fa-lg')
+                    )
+            )
+            .append(
+                $('<span/>')
+                    .addClass('help-block')
+            );
+        $('<div/>')
+            .appendTo(controls)
+            .append(
+                $('<div/>')
+                    .addClass('checkbox')
+                    .append(
+                        $('<label>')
+                            .text('Make the gist public')
+                            .prepend(
+                                $('<input/>')
+                                    .attr('type', 'checkbox')
+                                    .attr('id', 'gist_public')
+                                    .prop('checked', Jupyter.notebook.metadata.gist.data.public)
+                                    .prop('readonly', id === '')
+                            )
+                    )
+            )
+            .append(
+                $('<label/>')
+                    .attr('for', 'gist_public')
+                    .text('public')
+            );
+        $('<div/>')
+            .appendTo(controls)
+            .append(
+                $('<label/>')
+                    .attr('for', 'gist_description')
+                    .text('description')
+            )
+            .append(
+                $('<input/>')
+                    .addClass('form-control')
+                    .attr('id', 'gist_description')
+                    .attr('type', 'textarea')
+                    .val(Jupyter.notebook.metadata.gist.data.description)
+            );
+
+        var form_groups = controls.children('div').addClass('form-group');
+        form_groups
+            .children('label')
+                .addClass('col-sm-2 control-label')
+                .css('padding-right', '1em');
+        form_groups
+            .each(function (index, elem) {
+                $('<div/>')
+                    .appendTo(elem)
+                    .addClass('col-sm-10')
+                    .append($(elem).children(':not(label)'));
+            });
+
+        update_gist_editor(gist_editor);
+
+        // bind events for id changing
+        var id_input = gist_editor.find('#gist_id');
+        // Save current value of element
+        id_input.data('oldVal', id_input.val());
+        // Look for changes in the value
+        id_input.bind("change click keyup input paste", function(event) {
+            // If value has changed...
+            if (id_input.data('oldVal') !== id_input.val()) {
+                // Updated stored value
+                id_input.data('oldVal', id_input.val());
+                // Do action
+                gist_id_updated_callback(gist_editor);
+            }
+        });
+
+        return gist_editor;
+    }
+
+    function show_gist_editor_modal () {
+        var modal;
+        modal = dialog.modal({
+            show: false,
+            title: 'Share on Github',
+            notebook: Jupyter.notebook,
+            keyboard_manager: Jupyter.notebook.keyboard_manager,
+            body: build_gist_editor(),
+            buttons: {
+                ' Gist it!': {
+                    class : 'btn-primary',
+                    click: function() {
+                        modal.find('.btn').prop('disabled', true);
+                        var new_data = {
+                            public: $('#gist_public').prop('checked'),
+                            description: $('#gist_description').val()
+                        };
+                        $.extend(
+                            true,
+                            Jupyter.notebook.metadata.gist.data,
+                            new_data
+                        );
+                        // prevent the modal from closing. See github.com/twbs/bootstrap/issues/1202
+                        modal.data('bs.modal').isShown = false;
+                        var spinner = modal.find('.btn-primary .fa-github').addClass('fa-spin');
+                        make_gist(function (jqXHR, textStatus) {
+                            modal.find('.btn').prop('disabled', false);
+                            // allow the modal to close again. See github.com/twbs/bootstrap/issues/1202
+                            modal.data('bs.modal').isShown = true;
+                            spinner.removeClass('fa-spin');
+                        });
+                    }
+                },
+                done: {}
+            }
+        })
+        .attr('id', 'gist_modal')
+        .on('shown.bs.modal', function (evt) {
+            var err = modal.find('#gist_id').parent().hasClass('has-error');
+            modal.find('.btn-primary').prop('disabled', err);
+        });
+
+        modal.find('.btn-primary').prepend(
+            $('<i/>')
+                .addClass('fa fa-lg fa-github')
+        );
+
+        modal.modal('show');
+    }
+
+    var make_gist = function make_gist (complete_callback) {
+        ensure_default_metadata();
+
+        var data = $.extend(
+            true, // deep-copy
+            { files: {} }, // defaults
+            Jupyter.notebook.metadata.gist.data // overrides
+        );
+        var filename = Jupyter.notebook.notebook_name;
+        data.files[filename] = {
+            content: JSON.stringify(Jupyter.notebook.toJSON(), null, 2)
+        };
+
+        var id_input = $('#gist_id');
+        var id = params.gist_it_personal_access_token !== '' ? id_input.val() : '';
+        var method = id ? 'PATCH' : 'POST';
+
+        // Create/edit the Gist
+        $.ajax({
+            url: get_api_endpoint() +'/gists' + (id ? '/' + id : ''),
+            type: method,
+            dataType: 'json',
+            data: JSON.stringify(data),
+            beforeSend: add_auth_token,
+            success: gist_success,
+            error: gist_error,
+            complete: complete_callback
+        });
+    };
+
+    function load_jupyter_extension () {
+        return Jupyter.notebook.config.loaded.then(initialize);
+    }
+
+    return {
+        load_jupyter_extension: load_jupyter_extension,
+        load_ipython_extension: load_jupyter_extension
+    };
+});

.local/share/jupyter/nbextensions/gist_it/readme.md

@@ -0,0 +1,59 @@
+Gist it
+=======
+
+Publish notebooks as Github gists with a single button click!
+
+![](icon.png)
+
+
+Authentication
+--------------
+
+The extension works with no special settings, publishing anonymous,
+non-modifiable gists.
+
+To create gists owned by your Github user, or to modify existing gists (useful
+for multiple revisions of a notebook!), you need to be authenticated with Github.
+
+
+### Anonymous
+
+You can publish anonymous gists without any authentication (the default mode).
+Anonymous gists can't be edited, so every time you click the button, a new gist
+is created.
+
+
+
+### Personal access tokens
+
+At the moment, the only supported method of authentication is client-side,
+using Github _personal access tokens_.
+
+__Important:__ __using personal access token authentication only makes sense if
+you are the only user of the notebook server__, and control the server.
+Otherwise, other users of the server may use your token
+(either accidentally or maliciously) to create/edit/delete gists,
+or exercise any other permissions you might have given to the token.
+If the server is only for your personal use, then you can create a github
+personal access token at [github.com/settings/tokens](https://github.com/settings/tokens).
+It makes sense to only grant the token the minimum permissions (scopes)
+necessary for the extension to work, in this case, the `gists` scope.
+Once you've got your token from Github, enter it in the
+[jupyter_nbextensions_configurator](https://github.com/Jupyter-contrib/jupyter_nbextensions_configurator)
+ui for it to be stored in the server config.
+
+
+### Full Github OAuth
+
+Github's full OAuth authentication
+(which would be required to make this extension useful for authenticating users
+in a multi-notebook setup)
+requires some server-side code.
+There are some issues with implementing this directly (
+essentially related to a secret which the App server must know, and for obvious
+reasons can't be published as part of open-source code) as a Jupyter extension.
+I ([@jcb91](https://github.com/jcb91)) started writing this `Gist it` extension
+to work with a 3rd-party authentication app, but didn't finish it or test it,
+so it's not functional at the moment.
+If you'd like to have the full OAuth model, I'd be happy to help with any
+attempt you make - drop me a line on Github.

.local/share/jupyter/nbextensions/help_panel/help_panel.js

@@ -0,0 +1,248 @@
+// Add help panel at right side of notebook window
+
+define([
+    'require',
+    'jqueryui',
+    'base/js/namespace',
+    'base/js/events',
+], function (
+    requirejs,
+    $,
+    IPython,
+    events
+) {
+    'use strict';
+
+    /**
+     * try to get bootstrap tooltip plugin.
+     * The require call may fail, since the plugin doesn't seem to be included
+     * in all Jupyter versions. In this case, we fallback to using jqueryui tooltips.
+     */
+    var have_bs_tooltips = false;
+    requirejs(
+        ['components/bootstrap/js/tooltip'],
+        // we don't actually need to do anything with the return
+        // just ensure that the plugin gets loaded.
+        function () { have_bs_tooltips = true; },
+        // The errback, error callback
+        // The error has a list of modules that failed
+        function (err) {
+            var failedId = err.requireModules && err.requireModules[0];
+            if (failedId === 'components/bootstrap/js/tooltip') {
+                // could do something here, like load a cdn version.
+                // For now, just ignore it.
+                have_bs_tooltips = false;
+            }
+        }
+    );
+
+    // define default values for config parameters
+    var params = {
+        help_panel_add_toolbar_button: false
+    };
+
+    // update params with any specified in the server's config file
+    function update_params () {
+        var config = IPython.notebook.config;
+        for (var key in params) {
+            if (config.data.hasOwnProperty(key))
+                params[key] = config.data[key];
+        }
+    }
+
+    var initialize = function () {
+        update_params();
+        if (params.help_panel_add_toolbar_button) {
+            $(IPython.toolbar.add_buttons_group([
+                IPython.keyboard_manager.actions.register({
+                    help   : 'Show help panel',
+                    icon   : 'fa-book',
+                    handler: function() {
+                        var visible = toggleHelpPanel();
+                        var btn = $(this);
+                        setTimeout(function() { btn.blur(); }, 500);
+                    }
+                }, 'show-help-panel', 'help_panel'),
+            ])).find('.btn').attr({
+                id: 'btn_help_panel',
+                'data-toggle': 'button',
+                'aria-pressed': 'false'
+            });
+        }
+    };
+
+    var side_panel_min_rel_width = 10;
+    var side_panel_max_rel_width = 90;
+    var side_panel_start_width = 45;
+
+    var build_side_panel = function (main_panel, side_panel, min_rel_width, max_rel_width) {
+        if (min_rel_width === undefined) min_rel_width = 0;
+        if (max_rel_width === undefined) max_rel_width = 100;
+
+        side_panel.css('display','none');
+        side_panel.insertAfter(main_panel);
+
+        var side_panel_splitbar = $('<div class="side_panel_splitbar"/>');
+        var side_panel_inner = $('<div class="side_panel_inner"/>');
+        var side_panel_expand_contract = $('<i class="btn fa fa-expand hidden-print">');
+        side_panel.append(side_panel_splitbar);
+        side_panel.append(side_panel_inner);
+        side_panel_inner.append(side_panel_expand_contract);
+
+        side_panel_expand_contract.attr({
+            title: 'expand/contract panel',
+            'data-toggle': 'tooltip'
+        }).tooltip({
+            placement: 'right'
+        }).click(function () {
+            var open = $(this).hasClass('fa-expand');
+            var site = $('#site');
+            slide_side_panel(main_panel, side_panel,
+                open ? 100 : side_panel.data('last_width') || side_panel_start_width);
+            $(this).toggleClass('fa-expand', !open).toggleClass('fa-compress', open);
+
+            var tooltip_text = (open ? 'shrink to not' : 'expand to') + ' fill the window';
+            if (open) {
+                side_panel.insertAfter(site);
+                site.slideUp();
+                $('#header').slideUp();
+                side_panel_inner.css({'margin-left': 0});
+                side_panel_splitbar.hide();
+            }
+            else {
+                side_panel.insertAfter(main_panel);
+                $('#header').slideDown();
+                site.slideDown({
+                    complete: function() { events.trigger('resize-header.Page'); }
+                });
+                side_panel_inner.css({'margin-left': ''});
+                side_panel_splitbar.show();
+            }
+
+            if (have_bs_tooltips) {
+                side_panel_expand_contract.attr('title', tooltip_text);
+                side_panel_expand_contract.tooltip('hide').tooltip('fixTitle');
+            }
+            else {
+                side_panel_expand_contract.tooltip('option', 'content', tooltip_text);
+            }
+        });
+
+        // bind events for resizing side panel
+        side_panel_splitbar.mousedown(function (md_evt) {
+            md_evt.preventDefault();
+            $(document).mousemove(function (mm_evt) {
+                mm_evt.preventDefault();
+                var pix_w = side_panel.offset().left + side_panel.outerWidth() - mm_evt.pageX;
+                var rel_w = 100 * (pix_w) / side_panel.parent().width();
+                rel_w = rel_w > min_rel_width ? rel_w : min_rel_width;
+                rel_w = rel_w < max_rel_width ? rel_w : max_rel_width;
+                main_panel.css('width', (100 - rel_w) + '%');
+                side_panel.css('width', rel_w + '%').data('last_width', rel_w);
+            });
+            return false;
+        });
+        $(document).mouseup(function (mu_evt) {
+            $(document).unbind('mousemove');
+        });
+
+        return side_panel;
+    };
+
+    var slide_side_panel = function (main_panel, side_panel, desired_width) {
+
+        var anim_opts = {
+            step : function (now, tween) {
+                main_panel.css('width', 100 - now + '%');
+            }
+        };
+
+        if (desired_width === undefined) {
+            if (side_panel.is(':hidden')) {
+                desired_width = (side_panel.data('last_width') || side_panel_start_width);
+            }
+            else {
+                desired_width = 0;
+            }
+        }
+
+        var visible = desired_width > 0;
+        if (visible) {
+            main_panel.css({float: 'left', 'overflow-x': 'auto'});
+            side_panel.show();
+        }
+        else {
+            anim_opts['complete'] = function () {
+                side_panel.hide();
+                main_panel.css({float : '', 'overflow-x': '', width: ''});
+            };
+        }
+
+        side_panel.animate({width: desired_width + '%'}, anim_opts);
+        return visible;
+    };
+
+    var populate_side_panel = function(side_panel) {
+        var side_panel_inner = side_panel.find('.side_panel_inner');
+        var qh = IPython.quick_help;
+        var strip_modal = function(into) {
+            // strip qh modal, insert content into element 'into'
+            $('.quickhelp').closest('.modal-body').children().children().appendTo(into);
+        };
+
+        if ($('.quickhelp').length > 0) {
+            strip_modal(side_panel_inner);
+        }
+        else {
+            // ensure quickhelp shortcuts modal won't show
+            $('body').addClass('help_panel_hide');
+            // get quickhelp to show shortcuts
+            qh.show_keyboard_shortcuts();
+            // attach handler for qh showing shortcuts
+            var qh_dia = $(qh.shortcut_dialog);
+            qh_dia.on('shown.bs.modal', function(evt) {
+                strip_modal(side_panel_inner);
+                // delicately pretend that it was never shown, unbind handlers
+                qh_dia.on('hidden.bs.modal', function () {
+                    $('body').removeClass('help_panel_hide');
+                    qh_dia.off('hidden.bs.modal');
+                }).off('shown.bs.modal').modal("hide");
+            });
+        }
+        // make sure content we stripped will be rebuilt
+        qh.force_rebuild = true;
+    };
+
+    var toggleHelpPanel = function () {
+        var main_panel = $('#notebook_panel');
+        var side_panel = $('#side_panel');
+
+        if (side_panel.length < 1) {
+            side_panel = $('<div id="side_panel"/>');
+            build_side_panel(main_panel, side_panel,
+                side_panel_min_rel_width, side_panel_max_rel_width);
+            populate_side_panel(side_panel);
+        }
+
+        var visible = slide_side_panel(main_panel, side_panel);
+        if (params.help_panel_add_toolbar_button) {
+            $('#btn_help_panel').toggleClass('active', visible);
+        }
+        return visible;
+    };
+
+    var load_ipython_extension = function () {
+        $('head').append(
+            $('<link/>', {
+                rel: 'stylesheet',
+                type:'text/css',
+                href: requirejs.toUrl('./help_panel.css')
+            })
+        );
+        return IPython.notebook.config.loaded.then(initialize);
+    };
+
+    return {
+        load_ipython_extension : load_ipython_extension
+    };
+});

.local/share/jupyter/nbextensions/hide_header/README.md

@@ -0,0 +1,4 @@
+Hide Header
+===========
+
+Add keyboard shortcut to toggle the whole header, menubar and toolbar visibility.

.local/share/jupyter/nbextensions/hide_header/main.js

@@ -0,0 +1,66 @@
+define([
+    'base/js/namespace',
+    'base/js/events'
+], function(
+    Jupyter,
+    events
+) {
+    // define default config parameter values
+    var params = {
+        header_toggle : 'ctrl-h',
+    };
+
+    // updates default params with any specified in the server's config
+    var update_params = function() {
+        var config = Jupyter.notebook.config;
+        for (var key in params){
+            if (config.data.hasOwnProperty(key) ){
+                params[key] = config.data[key];
+            }
+        }
+    };
+
+    var initialize = function () {
+        // update defaults
+        update_params();
+
+        // register action
+        var toggle_header = function (event) {
+            if (Jupyter.notebook.mode == 'command') {
+                $('#header').toggle();
+                $('div#site').toggleClass('noheader');
+                events.trigger('toggle-all-headers');
+                return false;
+            }
+            return true;
+        };
+
+        var action = {
+            icon: 'fa-gear',
+            help: 'Toggle All Headers',
+            help_index: 'zz',
+            handler: toggle_header,
+        };
+        var prefix = 'hide_header';
+        var action_name = 'toggle';
+
+        var full_action_name = Jupyter.keyboard_manager.actions.register(action, action_name, prefix);
+
+        // define keyboard shortcuts
+        var shortcuts = {};
+        shortcuts[params.header_toggle] = full_action_name;
+
+        // register keyboard shortcuts with keyboard_manager
+        Jupyter.notebook.keyboard_manager.command_shortcuts.add_shortcuts(shortcuts);
+    };
+
+    function load_ipython_extension() {
+        $("head").append(
+            '<style type="text/css"> .noheader { height: 100% !important }</style>');
+        return Jupyter.notebook.config.loaded.then(initialize);
+    }
+
+    return {
+        load_ipython_extension: load_ipython_extension
+    };
+});

.local/share/jupyter/nbextensions/hide_input/main.js

@@ -0,0 +1,54 @@
+// Adds a button to hide the input part of the currently selected cells
+
+define([
+    'jquery',
+    'base/js/namespace',
+    'base/js/events'
+], function(
+    $,
+    Jupyter,
+    events
+) {
+    "use strict";
+
+    var toggle_selected_input = function () {
+        // Find the selected cell
+        var cell = Jupyter.notebook.get_selected_cell();
+        // Toggle visibility of the input div
+        cell.element.find("div.input").toggle('slow');
+        cell.metadata.hide_input = ! cell.metadata.hide_input;
+    };
+
+    var update_input_visibility = function () {
+        Jupyter.notebook.get_cells().forEach(function(cell) {
+            if (cell.metadata.hide_input) {
+                cell.element.find("div.input").hide();
+            }
+        })
+    };
+
+    var load_ipython_extension = function() {
+
+        // Add a button to the toolbar
+        $(Jupyter.toolbar.add_buttons_group([
+            Jupyter.keyboard_manager.actions.register({
+                help   : 'Toggle selected cell input display',
+                icon   : 'fa-chevron-up',
+                handler: function() {
+                    toggle_selected_input();
+                    setTimeout(function() { $('#btn-hide-input').blur(); }, 500);
+                }
+            }, 'toggle-cell-input-display', 'hide_input')
+        ])).find('.btn').attr('id', 'btn-hide-input');
+        // Collapse all cells that are marked as hidden
+        if (Jupyter.notebook !== undefined && Jupyter.notebook._fully_loaded) {
+            // notebook already loaded. Update directly
+            update_input_visibility();
+        }
+        events.on("notebook_loaded.Notebook", update_input_visibility);
+    };
+
+    return {
+        load_ipython_extension : load_ipython_extension
+    };
+});

.local/share/jupyter/nbextensions/select_keymap/main.js

@@ -0,0 +1,371 @@
+// change the mode of all current and future CodeMirror instances
+
+define([
+    "base/js/namespace",
+    "notebook/js/cell",
+    "codemirror/lib/codemirror",
+    "codemirror/keymap/emacs",
+    "codemirror/keymap/vim",
+    "codemirror/keymap/sublime",
+    "codemirror/mode/meta",
+    "codemirror/addon/comment/comment",
+    "codemirror/addon/dialog/dialog",
+    "codemirror/addon/edit/closebrackets",
+    "codemirror/addon/edit/matchbrackets",
+    "codemirror/addon/search/searchcursor",
+    "codemirror/addon/search/search",
+], function(
+    Jupyter,
+    Cell,
+    CodeMirror
+    // other stuff is loaded, but not used
+) {
+    "use_strict";
+
+    var previous_mode = "";
+
+    var available_keymaps = [
+        "default",
+        "emacs",
+        "vim",
+        "sublime"
+    ];
+
+    /* Values to use for config keys that are note defined in server config */
+    var default_config = {
+        line_wrap: true,
+        local_storage: true,
+    };
+
+    var starting_state = {
+        extraKeys: {},
+        edit_shortcuts: {},
+        command_shortcuts: {}
+    };
+
+    var cm_default = Cell.Cell.options_default.cm_config;
+    var edit_shortcuts = Jupyter.keyboard_manager.edit_shortcuts;
+    var command_shortcuts = Jupyter.keyboard_manager.command_shortcuts;
+
+    var mods = {
+        vim: {
+            add: {
+                extraKeys: {
+                    "Esc": "leave_current_mode",
+                    "Ctrl-[": "leave_current_mode"
+                },
+                command_shortcuts: {
+                    "Ctrl-c": "jupyter-notebook:interrupt-kernel",
+                    "Ctrl-z": "jupyter-notebook:restart-kernel",
+
+                    "d,d": "jupyter-notebook:cut-cell",
+                    "y,y": "jupyter-notebook:copy-cell",
+                    "u": "jupyter-notebook:undo-cell-deletion",
+
+                    "p": "jupyter-notebook:paste-cell-below",
+                    "Shift-P": "jupyter-notebook:paste-cell-above",
+
+                    "o": "jupyter-notebook:insert-cell-below",
+                    "Shift-O": "jupyter-notebook:insert-cell-above",
+
+                    "i": "jupyter-notebook:enter-edit-mode",
+                    "Enter": "jupyter-notebook:enter-edit-mode",
+
+                    "Shift-J": "jupyter-notebook:move-cell-down",
+                    "Shift-K": "jupyter-notebook:move-cell-up",
+
+                    "Shift-/": "jupyter-notebook:show-keyboard-shortcuts",
+                    "h": "jupyter-notebook:toggle-cell-output-collapsed",
+                    "Shift-H": "jupyter-notebook:toggle-cell-output-scrolled",
+
+                    "`": "jupyter-notebook:change-cell-to-code",
+                    "0": "jupyter-notebook:change-cell-to-markdown"
+                },
+                edit_shortcuts: {
+                    "Shift-Esc": "jupyter-notebook:enter-command-mode"
+                }
+            },
+            remove: {
+                edit_shortcuts: ["Esc"]
+            },
+            custom: function() {
+                disable_keyboard_manager_in_dialog(this);
+            },
+            custom_teardown: function() {
+                reenable_keyboard_manager_in_dialog(this);
+            }
+        },
+        emacs: {
+            add: {
+                extraKeys: {
+                    "Ctrl-Y": "yank_no_selection"
+                },
+                command_shortcuts: {
+                    "Ctrl-N": "jupyter-notebook:select-next-cell",
+                    "Ctrl-P": "jupyter-notebook:select-previous-cell",
+                    "Alt-X": "jupyter-notebook:show-command-palette"
+
+                },
+                edit_shortcuts: {
+                    "Alt-X": "jupyter-notebook:show-command-palette"
+                }
+            },
+            remove: {
+                edit_shortcuts: ["Ctrl-Shift-Minus"],
+                keyMap: ["Ctrl-V"]
+            },
+            custom: function() {
+                disable_keyboard_manager_in_dialog(this);
+            },
+            custom_teardown: function() {
+                reenable_keyboard_manager_in_dialog(this);
+            }
+        }
+    };
+
+    function disable_keyboard_manager_in_dialog(_this) {
+        // Disable keyboard manager for code mirror dialogs, handles ':'
+        // triggered ex-mode dialog box in vim mode.
+        // Manager is re-enabled by re-entry into notebook edit mode +
+        // cell normal mode after dialog closes
+        _this.openDialog = CodeMirror.prototype.openDialog;
+
+        function openDialog_keymap_wrapper(target, template, callback, options) {
+            Jupyter.keyboard_manager.disable();
+            return target.call(this, template, callback, options);
+        }
+
+        CodeMirror.defineExtension("openDialog", _.wrap(_this.openDialog,
+            openDialog_keymap_wrapper));
+    }
+
+    function reenable_keyboard_manager_in_dialog(_this) {
+        CodeMirror.defineExtension("openDialog", _this.openDialog);
+    }
+
+    var server_config = Jupyter.notebook.config;
+    // make sure config is loaded before making initial changes
+    var initialize = function () {
+        save_starting_state();
+        // initialize last stored value or default
+        switch_keymap(get_stored_keymap());
+    };
+
+    function get_config(key) {
+        if (server_config.data.hasOwnProperty("select_keymap_" + key)) {
+            return server_config.data["select_keymap_" + key];
+        }
+        return default_config[key];
+    }
+
+    function get_stored_keymap() {
+        var keymap;
+        if (get_config("local_storage")) {
+            keymap = window.localStorage.getItem("jupyter_keymap");
+        } else {
+            keymap = server_config.data.stored_keymap;
+        }
+        return keymap || "default";
+    }
+
+    function store_keymap(mode) {
+        if (get_config("local_storage")) {
+            window.localStorage.setItem("jupyter_keymap", mode);
+        } else {
+            server_config.update({
+                stored_keymap: mode
+            });
+        }
+    }
+
+    function flatten_shortcuts(shortcut_tree) {
+        var result = {};
+        for (var p in shortcut_tree) {
+            if (typeof(shortcut_tree[p]) == "string") {
+                result[p] = shortcut_tree[p];
+            } else {
+                var subresult = flatten_shortcuts(shortcut_tree[p]);
+                for (var subp in subresult) {
+                    result[p + "," + subp] = subresult[subp];
+                }
+            }
+        }
+        return result;
+    }
+
+    function update_shortcuts(shortcut_manager, updated_shortcuts) {
+        var current_shortcuts = _.invert(flatten_shortcuts(shortcut_manager._shortcuts));
+
+        for (var shortcut_action in _.invert(updated_shortcuts)) {
+            if (_.has(current_shortcuts, shortcut_action) &&
+                shortcut_manager.get_shortcut(current_shortcuts[shortcut_action])) {
+
+                shortcut_manager.remove_shortcut(current_shortcuts[shortcut_action]);
+            }
+        }
+
+        shortcut_manager.add_shortcuts(updated_shortcuts);
+    }
+
+    // start custom CodeMirror command definitions
+    function leave_current_mode(cm) {
+        if (cm.state.vim.insertMode) {
+            // Move from insert mode into command mode.
+            CodeMirror.keyMap["vim-insert"].call("Esc", cm);
+        } else if (cm.state.vim.visualMode) {
+            // Move from visual mode to command mode.
+            CodeMirror.keyMap["vim"].call("Esc", cm);
+        } else {
+            // Move to notebook command mode.
+            Jupyter.notebook.command_mode();
+            Jupyter.notebook.focus_cell();
+        }
+    };
+
+    var orig_ctrl_y = CodeMirror.keyMap.emacs["Ctrl-Y"];
+
+    function yank_no_selection(cm) {
+        orig_ctrl_y(cm);
+        // remove selection after yank
+        cm.setSelection(cm.getCursor(), cm.getCursor());
+    };
+
+    CodeMirror.commands.yank_no_selection = yank_no_selection;
+    CodeMirror.commands.leave_current_mode = leave_current_mode;
+    // end custom CodeMirror command definitions
+
+    function create_menu() {
+        var menu = [
+            "<li class='divider''></li>",
+            "<li class='dropdown-submenu'>",
+            "<a href='#'>Keymaps</a>",
+            "<ul class='dropdown-menu'' id='keymap_menu'>"
+        ];
+
+        available_keymaps.forEach(function(keymap) {
+            menu.push(`<li><a id="keymap-${keymap}" href="#" title="Toggle ${keymap} keybindings" onClick="switch_keymap('${keymap}')" style="text-transform: capitalize;">${keymap}</a></li>`);
+        });
+
+        menu.push("</ul></li>");
+
+        $("#move_cell_down").after(menu.join("\n"));
+    }
+
+    function update_cm_instance_to_defaults(cell) {
+        var cm = cell.code_mirror;
+        cm.setOption("vimMode", cm_default["vimMode"]);
+        cm.setOption("lineWrapping", cm_default["lineWrapping"]);
+        cm.setOption("keyMap", cm_default["keyMap"]);
+        cm.setOption("extraKeys", cm_default["extraKeys"]);
+    };
+
+    function highlight_selection(mode) {
+        $("[id^=keymap]").css("font-weight", "normal");
+        $("[id=keymap-" + mode + "]").css("font-weight", "bold");
+    }
+
+    function reset_state() {
+        // FIXME: if this extension loads before other extensions that alter
+        // key shortcuts, this will probably reset those as well
+        cm_default.extraKeys = _.clone(starting_state.extraKeys);
+        update_shortcuts(edit_shortcuts, starting_state.edit_shortcuts);
+        update_shortcuts(command_shortcuts, starting_state.command_shortcuts);
+
+        // if changing from another mode, run the teardown function
+        var prev_mode_mods = mods[previous_mode];
+        if (prev_mode_mods && prev_mode_mods.custom_teardown) {
+            prev_mode_mods.custom_teardown();
+        }
+    }
+
+    function save_starting_state() {
+        starting_state.extraKeys = _.clone(cm_default.extraKeys);
+        starting_state.edit_shortcuts = flatten_shortcuts(edit_shortcuts._shortcuts);
+        starting_state.command_shortcuts = flatten_shortcuts(command_shortcuts._shortcuts);
+    }
+
+    function add_bindings(add, mode) {
+        _.extend(CodeMirror.keyMap[mode], add.keyMap);
+        _.extend(cm_default.extraKeys, add.extraKeys);
+
+        if (add.command_shortcuts) {
+            update_shortcuts(command_shortcuts, add.command_shortcuts);
+        }
+
+        if (add.edit_shortcuts) {
+            update_shortcuts(edit_shortcuts, add.edit_shortcuts);
+        }
+    }
+
+    function remove_bindings(remove, mode) {
+        _.forEach(remove.keyMap, function(key) {
+            delete CodeMirror.keyMap[mode][key];
+        });
+
+        _.forEach(remove.extraKeys, function(key) {
+            delete cm_default.extraKeys[key];
+        });
+
+        _.forEach(remove.edit_shortcuts, function(key) {
+            edit_shortcuts.remove_shortcut(key);
+        });
+
+        _.forEach(remove.command_shortcuts, function(key) {
+            command_shortcuts.remove_shortcut(key);
+        });
+    }
+
+    function change_notebook_defaults(mode) {
+        // make changes to cm defaults
+        cm_default.keyMap = mode;
+        cm_default.vimMode = mode == "vim";
+        cm_default.lineWrapping = get_config('line_wrap');
+
+        var mode_mods = mods[mode];
+        if (mode_mods) {
+            if (mode_mods.add) {
+                add_bindings(mode_mods.add, mode);
+            }
+
+            if (mode_mods.remove) {
+                remove_bindings(mode_mods.remove, mode);
+            }
+
+            if (mode_mods.custom) {
+                mode_mods.custom();
+            }
+        }
+    }
+
+    function change_cells_to_defaults() {
+        Jupyter.notebook.get_cells().map(update_cm_instance_to_defaults);
+    }
+
+    function switch_keymap(mode) {
+        // don't run if selecting currently selected mode
+        if (mode == previous_mode) return;
+
+        // store selection only when it changes
+        if (previous_mode) store_keymap(mode);
+
+        reset_state();
+
+        change_notebook_defaults(mode);
+
+        change_cells_to_defaults();
+
+        highlight_selection(mode);
+
+        previous_mode = mode;
+    }
+
+    window.switch_keymap = switch_keymap;
+
+    return {
+        load_ipython_extension: function () {
+            return Jupyter.notebook.config.loaded
+                .then(initialize)
+                .then(create_menu);
+        }
+    };
+});

.local/share/jupyter/nbextensions/select_keymap/select_keymap.yaml

@@ -0,0 +1,15 @@
+Type: Jupyter Notebook Extension
+Name: Select CodeMirror Keymap
+Link: README.md
+Description: "A little extension to choose between CodeMirror keymaps: default, emacs, vim, and sublime"
+Main: main.js
+Compatibility: 4.x, 5.x
+Parameters:
+- name: select_keymap_line_wrap
+  description: Enable line wrap in CodeMirror
+  input_type: checkbox
+  default: true
+- name: select_keymap_local_storage
+  description: Store keymap selection on the client instead of server config
+  input_type: checkbox
+  default: true

.local/share/jupyter/nbextensions/skip-traceback/main.js

@@ -0,0 +1,204 @@
+// Copyright (c) IPython-Contrib Team.
+// Distributed under the terms of the Modified BSD License.
+
+define([
+    'base/js/namespace',
+    'jquery',
+    'require',
+    'notebook/js/outputarea',
+], function (
+    Jupyter,
+    $,
+    requirejs,
+    outputarea
+) {
+    "use strict";
+
+    var mod_name = 'skip-traceback';
+    var log_prefix = '[' + mod_name + ']';
+
+    var cfg = {
+        enable: true,
+        use_toolbar_button: false,
+        button_icon: 'fa-warning',
+        animation_duration: 100,
+        show_copy_buttons: true,
+    };
+
+    // this will be filled as they're registered
+    var actions = {};
+
+    var apply_patches = function () {
+
+        outputarea.OutputArea.prototype.append_error = function (json) {
+            // firts part is just a copy of the original, but keeping a reference to inserted_text
+            var inserted_text;
+            var tb = json.traceback;
+            if (tb !== undefined && tb.length > 0) {
+                var s = '';
+                var len = tb.length;
+                for (var i = 0; i < len; i++) {
+                    s = s + tb[i] + '\n';
+                }
+                s = s + '\n';
+                var toinsert = this.create_output_area();
+                var append_text = outputarea.OutputArea.append_map['text/plain'];
+                if (append_text) {
+                    inserted_text = append_text.apply(this, [s, {}, toinsert]).addClass('output_error');
+                }
+                this._safe_append(toinsert);
+
+                // now we add our header at the top of the inserted_text
+                if (!inserted_text) {
+                    return;
+                }
+                var copy_btn = $('<i class="fa fa-fw fa-copy" title="Copy full traceback to clipboard"/>')
+                    .on('click', function (evt) {
+                        // prevent event bubbling up to collapse/uncollapse traceback
+                        evt.stopPropagation();
+                        var $copy_btn = $(this)
+                            .tooltip({track: false, trigger: 'manual', placement: 'bottom'});
+                        // create temporary off-screen textarea for copying text
+                        var $copy_txt_area = $('<textarea>')
+                            .css({position: 'absolute', left: '-10000px', top: '-10000px'})
+                            .appendTo('body');
+                        // remember this for later
+                        var was_focussed = document.activeElement;
+                        var msg = 'Failed to copy traceback to clipboard';
+                        try {
+                            $copy_txt_area[0].value = $copy_btn.closest('.skip-traceback-summary').siblings().text();
+                            $copy_txt_area[0].select();
+                            var successful = document.execCommand('copy');
+                            if (successful) {
+                                msg = 'Copied traceback to clipboard!';
+                                console.log(log_prefix, msg);
+                            }
+                            else {
+                                console.warn(log_prefix, msg);
+                            }
+                        }
+                        catch (err) {
+                            console.warn(log_prefix, msg + ':', err);
+                        }
+                        finally {
+                            $copy_txt_area.remove();
+                            was_focussed.focus();
+                            // this tooltip bit relies on jqueryui tooltip, but
+                            // it may have been overwritten by bootstrap tooltip (if loaded).
+                            try {
+                                $copy_btn
+                                    .tooltip('option', 'content', msg)
+                                    .tooltip('open');
+                                setTimeout(function () {
+                                    $copy_btn.tooltip('disable');
+                                }, 1000);
+                            }
+                            catch (err) {
+                                console.warn(log_prefix, err);
+                            }
+                        }
+                    });
+                var sum = $('<pre/>')
+                    .addClass('skip-traceback-summary')
+                    .css('cursor', 'pointer')
+                    .text(': ' + json.evalue + ' ')
+                    .prepend($('<span class=ansired/>').text(json.ename));
+
+                if (cfg.show_copy_buttons) {
+                    sum.prepend(' ').prepend(copy_btn);
+                }
+                sum
+                    .append('<i class="fa fa-caret-right" title="Expand traceback"/>')
+                    .append('\n')
+                    .on('click', function (evt) {
+                        var summary = $(this);
+                        var icon = summary.find('.fa-caret-right,.fa-caret-down');
+                        var show = icon.hasClass('fa-caret-right');
+                        icon
+                            .toggleClass('fa-caret-down', show)
+                            .toggleClass('fa-caret-right', !show)
+                            .attr('title', show ? 'Collapse traceback' : 'Expand traceback');
+                        summary.siblings()[show ? 'slideDown' : 'slideUp'](cfg.animation_duration || 100);
+                    })
+                    .prependTo(inserted_text);
+                if (cfg.enable) {
+                    sum.siblings().css('display', 'none');
+                }
+                else {
+                    sum.css('display', 'none');
+                }
+            }
+        };
+    };
+
+    var toggle_traceback = function (set_on) {
+        if (set_on === undefined) {
+            set_on = !cfg.enable;
+        }
+        // update config
+        if (set_on !== cfg.enable) {
+            cfg.enable = set_on;
+            var conf_update = {};
+            conf_update[mod_name] = {enable: set_on};
+            Jupyter.notebook.config.update(conf_update);
+            console.log(log_prefix, 'toggled', set_on ? 'on' : 'off');
+        }
+        // update button looks
+        $('#toggle_traceback_btns > .btn').toggleClass('active', set_on).blur();
+        // update existing OutputAreas
+        $('.cell .output_area .output_error .skip-traceback-summary').each(function (idx, el) {
+            var $summary = $(el);
+            $summary.css('display', set_on ? '' : 'none');
+            if ($summary.find('.fa').hasClass(set_on ? 'fa-caret-down' : 'fa-caret-right')) {
+                $summary.click();
+            }
+        });
+    };
+
+    var register_new_actions = function () {
+        actions.toggle = {
+            help : 'Toggle Hiding Traceback',
+            help_index: 'zz',
+            icon : cfg.button_icon || 'fa-warning',
+            handler : function (env) { toggle_traceback(); },
+        };
+        actions.toggle.name = Jupyter.keyboard_manager.actions.register(
+            actions.toggle, 'toggle', mod_name);
+    };
+
+    var add_toolbar_button = function () {
+        if (cfg.use_toolbar_button) {
+            Jupyter.toolbar.add_buttons_group([actions.toggle.name], 'toggle_traceback_btns');
+        }
+    };
+
+    var load_ipython_extension = function () {
+        apply_patches();
+
+        Jupyter.notebook.config.loaded
+        .then(function () {
+            $.extend(true, cfg, Jupyter.notebook.config.data[mod_name]);
+            register_new_actions();
+            add_toolbar_button();
+            toggle_traceback(cfg.enable);
+            // update any OutputArea created before our patch)
+            $('.cell .output_area .output_error').each(function (idx, el) {
+                var $el = $(el);
+                if ($el.children('.skip-traceback-summary').length < 1) {
+                    var oa = $el.closest('.cell').data('cell').output_area;
+                    var json_outputs = oa.toJSON();
+                    // clear; do not wait, ignore queue
+                    oa.clear_output(false, true);
+                    oa.fromJSON(json_outputs);
+                }
+            });
+        })
+        .catch(function (reason) {
+            console.error(log_prefix, 'Error loading:', reason);
+        });
+    };
+
+    return {
+        load_ipython_extension : load_ipython_extension
+    };
+});

.local/share/jupyter/nbextensions/snippets_menu/examples_for_custom.js

@@ -0,0 +1,187 @@
+// The following are various examples taken from README.md.  Each section
+// contains code that you could place into your own custom.js file.  Note that
+// only one of these should be used, though you might want to combine ideas
+// from the various examples.
+
+
+//// 1. Simple "My favorites" menu inserted at the *bottom* of "Snippets", with horizontal-line separator
+requirejs(["nbextensions/snippets_menu/main"], function (snippets_menu) {
+    console.log('Loading `snippets_menu` customizations from `custom.js`');
+    var horizontal_line = '---';
+    var my_favorites = {
+        'name' : 'My favorites',
+        'sub-menu' : [
+            {
+                'name' : 'Menu item text',
+                'snippet' : ['new_command(3.14)',],
+            },
+            {
+                'name' : 'Another menu item',
+                'snippet' : ['another_new_command(2.78)',],
+            },
+        ],
+    };
+    snippets_menu.options['menus'] = snippets_menu.default_menus;
+    snippets_menu.options['menus'][0]['sub-menu'].push(horizontal_line);
+    snippets_menu.options['menus'][0]['sub-menu'].push(my_favorites);
+    console.log('Loaded `snippets_menu` customizations from `custom.js`');
+});
+
+
+//// 2. "My favorites" menu with lots of stringy goodness
+requirejs(["nbextensions/snippets_menu/main"], function (snippets_menu) {
+    console.log('Loading `snippets_menu` customizations from `custom.js`');
+    var horizontal_line = '---';
+    var my_favorites = {
+        'name' : 'My $\\nu$ favorites',
+        'sub-menu' : [
+            {
+                'name' : 'Multi-line snippet',
+                'snippet' : ['new_command(3.14)',
+                             'other_new_code_on_new_line("with a string!")',
+                             'stringy(\'escape single quotes once\')',
+                             "stringy2('or use single quotes inside of double quotes')",
+                             'backslashy("This \\ appears as just one backslash in the output")',
+                             'backslashy2("Here are \\\\ two backslashes")',],
+            },
+            {
+                'name' : 'TeX appears correctly $\\alpha_W e\\int_0 \\mu \\epsilon$',
+                'snippet' : ['another_new_command(2.78)',],
+            },
+        ],
+    };
+    snippets_menu.options['menus'].push(snippets_menu.default_menus[0]);
+    snippets_menu.options['menus'][0]['sub-menu'].push(horizontal_line);
+    snippets_menu.options['menus'][0]['sub-menu'].push(my_favorites);
+    console.log('Loaded `snippets_menu` customizations from `custom.js`');
+});
+
+
+
+//// 3. Delete "Matplotlib"'s "Setup for scripts" item
+requirejs(["nbextensions/snippets_menu/main"], function (snippets_menu) {
+    console.log('Loading `snippets_menu` customizations from `custom.js`');
+    snippets_menu.python.matplotlib['sub-menu'].splice(1, 1); // Delete 1 element starting at position 1 of the sub-menu
+    console.log('Loaded `snippets_menu` customizations from `custom.js`');
+});
+
+
+
+//// 4. Swap setup items in "Matplotlib" sub-menu
+requirejs(["nbextensions/snippets_menu/main"], function (snippets_menu) {
+    console.log('Loading `snippets_menu` customizations from `custom.js`');
+    var tmp = snippets_menu.python.matplotlib['sub-menu'][0];
+    snippets_menu.python.matplotlib['sub-menu'][0] = snippets_menu.python.matplotlib['sub-menu'][1];
+    snippets_menu.python.matplotlib['sub-menu'][1] = tmp;
+    console.log('Loaded `snippets_menu` customizations from `custom.js`');
+});
+
+
+
+//// 5. Insert "My favorites" as a new top-level menu before "Snippets", instead of inside "Snippets"
+requirejs(["nbextensions/snippets_menu/main"], function (snippets_menu) {
+    console.log('Loading `snippets_menu` customizations from `custom.js`');
+    var my_favorites = {
+        'name' : 'My favorites',
+        'sub-menu' : [
+            {
+                'name' : 'Menu item text',
+                'snippet' : ['new_command(3.14)',],
+            },
+            {
+                'name' : 'Another menu item',
+                'snippet' : ['another_new_command(2.78)',],
+            },
+        ],
+    };
+    snippets_menu.options['menus'].push(my_favorites);
+    snippets_menu.options['menus'].push(snippets_menu.default_menus[0]);
+    console.log('Loaded `snippets_menu` customizations from `custom.js`');
+});
+
+
+
+//// 6. Insert "My favorites" as a new top-level menu after "Snippets", instead of inside "Snippets"
+requirejs(["nbextensions/snippets_menu/main"], function (snippets_menu) {
+    console.log('Loading `snippets_menu` customizations from `custom.js`');
+    var my_favorites = {
+        'name' : 'My favorites',
+        'sub-menu' : [
+            {
+                'name' : 'Menu item text',
+                'snippet' : ['new_command(3.14)',],
+            },
+            {
+                'name' : 'Another menu item',
+                'snippet' : ['another_new_command(2.78)',],
+            },
+        ],
+    };
+    snippets_menu.options['menus'].push(snippets_menu.default_menus[0]);
+    snippets_menu.options['menus'].push(my_favorites);
+    console.log('Loaded `snippets_menu` customizations from `custom.js`');
+});
+
+
+
+//// 7. Place "Snippets" before "Help" menu
+requirejs(["nbextensions/snippets_menu/main"], function (snippets_menu) {
+    console.log('Loading `snippets_menu` customizations from `custom.js`');
+    snippets_menu.options['insert_before_sibling'] = true;
+    console.log('Loaded `snippets_menu` customizations from `custom.js`');
+});
+
+
+
+//// 8. Move SymPy and Numpy to navbar and delete pandas
+requirejs(["nbextensions/snippets_menu/main"], function (snippets_menu) {
+    console.log('Loading `snippets_menu` customizations from `custom.js`');
+    snippets_menu.default_menus[0]['sub-menu'].splice(3, 2); // Remove SymPy and pandas
+    snippets_menu.python.sympy['sub-menu-direction'] = 'left'; // Point new SymPy menus to left
+    snippets_menu.python.numpy['sub-menu-direction'] = 'left'; // Point new Numpy menus to left
+    snippets_menu.options['menus'].push(snippets_menu.default_menus[0]); // Start with the remaining "Snippets" menu
+    snippets_menu.options['menus'].push(snippets_menu.python.sympy); // Follow that with a new SymPy menu
+    snippets_menu.options['menus'].push(snippets_menu.python.numpy); // Follow that with a new Numpy menu
+    console.log('Loaded `snippets_menu` customizations from `custom.js`');
+});
+
+
+
+//// 9. Change direction of sub-menus under "Snippets"
+requirejs(["nbextensions/snippets_menu/main"], function (snippets_menu) {
+    console.log('Loading `snippets_menu` customizations from `custom.js`');
+    snippets_menu.options['direction_of_top_level_submenu'] = 'right';
+    console.log('Loaded `snippets_menu` customizations from `custom.js`');
+});
+
+
+
+//// 10. Place "Snippets" inside "Insert" menu
+requirejs(["nbextensions/snippets_menu/main"], function (snippets_menu) {
+    console.log('Loading `snippets_menu` customizations from `custom.js`');
+    snippets_menu.default_menus[0]['menu-direction'] = 'left'; // Open top-level menu to the left...
+    snippets_menu.default_menus[0]['sub-menu-direction'] = 'right'; // ...and sub-menus to the right.
+    snippets_menu.options['menus'].push('---', snippets_menu.default_menus[0]); // Add horizontal line and default menus
+    snippets_menu.options['sibling'] = $("#insert_cell_below"); // Find the place at which to insert the new menus
+    console.log('Loaded `snippets_menu` customizations from `custom.js`');
+});
+
+
+
+//// 11. Multiple menus in different places
+requirejs(["nbextensions/snippets_menu/main"], function (snippets_menu) {
+    console.log('Loading `snippets_menu` customizations from `custom.js`');
+    var sympy_menu = [snippets_menu.python.sympy,];
+    sympy_menu[0]['sub-menu-direction'] = 'left';
+    snippets_menu.options['menus'] = sympy_menu;
+    snippets_menu.default_menus[0]['sub-menu'].splice(3, 1); // Remove SymPy from defaults
+    snippets_menu.default_menus[0]['menu-direction'] = 'left';
+    snippets_menu.default_menus[0]['sub-menu-direction'] = 'right';
+    var sibling = $("#insert_cell_below");
+    var inserted_menu = [
+        '---',
+        snippets_menu.default_menus[0],
+    ];
+    snippets_menu.menu_setup(inserted_menu, sibling, false);
+    console.log('Loaded `snippets_menu` customizations from `custom.js`');
+});

.local/share/jupyter/nbextensions/snippets_menu/readme.md

@@ -0,0 +1,633 @@
+Jupyter notebook snippets menu
+==============================
+
+Adds a customizable menu item to Jupyter notebooks to insert
+snippets, boilerplate, and examples of code.
+
+![Open snippets menu](screenshot1.png)
+
+This notebook extension adds a menu item (or multiple menu items, if
+desired) after the `Help` menu in Jupyter notebooks.  This new menu
+contains little snippets of code that we all forget from time to time
+but don't want to google, or are just too lazy to type, or simply
+didn't know about.  It can also be helpful for people just starting
+out with a programming language, who need some ideas for what to do
+next — like importing a module, defining variables, or calling
+functions.
+
+The new menu comes with a default value relevant for python
+programming — especially scientific computing — though this is fully
+user-configurable as detailed below.  The default menu is named
+`Snippets`, and contains sub-menus with snippets for a few popular
+python packages, as well as python itself, and some notebook markdown.
+(Note that some of the menus are so large that it is necessary to move
+the first-level menus to the left so that lower-level menus will fit
+on the screen.  This behavior is also user-configurable, as discussed
+in detail [below](#change-direction-of-sub-menus).)
+
+So, for example, if you are editing a code cell and want to import
+matplotlib for use in the notebook, you can just click the `Snippets`
+menu, then mouse over "Matplotlib".  This will open up a new sub-menu,
+with an item "Setup for notebook".  Clicking on that item will insert
+the code snippet at the point where your cursor was just before you
+clicked on the menu.  In particular, for this `matplotlib` example,
+the following code gets inserted:
+
+```python
+import numpy as np
+import matplotlib as mpl
+import matplotlib.pyplot as plt
+%matplotlib inline
+```
+
+The inserted text will be selected, so that you can delete it by
+pressing backspace or delete, or you can just select another snippet
+to replace it -- and just to highlight what was inserted.
+
+Note that many of the snippets involve variable names prefixed with
+`bp_`.  For example, a new numpy array is created as `bp_new_array`.
+These are intentionally dumb names that you really should replace.
+Failing to do so could lead to ugly bugs in your code if you use
+multiple boilerplate snippets with clashing variable names.
+
+Similarly, some strings are intended to be replaced, such as the axis
+labels in plots.  These are there to show you what can be done, and to
+remind you to put informative labels in your plots.  If you don't
+want, e.g., a title on your plot, just remove that line.
+
+
+Installation
+------------
+To install this extension alone (without the [main collection of nbextensions](https://github.com/ipython-contrib/jupyter_contrib_nbextensions)), run the following from the command line:
+
+```bash
+git clone git://github.com/moble/jupyter_boilerplate
+jupyter nbextension install jupyter_boilerplate
+jupyter nbextension enable jupyter_boilerplate/main
+```
+
+You can then disable the extension if you want with
+```bash
+jupyter nbextension disable jupyter_boilerplate/main
+```
+
+
+Basic menu customization
+------------------------
+
+The default menu might have too many irrelevant items for you, or may
+not have something you would find useful.  You can easily customize it
+in the
+[jupyter_nbextensions_configurator](https://github.com/Jupyter-contrib/jupyter_nbextensions_configurator#usage),
+which you almost certainly have if you installed this extension the
+normal way,
+through
+[jupyter_contrib_nbextensions](https://github.com/ipython-contrib/jupyter_contrib_nbextensions).
+Usually, you can get to the configurator by pointing your browser to
+http://127.0.0.1:8888/nbextensions, though you may have to modify the
+URL if you use a more complicated jupyter server.
+
+On the configurator page, you will see a number of options (as well as
+this README) that should be fairly self-explanatory, allowing you to
+remove any of the default menu items, or add a custom menu within the
+"Snippets" menu.  The custom menu is written in JSON, and a simple
+(and useless) example is given that should be easy to modify as
+needed.
+
+
+
+Advanced menu customization
+---------------------------
+
+It is also possible to extensively customize the menus in far more
+complex ways using your `custom.js` file.  For example, you can change
+the order of menu items, add more custom sub-menus under the
+"Snippets" menu, and custom menus alongside "Snippets" in the menu
+bar, or even add menus in other places, like inside the "Insert" menu.
+
+You can find the path to `custom.js` by running the command
+
+```bash
+echo $(jupyter --config-dir)/custom/custom.js
+```
+
+For Mac and linux users, the result is probably
+`~/.jupyter/custom/custom.js`.  If this file or the directory
+containing it do not exist, you can simply create them.
+
+The customization process is best explained through examples, which
+are available in the `examples_for_custom.js` file in this directory.
+Note that there's a lot of explanation here, but it's all actually
+pretty simple.  Give it a try, and you'll pick it up quickly.  Note
+that using this method can make it so that options selected in the
+configurator are ignored.
+
+The theory behind this customization is that the menu is represented
+by a nested JavaScript array (which is just like a python list).  So
+to change the menu, you just need to change that array.  And each menu
+*item* inside this array is represented by
+a [JavaScript "object"](https://api.jquery.com/Types/#Object) (which is
+just like a python dictionary).  So to change a menu item, you just
+have to change that object.
+
+Again, this makes more sense when looking at example, as follows.
+
+
+### Add a custom sub-menu with simple snippets
+
+Suppose you want to make a new sub-menu with your favorite snippets at
+the bottom of `Snippets`.  You create a new object for the menu item,
+and then just "push" it onto the default menu.  Do this by inserting
+some lines into your `custom.js`, so that it looks like this:
+
+```javascript
+require(["nbextensions/snippets_menu/main"], function (snippets_menu) {
+    console.log('Loading `snippets_menu` customizations from `custom.js`');
+    var horizontal_line = '---';
+    var my_favorites = {
+        'name' : 'My favorites',
+        'sub-menu' : [
+            {
+                'name' : 'Menu item text',
+                'snippet' : ['new_command(3.14)',],
+            },
+            {
+                'name' : 'Another menu item',
+                'snippet' : ['another_new_command(2.78)',],
+            },
+        ],
+    };
+    snippets_menu.options['menus'] = snippets_menu.default_menus;
+    snippets_menu.options['menus'][0]['sub-menu'].push(horizontal_line);
+    snippets_menu.options['menus'][0]['sub-menu'].push(my_favorites);
+    console.log('Loaded `snippets_menu` customizations from `custom.js`');
+});
+```
+
+Now, if you refresh your notebook, you'll see a new menu item named "My
+favorites".  Hover over it, and it will pop up a sub-menu with two more
+options.  Click the first one, and it will insert `new_command(3.14)` into
+your notebook wherever the cursor was.
+
+We discuss how all this works below.  But first, we need to slightly generalize
+the example above to work with more complicated snippets.
+
+
+### More complicated snippets
+
+The example above inserted simple one-line snippets of code.  Those snippets
+didn't have any quotation marks (single or double), backslashes, or newlines,
+which made everything easy.  Unfortunately, JavaScript doesn't deal too well
+with strings.  (There are no raw triple-quoted strings, like in python.)  So
+there are just three things to remember when writing snippets.
+
+  1. Quotation marks can be a tiny bit tricky.  There are a few options:
+    1. The obvious option is to enclose your snippets in single quotation marks
+       (`'`), and use only double quotation marks (`"`) within the snippet
+       itself.
+    2. Just as easy is to enclose your snippets in double quotation marks
+       (`"`), and use only single quotation marks (`'`) within the snippet
+       itself.
+    3. You can also escape single quotation marks inside single quotation marks
+       as `\'`.
+
+  2. Newlines are even trickier, but the extension takes care of this for you
+     as long as you put separate lines of code as separate elements of the
+     `snippet` array.  Generally, there's no reason to put a literal newline in
+     your snippets.
+
+  3. JavaScript will treat backslashes as if they're trying to escape whatever
+     comes after them.  So if you want one backslash in your output code,
+     you'll need to put two backslashes in.
+
+This is all best described with another example.  Let's change the first
+function above, to give it some more lines and some quotes:
+
+```javascript
+require(["nbextensions/snippets_menu/main"], function (snippets_menu) {
+    console.log('Loading `snippets_menu` customizations from `custom.js`');
+    var horizontal_line = '---';
+    var my_favorites = {
+        'name' : 'My $\\nu$ favorites',
+        'sub-menu' : [
+            {
+                'name' : 'Multi-line snippet',
+                'snippet' : ['new_command(3.14)',
+                             'other_new_code_on_new_line("with a string!")',
+                             'stringy(\'escape single quotes once\')',
+                             "stringy2('or use single quotes inside of double quotes')",
+                             'backslashy("This \\ appears as just one backslash in the output")',
+                             'backslashy2("Here are \\\\ two backslashes")',],
+            },
+            {
+                'name' : 'TeX appears correctly $\\alpha_W e\\int_0 \\mu \\epsilon$',
+                'snippet' : ['another_new_command(2.78)',],
+            },
+        ],
+    };
+    snippets_menu.options['menus'].push(snippets_menu.default_menus[0]);
+    snippets_menu.options['menus'][0]['sub-menu'].push(horizontal_line);
+    snippets_menu.options['menus'][0]['sub-menu'].push(my_favorites);
+    console.log('Loaded `snippets_menu` customizations from `custom.js`');
+});
+```
+
+Note the code output by the first item contains all sorts of interesting
+strings.  Also, the menu title of the second item contains TeX, which will
+display correctly, and is used in some of the default menus to show the
+standard symbols for physical constants.  For more examples, look at the
+default menus stored in the `snippets_menu` directory -- mostly under `python`.
+
+
+### How it works: Creating new menu items
+
+Each of the menu items above is a JavaScript object (like a python `dict`),
+with some attributes -- `name` and `sub-menu` for the main menu item, and
+`name` and `snippet` for the sub-menu items.  In general, any menu object can
+have any of the following properties:
+
+  1. `name`: Text that appears in the menu.  Note that this can include latex,
+     as the menus are processed by MathJax after being loaded.
+  2. `sub-menu`: An array of more menu items
+  3. `snippet`: An array of strings turned into code when the menu item is
+     clicked
+  4. `internal-link`: Link to some place on the present page.  For example,
+     this could be `#References`, to link to the `References` section of any
+     notebook you're in.
+  5. `external-link`: This just a link to some external web page, which will be
+     identified with a little icon, just like in the standard notebook "Help"
+     menu.  When clicked, the link will open in a new window/tab.
+  6. `menu-direction`: If the value of this property is `left`, this menu's
+     sub-menus open on the left.  This is useful when the top-level menu is
+     inserted as an item within other menu items.  See
+     [below](#change-direction-of-sub-menus) for examples.
+  7. `sub-menu-direction`: If the value of this property is `left`, sub-menus
+     within this menu's sub-menus open on the left.  This is used by default
+     for items under the `Snippets` menu to help ensure that nested menus
+     don't become too large to fit on the screen.  See
+     [below](#change-direction-of-sub-menus) for examples.
+
+The `name` property is the only required one, though you'll probably want at
+least one other property.  The `sub-menu` contains menu objects that again may
+have any of these properties, so you can easily nest menus.  You can also
+combine a `snippet` with a `sub-menu`, so that there's a default value as well
+as a sub-menu.  However, the last three are mutually exclusive: `snippet` will
+override any `-link`; an `internal-link` will override an `external-link`.
+
+
+### How it works: Splicing new menu items into the old
+
+Besides just creating the menu items, we may want to join together previously
+created items.  That's the purpose of this line in the code above:
+
+```javascript
+    snippets_menu.options['menus'][0]['sub-menu'].push(my_favorites);
+```
+
+This uses
+the [JavaScript `push`](https://www.w3schools.com/jsref/jsref_push.asp)
+function to insert the new menu `my_favorites` menu into the last slot
+of `snippets_menu.options['menus'][0]['sub-menu']`, which is the set
+of menus under the heading `Snippets`.
+
+If you think about this last point, you'll realize that `Snippets` is
+just the `0` slot of an array of menus.  If you want a new menu right
+in the menu bar, you could add `my_favorites` right to that top-level
+array, with something like this:
+
+```javascript
+    snippets_menu.options['menus'].push(snippets_menu.default_menus[0]);
+    snippets_menu.options['menus'].push(my_favorites);
+```
+
+This would place your favorites after the default `Snippets` menu; to
+put it before, just swap the order in which you `push`:
+
+```javascript
+    snippets_menu.options['menus'].push(my_favorites);
+    snippets_menu.options['menus'].push(snippets_menu.default_menus[0]);
+```
+
+(In general, to add a new element at a given index of an array, you
+could also just use
+the [splice](https://www.w3schools.com/jsref/jsref_splice.asp)
+function.)
+
+This might be useful if you have one set of very frequently used
+commands, and want immediate access, without going through various
+levels of the usual menu.  A useful example of this is
+shown [below](#starting-over-with-the-menus).  The `splice` function
+can also be used to delete items from the array, as
+described [next](#deleting-menu-items).
+
+
+### Other menu manipulations
+
+To rearrange menu items, just use standard JavaScript techniques.  The two most
+likely examples are deleting and rearranging menu items, but we'll also see
+that other manipulations are easy.  We can also change where the new menus go,
+and what they look like.
+
+#### Deleting menu items
+
+To delete an item, just `splice` nothing into it.  Let's suppose, for example,
+that you want to remove the option to set up matplotlib for a script, which is
+the `1` item of the "Matplotlib" menu:
+
+```javascript
+snippets_menu.python.matplotlib['sub-menu']
+```
+
+Remember that `[1]` is the second element of "Matplotlib"'s sub-menu
+list.  So the following code will do the trick
+
+
+```javascript
+require(["nbextensions/snippets_menu/main"], function (snippets_menu) {
+    console.log('Loading `snippets_menu` customizations from `custom.js`');
+    snippets_menu.python.matplotlib['sub-menu'].splice(1, 1); // Delete 1 element starting at position 1 of the sub-menu
+    console.log('Loaded `snippets_menu` customizations from `custom.js`');
+});
+```
+
+The first `1` in the argument to `splice` says to work on the element at
+position 1; the second `1` says to delete 1 element of the array.
+
+
+#### Rearranging menu items
+
+Following the example above, suppose you don't want to delete the second setup
+item under "Matplotlib", but instead want to swap those first two items.  To
+make this swap, you need to do the usual trick of storing one element in a
+temporary variable, and then reassign appropriately.  The following code
+achieves this purpose:
+
+```javascript
+require(["nbextensions/snippets_menu/main"], function (snippets_menu) {
+    console.log('Loading `snippets_menu` customizations from `custom.js`');
+    var tmp = snippets_menu.python.matplotlib['sub-menu'][0];
+    snippets_menu.python.matplotlib['sub-menu'][0] = snippets_menu.python.matplotlib['sub-menu'][1];
+    snippets_menu.python.matplotlib['sub-menu'][1] = tmp;
+    console.log('Loaded `snippets_menu` customizations from `custom.js`');
+});
+```
+
+#### Change direction of sub-menus
+
+Each sub-menu may be placed to the right or left side of the menu item
+containing it.  This is controlled by the `menu-direction` and
+`sub-menu-direction` properties of the container.  By default, both are set to
+`right` for all menus, but `sub-menu-direction` is set to `left` for the
+default `Snippets` menu, which means that all of its sub-menus open to the
+left side.  This is important because the menus may be nested quite deeply, and
+need to fit on the screen.  For example, the SciPy CODATA constants and SymPy's
+orthogonal functions will easily extend far past the right-hand edge of the
+notebook without this feature.  That means the window size would abruptly
+increase when you mouse over these menus, and would abruptly collapse when you
+mouse out of them.  So by opening them to the left, we gain enough space to
+keep everything on the screen.
+
+But these are configurable properties.  If, for example, you want to change the
+default menus to open on the right (which would be the more standard behavior),
+you can use this:
+
+```javascript
+    snippets_menu.default_menus[0]['sub-menu-direction'] = 'right';
+```
+
+This may be particularly useful if we change the position of the menus, as in
+the next examples.
+
+
+#### Starting over with the menus
+
+Each of the menu items under the default `Snippets` menu is
+individually available as part of the `snippets_menu` object defined
+in our JavaScript examples.  So if you want, you could just use them
+to build your own version of the menu.  For example, suppose use SymPy
+and Numpy most frequently, so you want easy access to their menus,
+without having to click `Snippets` first.  And then suppose you still
+want most of the other `Snippets` items, but less frequently so they
+can stay in their menu, except that you really never use pandas.  You
+can create your own menu as follows:
+
+```javascript
+require(["nbextensions/snippets_menu/main"], function (snippets_menu) {
+    console.log('Loading `snippets_menu` customizations from `custom.js`');
+    snippets_menu.default_menus[0]['sub-menu'].splice(3, 2); // Remove SymPy and pandas
+    snippets_menu.python.sympy['sub-menu-direction'] = 'left'; // Point new SymPy menus to left
+    snippets_menu.python.numpy['sub-menu-direction'] = 'left'; // Point new Numpy menus to left
+    snippets_menu.options['menus'].push(snippets_menu.default_menus[0]); // Start with the remaining "Snippets" menu
+    snippets_menu.options['menus'].push(snippets_menu.python.sympy); // Follow that with a new SymPy menu
+    snippets_menu.options['menus'].push(snippets_menu.python.numpy); // Follow that with a new Numpy menu
+    console.log('Loaded `snippets_menu` customizations from `custom.js`');
+});
+```
+
+The default menu group is `snippets_menu.default_menus`, and the SymPy sub-menu
+is `snippets_menu.python.sympy`.  You can see that we've manipulated them above
+by removing two elements from the default menu, using the `splice` command.
+We've also added a new property to the SymPy menu to make its sub-menus open to
+the left, instead of the right -- which is necessary to keep all of SymPy's
+extensively nested menus on the screen.  (In fact, the list of orthogonal
+polynomials under "Special functions" in the SymPy menu are some of the widest
+menus in the default set.)  Finally, we've combined the modified default menu
+with the modified SymPy menu into one new list.
+
+This gives us the original `Snippets` menu with SymPy and pandas removed, as
+well as new menus devoted to just SymPy and Numpy right in the menu bar:
+
+![Opened snippets menu after adjustments](screenshot2.png)
+
+You can see that the two items are indeed removed from `Snippets`, and
+"SymPy" and "Numpy" now have places of honor right in the menu bar.
+You can, of course, swap their order in the code above, or make any
+number of further alterations.
+
+
+#### Changing the insertion point
+
+You might want to change the order of the menus in the navbar (that
+top-level bar with "File", etc.).  For example, it might feel
+particularly natural to have "Help" as the last item, so maybe you'd
+prefer to put the `Snippets` menu *before* the "Help" menu.  Or you
+may prefer to maintain the structure of the menus in the navbar, and
+would rather have the `Snippets` menu *inside* of some other top-level
+menu -- like the "Insert" menu.  Personally, I prefer to have the
+`Snippets` menu in its default position for easy access.  But it's
+certainly possible to put it other places.
+
+To help do this, there are two additional options available, which can
+be set either in the configurator or in `custom.js`.  Their default
+values give us the usual placement of the `Snippets` menu; by giving
+them different values, we can change the placement.  These options are
+
+  1. `sibling`: This is an HTML node next to our new menu,
+     presumably
+     [selected with `jQuery`](https://learn.jquery.com/using-jquery-core/selecting-elements/).
+     The default value is `$("#help_menu").parent()`, which is the
+     "Help" menu.  For the configurator, `.parent()` is automatically
+     appended.
+  2. `insert_before_sibling`: This is just a string controlling where
+     the new menu will be inserted relative to its sibling. The
+     default value is `false`.  If you change it to `true`, the new
+     menu will be inserted before the sibling.
+
+So placing the `Snippets` menu *before* the "Help" menu is as easy as
+checking the box for that second option.  For more complicated uses,
+you may need to set these values from `custom.js`.  For example, f you
+want to put the new `Snippets` menu as an item inside the standard
+"Insert" menu, and include an additional horizontal divider, you can
+use this:
+
+```javascript
+require(["nbextensions/snippets_menu/main"], function (snippets_menu) {
+    console.log('Loading `snippets_menu` customizations from `custom.js`');
+    snippets_menu.default_menus[0]['menu-direction'] = 'left'; // Open top-level menu to the left...
+    snippets_menu.default_menus[0]['sub-menu-direction'] = 'right'; // ...and sub-menus to the right.
+    snippets_menu.options['menus'].push('---', snippets_menu.default_menus[0]); // Add horizontal line and default menus
+    snippets_menu.options['sibling'] = $("#insert_cell_below"); // Find the place at which to insert the new menus
+    console.log('Loaded `snippets_menu` customizations from `custom.js`');
+});
+```
+
+Here's what that looks like:
+
+![Opened snippets menu under "Insert" menu](screenshot3.png)
+
+And of course, you can combine this selection of the insertion point with other
+techniques above, where you change the content of the menus.
+
+
+#### Multiple menus in separate locations
+
+Finally, we have one more interesting example that brings together various
+threads from the previous examples.  It is possible to place multiple menus in
+different locations.  For example, suppose we want to combine two of the examples
+above, where [(1)](#starting-over-with-the-menus) we separated "SymPy" into its
+own menu on the navbar, and [(2)](#changing-the-insertion-point) we placed the
+`Snippets` menu inside the "Insert" menu.  That is, you might want "SymPy"
+to be conveniently placed, but you want the rest of the `Snippets` to stay
+under the "Insert" menu.
+
+To add these two separate menus, we place the first with the usual
+approach, and then place the second with another function,
+`snippets_menu.menu_setup`.  The former is mostly just a wrapper to
+the latter, except that it also inserts JavaScript and CSS elements
+into the notebook.  Note that `menu_setup` does not have any default
+values; you must always pass the `sibling` and `insert_before_sibling`
+arguments.
+
+So, putting it all together, the code needed for this arrangement is as
+follows:
+
+```javascript
+require(["nbextensions/snippets_menu/main"], function (snippets_menu) {
+    console.log('Loading `snippets_menu` customizations from `custom.js`');
+    var sympy_menu = [snippets_menu.python.sympy,];
+    sympy_menu[0]['sub-menu-direction'] = 'left';
+    snippets_menu.options['menus'] = sympy_menu;
+    snippets_menu.default_menus[0]['sub-menu'].splice(3, 1); // Remove SymPy from defaults
+    snippets_menu.default_menus[0]['menu-direction'] = 'left';
+    snippets_menu.default_menus[0]['sub-menu-direction'] = 'right';
+    var sibling = $("#insert_cell_below");
+    var inserted_menu = [
+        '---',
+        snippets_menu.default_menus[0],
+    ];
+    snippets_menu.menu_setup(inserted_menu, sibling, 'after');
+    console.log('Loaded `snippets_menu` customizations from `custom.js`');
+});
+```
+
+
+Troubleshooting
+---------------
+
+The first step is to make sure that the default setup can be loaded.
+Comment out whatever you've got in `custom.js`, and add in the simple
+configuration from [the beginning](#installation).  If that doesn't
+work, try the following steps
+suggested
+[here](http://jupyter-contrib-nbextensions.readthedocs.io/en/latest/troubleshooting.html):
+
+  1. Clear your browser cache or start a private browser tab.
+  2. Verify your `custom.js` is the one the notebook is seeing, by opening it
+     in the browser: <http://127.0.0.1:8888/static/custom/custom.js> (as
+     opposed to looking at the file directly outside of your browser, which may
+     not be the `custom.js` loaded if you are using a `virtualenv`).
+  3. Verify the extension can be loaded by the Jupyter notebook, for example:
+     <http://127.0.0.1:8888/nbextensions/snippets_menu/main.js>.  You
+     should see a page with lots of JavaScript code, and should *not*
+     see a 404 error.
+  4. Check for error messages in the JavaScript console.
+
+Now, assuming the basic installation works, it must be something wrong
+in your customization.  (Or maybe a new bug you've uncovered...)
+
+Sometimes, the menu(s) might simply not appear.  This is most likely
+due to a syntax error in your menu.  You can find out in Chrome by
+going to "View" -> "Developer" -> "JavaScript console".  You'll see a
+bunch of output.  Red lines are usually errors (some of which are
+probably *not* due to your menu error).  On the right side of those
+lines, you'll see the file where the error came from, and possibly
+even the line number that's causing the trouble.  Find an error that
+links to either `snippets_menu/main.js` or `custom.js`, and click on
+it.  Then try to figure out what went wrong.  The most common error
+I've encountered is "Unexpected string", which might indicate a
+missing comma, or an improperly escaped quote.  Note that sometimes
+the error will point to the first thing *after* the real problem.
+
+Or maybe the menu did appear, but it doesn't work properly.  You can
+also inspect the actual elements that were inserted.  Click on
+"Elements" in that Developer Tools tab that opened at the bottom of
+your window.  Then click the magnifying glass, and click on the
+`Snippets` menu.  This will jump the Developer Tools to the part of
+the source with that menu.  Scroll through to find the menu item
+that's not working correctly, and take a look at it.  The text in the
+`data-snippet-code` attribute is especially important, since that's
+what gets inserted into the notebook.
+
+
+TODO
+----
+
+There's a bunch of stuff I still need to do, listed in
+the
+[issue tracker](https://github.com/moble/jupyter_boilerplate/issues).
+If you find a bug or have an idea for a good snippet that you think
+should be added to the defaults, feel free
+to
+[open a new issue](https://github.com/moble/jupyter_boilerplate/issues/new).
+
+In particular, I don't use Julia or R, so I welcome suggestions for
+default snippets for those languages.
+
+
+
+Reasons for using this extension
+--------------------------------
+
+This is just a nice place to collect thoughts about why anyone might
+find this to be a useful extension:
+
+  * Introducing beginners to coding.  It's helpful for the beginner to have a
+    list of useful possibilities (with correct syntax!) lined up right where
+    the programming is happening.  It's like "Hello world" on steroids.
+  * Introducing the Jupyter notebook.  It can be useful to have some nice
+    things to do in the notebook to demonstrate the possibilities.  For
+    example, you might suggest that someone new to the notebook run the
+    Matplotlib setup and then make an example plot.
+  * Convenience for lazy people like me.  For example, I usually don't want to
+    bother with all the typing involved in setting up the nice (but important)
+    parts of a plot, like the axis labels and legend.  But by inserting the
+    template, all I have to do is change the relevant values.
+  * Reminders about useful things that could be done.  For example,
+    when I'm manipulating expressions in SymPy, I'll frequently forget
+    that I can simplify, expand, collect, etc., in all sorts of ways.
+    The Snippets menu reminds me of that.
+  * Convenient reference for massive libraries.  For example, SciPy contains
+    lots of constants.  You could certainly go to the web page describing these
+    various constants to find the one you need, or you could just explore them
+    right in the browser.  The same is true of SymPy's collection of special
+    functions.

.local/share/jupyter/nbextensions/snippets_menu/snippets_menu.css

@@ -0,0 +1,72 @@
+/*
+
+  The left-side dropdown submenu is adapted from the usual right-side code at
+  <https://github.com/ipython/ipython/blob/master/IPython/html/static/style/style.min.css#L10664>
+
+*/
+.dropdown-submenu-left > .dropdown-menu {
+  left: auto;
+  right: 100%;
+}
+
+/* For space-saving menus */
+.dropdown-submenu > .dropdown-menu.dropdown-menu-compact {
+  left: 50%;
+  top: 100%;
+}
+.dropdown-submenu-left > .dropdown-menu.dropdown-menu-compact {
+  left: auto;
+  right: 50%;
+}
+
+.dropdown-submenu-left > a:after {
+  visibility: hidden;
+}
+.dropdown-submenu-left > a:before {
+  display: inline-block;
+  font: normal normal normal 14px/1 FontAwesome;
+  font-size: inherit;
+  text-rendering: auto;
+  -webkit-font-smoothing: antialiased;
+  -moz-osx-font-smoothing: grayscale;
+  transform: translate(0, 0);
+  display: block;
+  content: "\f0d9";
+  float: left;
+  color: #333333;
+  margin-top: 2px;
+  margin-left: -10px;
+}
+
+
+/*
+
+  The following allows for control of the "tooltip" that shows the code to be
+  inserted when the item is clicked.  Without this, the tooltip might wrap the
+  code, making it hard to read; will cut off some of the code; won't be
+  monospaced; etc.  Note that these CSS selectors select any <a/> element with
+  an attribute `data-snippet-code`.  This attribute is necessary and sufficient
+  for us to add the pop-up.
+
+*/
+a[data-snippet-code]:after {
+    content: attr(data-snippet-code); /* Read from the data-snippet-code attribute */
+    font-family: monospace;
+    font-size: 75%;
+    position: absolute;
+    width: auto;
+    display: table;
+    left: 50%;
+    white-space: pre;
+    z-index: 10000;
+    background: #E8E8E8;
+    padding: 4px;
+    border-color : #AAA;
+    border-style: solid;
+    border-width: 1px;
+    visibility: hidden;
+}
+a[data-snippet-code]:hover:after {
+    visibility: visible;
+    transition: all 0s ease 1s;
+}

.local/share/jupyter/nbextensions/snippets_menu/snippets_submenus_python/numba.js

@@ -0,0 +1,51 @@
+define({
+    'name' : 'numba',
+    'sub-menu' : [
+        {
+            'name' : 'Setup',
+            'snippet' : [
+                'from __future__ import print_function, division',
+                'import sys',
+                'if sys.version_info[0] >= 3:',
+                '    xrange = range  # Must always iterate with xrange in njit functions',
+                'import numba',
+            ],
+        },
+        {
+            'name' : 'Documentation',
+            'external-link' : 'http://numba.pydata.org/numba-doc/dev/index.html',
+        },
+        '---',
+        {
+            'name' : 'Jit function',
+            'snippet'  : [
+                '@numba.njit',
+                'def bp_func(x):',
+                '    r"""Some function',
+                '    ',
+                '    Does some stuff.',
+                '    ',
+                '    """',
+                '    return x**2',
+            ],
+        },
+
+        {
+            'name' : 'Jit function with specified signature',
+            'snippet'  : [
+                '@numba.njit(f8, f8[:])',
+                'def bp_func(x, y):',
+                '    r"""Some function',
+                '    ',
+                '    Parameters',
+                '    ----------',
+                '    x : float',
+                '    y : float array',
+                '    ',
+                '    """',
+                '    for j in xrange(y.size):',
+                '        y[j] *= x',
+            ],
+        },
+    ],
+});

.local/share/jupyter/nbextensions/snippets_menu/snippets_submenus_python/numpy.js

@@ -0,0 +1,618 @@
+define([
+    "require",
+    "./numpy_ufuncs",
+    "./numpy_polynomial",
+], function (requirejs, numpy_ufuncs, numpy_polynomial) {
+    return {
+        'name' : 'NumPy',
+        'sub-menu' : [
+            {
+                'name' : 'Setup',
+                'snippet' : [
+                    'from __future__ import print_function, division',
+                    'import numpy as np',
+                ],
+            },
+            {
+                'name' : 'Documentation',
+                'external-link' : 'http://docs.scipy.org/doc/numpy/index.html',
+            },
+            '---',
+            {
+                'name' : 'Creating arrays',
+                'sub-menu' : [
+                    {
+                        'name' : 'New array of given shape',
+                        'snippet' : ['new_array = np.zeros((4,3,), dtype=complex)',],
+                    },
+                    {
+                        'name' : 'New array shaped like another',
+                        'snippet' : ['new_array = np.zeros_like(old_array, dtype=complex)',],
+                    },
+                    {
+                        'name' : 'Copy of existing data',
+                        'snippet' : ['new_array = np.copy(old_array)',],
+                    },
+                    {
+                        'name' : 'Array from list of data',
+                        'snippet' : ['new_array = np.array([1.2, 3.4, 5.6])',],
+                    },
+                    {
+                        'name' : 'Evenly spaced values within a given interval',
+                        'snippet' : ['new_array = np.arange(1, 10, 2)'],
+                    },
+                    {
+                        'name' : 'Evenly spaced numbers over a specified interval',
+                        'snippet' : ['new_array = np.linspace(1., 10., num=120, endpoint=True)'],
+                    },
+                    {
+                        'name' : 'Numbers spaced evenly on a log scale',
+                        'snippet' : ['new_array = np.logspace(1., 10., num=120, endpoint=True, base=2)'],
+                    },
+                    {
+                        'name' : 'Coordinate matrices from coordinate vectors',
+                        'snippet' : [
+                            'x = np.linspace(0, 1, 7)',
+                            'y = np.linspace(0, 1, 11)',
+                            'xx, yy = np.meshgrid(x, y)',
+                        ],
+                    },
+                    {
+                        'name' : 'Return views of the data, split into $N$ groups',
+                        'snippet' : [
+                            'x = np.arange(12)',
+                            'a,b,c = np.split(x, 3)',
+                        ],
+                    },
+                    {
+                        'name' : 'Return views of the data, split at given indices along given axis',
+                        'snippet' : [
+                            'x = np.arange(27).reshape((3,9))',
+                            'a,b,c = np.split(x, [2,6], axis=1)',
+                        ],
+                    },
+                    {
+                        'name' : 'Return copy of arrays, combined into one',
+                        'snippet' : [
+                            'a = np.arange(30).reshape((2,3,5))',
+                            'b = np.arange(42).reshape((2,3,7))',
+                            'c = np.concatenate((a, b), axis=1)',
+                        ],
+                    },
+                ],
+            },
+
+            {
+                'name' : 'Reshaping and viewing arrays',
+                'sub-menu' : [
+                    {
+                        'name' : 'Return a view of the data, with a different shape',
+                        'snippet' : ['np.arange(6).reshape((3, 2))'],
+                    },
+                    {
+                        'name' : 'Return a view of the data, with an extra axis',
+                        'snippet' : ['a[:, np.newaxis]'],
+                    },
+                    {
+                        'name' : 'Return a view of the data, flattened to 1-D',
+                        'snippet' : ['a.ravel()'],
+                    },
+                    {
+                        'name' : 'Return a copy of the data, flattened to 1-D',
+                        'snippet' : ['a.flatten()'],
+                    },
+                    {
+                        'name' : 'Return a view of the data, with a different dtype',
+                        'snippet' : ['np.linspace(0, 10, num=50).view(complex)'],
+                        'sub-menu' : [
+                            {
+                                'name' : 'View real array as complex',
+                                'snippet' : [
+                                    'r = np.linspace(0, 10, num=100).reshape((25,4))',
+                                    'c = r.view(complex)',
+                                ],
+                            },
+                            {
+                                'name' : 'View complex array as real with extra dimension',
+                                'snippet' : [
+                                    'c = (np.linspace(0, 10, num=50) + 1j*np.linspace(0, 10, num=50))',
+                                    'cv = c.view(float)',
+                                    'r = cv.reshape(c.shape + (2,))',
+                                ],
+                            },
+                        ],
+                    },
+                    {
+                        'name' : 'Return a copy of the data, cast to a different dtype',
+                        'snippet' : ['np.linspace(0, 10, num=50).astype(complex)'],
+                    },
+                    {
+                        'name' : 'Return a view of the data with indices reversed (transposed)',
+                        'snippet' : ['np.arange(210).reshape((2,3,5,7)).transpose()'],
+                    },
+                    {
+                        'name' : 'Return a view of the data with indices permuted',
+                        'snippet' : ['np.arange(210).reshape((2,3,5,7)).transpose((2,1,0,3))'],
+                    },
+                    {
+                        'name' : 'Exchange two axes in an array',
+                        'snippet' : ['np.arange(210).reshape((2,3,5,7)).swapaxes(1,3)'],
+                    },
+                    {
+                        'name' : 'Permute axes, bringing given axis into new position',
+                        'snippet' : ['np.rollaxis(np.arange(210).reshape((2,3,5,7)), 2, 0)'],
+                    },
+                    {
+                        'name' : 'Permute indices by a given amount along the given axis',
+                        'snippet' : ['np.roll(np.arange(10).reshape((2,5)), 2, axis=1)'],
+                    },
+                    {
+                        'name' : 'Return views of the data, split into $N$ groups',
+                        'snippet' : [
+                            'x = np.arange(12)',
+                            'a,b,c = np.split(x, 3)',
+                        ],
+                    },
+                    {
+                        'name' : 'Return views of the data, split at given indices along given axis',
+                        'snippet' : [
+                            'x = np.arange(27).reshape((3,9))',
+                            'a,b,c = np.split(x, [2,6], axis=1)',
+                        ],
+                    },
+                    {
+                        'name' : 'Return copy of arrays, combined into one',
+                        'snippet' : [
+                            'a = np.arange(30).reshape((2,3,5))',
+                            'b = np.arange(42).reshape((2,3,7))',
+                            'c = np.concatenate((a, b), axis=1)',
+                        ],
+                    },
+                ],
+            },
+
+            {
+                'name' : 'Indexing and testing arrays',
+                'sub-menu' : [
+                    {
+                        'name' : 'Indexing documentation',
+                        'external-link' : 'http://docs.scipy.org/doc/numpy/reference/arrays.indexing.html',
+                    },
+                    '---',
+                    {
+                        'name' : 'Test if array is empty',
+                        'snippet' : [
+                            'if a.size > 0:  # Never use `if a` or `if len(a)` for numpy arrays',
+                            '    print(a)',
+                        ],
+                    },
+                    {
+                        'name' : 'Get number of dimensions of array',
+                        'snippet' : ['a.ndim'],
+                    },
+                    {
+                        'name' : 'Get shape of array',
+                        'snippet' : ['a.shape'],
+                    },
+                    {
+                        'name' : 'Index a one-dimensional array',
+                        'sub-menu' : [
+                            {
+                                'name' : 'Get one element',
+                                'snippet' : [
+                                    'a = np.arange(10)',
+                                    'a[3]'
+                                ],
+                            },
+                            {
+                                'name' : 'Get first $N$ elements',
+                                'snippet' : [
+                                    'a = np.arange(10)',
+                                    'a[:3]'
+                                ],
+                            },
+                            {
+                                'name' : 'Get last $N$ elements',
+                                'snippet' : [
+                                    'a = np.arange(10)',
+                                    'a[-3:]'
+                                ],
+                            },
+                            {
+                                'name' : 'Get elements $N$ to $M$',
+                                'snippet' : [
+                                    'a = np.arange(10)',
+                                    'a[3:6]'
+                                ],
+                            },
+                            {
+                                'name' : 'Get elements satisfying a condition',
+                                'snippet' : [
+                                    'a = np.arange(10)',
+                                    'a[a>5]'
+                                ],
+                            },
+                        ],
+                    },
+                    {
+                        'name' : 'Index a multi-dimensional array',
+                        'sub-menu' : [
+                            {
+                                'name' : 'Get one element',
+                                'snippet' : [
+                                    'a = np.arange(30).reshape((2,3,5))',
+                                    'a[1, 2, 4]'
+                                ],
+                            },
+                            {
+                                'name' : 'Get first $N$ elements along each final axis',
+                                'snippet' : [
+                                    'a = np.arange(30).reshape((2,3,5))',
+                                    'a[:, :, :4]'
+                                ],
+                            },
+                            {
+                                'name' : 'Get last $N$ elements along each final axis',
+                                'snippet' : [
+                                    'a = np.arange(30).reshape((2,3,5))',
+                                    'a[:, :, -3:]'
+                                ],
+                            },
+                            {
+                                'name' : 'Get elements $N$ to $M$ along each final axis',
+                                'snippet' : [
+                                    'a = np.arange(30).reshape((2,3,5))',
+                                    'a[:, :, 3:5]'
+                                ],
+                            },
+                            {
+                                'name' : 'Get elements satisfying a condition (flattened result)',
+                                'snippet' : [
+                                    'a = np.arange(30).reshape((2,3,5))',
+                                    'a[a>5]'
+                                ],
+                            },
+                        ],
+                    },
+                    {
+                        'name' : 'Index an array of unknown dimension',
+                        'sub-menu' : [
+                            {
+                                'name' : 'Get first $N$ elements along each final axis',
+                                'snippet' : [
+                                    'a = np.arange(30).reshape((2,3,5))',
+                                    'a[..., :4]'
+                                ],
+                            },
+                            {
+                                'name' : 'Get last $N$ elements along each final axis',
+                                'snippet' : [
+                                    'a = np.arange(30).reshape((2,3,5))',
+                                    'a[..., -3:]'
+                                ],
+                            },
+                            {
+                                'name' : 'Get elements $N$ to $M$ along each final axis',
+                                'snippet' : [
+                                    'a = np.arange(30).reshape((2,3,5))',
+                                    'a[..., 3:5]'
+                                ],
+                            },
+                            {
+                                'name' : 'Get elements satisfying a condition (flattened result)',
+                                'snippet' : [
+                                    'a = np.arange(30).reshape((2,3,5))',
+                                    'a[a>5]'
+                                ],
+                            },
+                        ],
+                    },
+                    {
+                        'name' : '',
+                        'snippet' : [
+                            ''
+                        ],
+                    },
+                ],
+            },
+
+            numpy_ufuncs,
+
+            numpy_polynomial,
+
+            // {
+            //     'name' : 'Polynomials',
+            //     'external-link' : 'http://docs.scipy.org/doc/numpy/reference/routines.polynomials.html',
+            //     // 'sub-menu' : [
+                    
+            //     // ],
+            // },
+
+            {
+                'name' : 'Pretty printing',
+                'sub-menu' : [
+                    {
+                        'name' : 'Context manager',
+                        'snippet' : [
+                            'import contextlib',
+                            '@contextlib.contextmanager',
+                            'def printoptions(*args, **kwargs):',
+                            '    original = np.get_printoptions()',
+                            '    np.set_printoptions(*args, **kwargs)',
+                            '    yield',
+                            '    np.set_printoptions(**original)',
+                        ],
+                    },
+                    '---',
+                    {
+                        'name' : 'Print to given precision',
+                        'snippet' : [
+                            'with printoptions(precision=5):',
+                            '    print(np.random.random(10))',
+                        ],
+                    },
+                    {
+                        'name' : 'Summarize arrays with more than $N+1$ elements',
+                        'snippet' : [
+                            'with printoptions(threshold=5):',
+                            '    print(np.random.random(10))',
+                        ],
+                    },
+                    {
+                        'name' : 'Print $N$ elements at each end of a summary',
+                        'snippet' : [
+                            'with printoptions(threshold=5, edgeitems=4):',
+                            '    print(np.random.random(10))',
+                        ],
+                    },
+                    {
+                        'name' : 'Set number of characters per line',
+                        'snippet' : [
+                            'with printoptions(linewidth=100):',
+                            '    print(np.random.random(10))',
+                        ],
+                    },
+                    {
+                        'name' : 'Suppress printing of small values',
+                        'snippet' : [
+                            'with printoptions(suppress=True):',
+                            '    print(1e-8*np.random.random(10))',
+                        ],
+                    },
+                    {
+                        'name' : 'Set string with which to represent nan',
+                        'snippet' : [
+                            "with printoptions(nanstr='NaN!'):",
+                            '    print(np.array([1, np.nan, 3]))',
+                        ],
+                    },
+                    {
+                        'name' : 'Set string with which to represent infinity',
+                        'snippet' : [
+                            "with printoptions(infstr='oo'):",
+                            '    print(np.array([1, np.inf, 3]))',
+                        ],
+                    },
+                    {
+                        'name' : 'Formatting functions for specific dtypes',
+                        'sub-menu' : [
+                            {
+                                'name' : 'Set formatter for `bool` type',
+                                'snippet' : [
+                                    "def format_bool(x):",
+                                    "    if x:",
+                                    "        return 'TRUE'",
+                                    "    else:",
+                                    "        return 'FALSE'",
+                                    "with printoptions(formatter={'bool': format_bool}):",
+                                    "    print(np.random.randint(0,2,10).astype(bool))",
+                                ],
+                            },
+                            {
+                                'name' : 'Set formatter for `int` type',
+                                'snippet' : [
+                                    "def format_int(x):",
+                                    "    return 'int({0})'.format(x)",
+                                    "with printoptions(formatter={'int': format_int}):",
+                                    "    print(np.random.randint(-3, 4, 10))",
+                                ],
+                            },
+                            {
+                                'name' : 'Set formatter for `timedelta` type',
+                                'snippet' : [
+                                    "def format_timedelta(delta):",
+                                    "    days = delta.astype('timedelta64[D]').astype(int)",
+                                    "    hours = delta.astype('timedelta64[h]').astype(int) - 24*days",
+                                    "    minutes = delta.astype('timedelta64[m]').astype(int) - 60*(24*days+hours)",
+                                    "    seconds = delta.astype('timedelta64[s]').astype(int) - 60*(60*(24*days+hours)+minutes)",
+                                    "    return '{0}days,{1}hours,{2}minutes,{3}seconds'.format(days, hours, minutes, seconds)",
+                                    "with printoptions(formatter={'timedelta': format_timedelta}):",
+                                    "    print(np.array([np.timedelta64(int(sec), 's') for sec in np.random.randint(0, 1000000, 10)]))",
+                                ],
+                            },
+                            {
+                                'name' : 'Set formatter for `datetime` type',
+                                'snippet' : [
+                                    "def format_datetime(date):",
+                                    "    year = date.astype('datetime64[Y]').astype(int) + 1970",
+                                    "    month = date.astype('datetime64[M]').astype(int) % 12 + 1",
+                                    "    day = (date - date.astype('datetime64[M]')).astype(int) + 1",
+                                    "    return 'Y{0}:M{1}:D{2}'.format(year, month, day)",
+                                    "with printoptions(formatter={'datetime': format_datetime}):",
+                                    "    days = np.random.randint(0, 20000, 10)",
+                                    "    dates = np.array([np.datetime64(int(d), 'D') for d in days])",
+                                    "    print(dates)",
+                                ],
+                            },
+                            {
+                                'name' : 'Set formatter for `float` type',
+                                'snippet' : [
+                                    "def format_float(x):",
+                                    "    return '{0:+0.2f}'.format(x)",
+                                    "with printoptions(formatter={'float': format_float}):",
+                                    "    print(np.random.random(10)-0.5)",
+                                ],
+                            },
+                            {
+                                'name' : 'Set formatter for `longfloat` type',
+                                'snippet' : [
+                                    "def format_longfloat(x):",
+                                    "    return 'long{0}'.format(x)",
+                                    "with printoptions(formatter={'longfloat': format_longfloat}):",
+                                    "    print(np.random.random(10).astype(np.longfloat))",
+                                ],
+                            },
+                            {
+                                'name' : 'Set formatter for `complexfloat` type',
+                                'snippet' : [
+                                    "def format_complexfloat(x):",
+                                    "    return '{0.real}+1j*{0.imag}'.format(x)",
+                                    "with printoptions(formatter={'complexfloat': format_complexfloat}):",
+                                    "    print(np.random.random(5)+1j*np.random.random(5))",
+                                ],
+                            },
+                            {
+                                'name' : 'Set formatter for `longcomplexfloat` type',
+                                'snippet' : [
+                                    "def format_longcomplexfloat(x):",
+                                    "    return '{0.real}+1j*{0.imag}'.format(x)",
+                                    "with printoptions(formatter={'longcomplexfloat': format_longcomplexfloat}):",
+                                    "    print(np.random.random(5).astype(np.longfloat)+1j*np.random.random(5).astype(np.longfloat))",
+                                ],
+                            },
+                            // {
+                            //     'name' : 'Set formatter for `numpy_str` type',
+                            //     'snippet' : [
+                            //         "def format_numpy_str(x):",
+                            //         "    return 'n\"{0}\"'.format(x)",
+                            //         "with printoptions(formatter={'numpy_str': format_numpy_str}):",
+                            //         "    print(np.random.random(10))",
+                            //     ],
+                            // },
+                            // {
+                            //     'name' : 'Set formatter for `str` type',
+                            //     'snippet' : [
+                            //         "def format_str(x):",
+                            //         "    return '\"{0}\"'.format(x)",
+                            //         "with printoptions(formatter={'str': format_str}):",
+                            //         "    print(np.random.random(10))",
+                            //     ],
+                            // },
+                            '---',
+                            {
+                                'name' : 'Set formatter for all types',
+                                'snippet' : [
+                                    "def format_all(x):",
+                                    "    return 'repr({0})'.format(repr(x))",
+                                    "with printoptions(formatter={'all': format_all}):",
+                                    "    print(np.array([3, 8]))",
+                                    "    print(np.array([0.1, 0.5]))",
+                                    "    print(np.array([1.4+2.3j, 2.8+4.6j]))",
+                                    "    print(np.array(['abc', 'xyz']))",
+                                ],
+                            },
+                            {
+                                'name' : 'Set formatter for all `int` types',
+                                'snippet' : [
+                                    "def format_int_kind(x):",
+                                    "    return 'int({0})'.format(x)",
+                                    "with printoptions(formatter={'int_kind': format_int_kind}):",
+                                    "    print(np.random.randint(-100, 100, 10))",
+                                ],
+                            },
+                            {
+                                'name' : 'Set formatter for all `float` types',
+                                'snippet' : [
+                                    "def format_float_kind(x):",
+                                    "    return '{0:.2%}'.format(x)",
+                                    "with printoptions(formatter={'float_kind': format_float_kind}):",
+                                    "    print(np.random.random(10))",
+                                ],
+                            },
+                            {
+                                'name' : 'Set formatter for all `complex` types',
+                                'snippet' : [
+                                    "def format_complex_kind(x):",
+                                    "    return '{0.real}+1j*{0.imag}'.format(x)",
+                                    "with printoptions(formatter={'complex_kind': format_complex_kind}):",
+                                    "    print(np.random.random(5)+1j*np.random.random(5))",
+                                ],
+                            },
+                            {
+                                'name' : 'Set formatter for all `str` types',
+                                'snippet' : [
+                                    "def format_str_kind(x):",
+                                    "    return 'str({0})'.format(x)",
+                                    "with printoptions(formatter={'str_kind': format_str_kind}):",
+                                    "    print(np.array(['abc', 'xyz']))",
+                                ],
+                            },
+                        ],
+                    },
+                ],
+            },
+
+            {
+                'name' : 'File I/O',
+                'sub-menu' : [
+                    {
+                        'name' : 'Read data from simple text file',
+                        'snippet' : [
+                            'data = np.loadtxt(filename)',
+                        ],
+                    },
+                    {
+                        'name' : 'Read data from text file with missing values',
+                        'snippet' : [
+                            'data = np.genfromtxt(filename)',
+                        ],
+                    },
+                    {
+                        'name' : 'Read data from .npy or .npz file',
+                        'snippet' : [
+                            'data = np.load(filename)',
+                        ],
+                    },
+                    '---',
+                    {
+                        'name' : 'Write single array to text file',
+                        'snippet' : [
+                            'np.savetxt(filename, x)',
+                        ],
+                    },
+                    {
+                        'name' : 'Write multiple arrays to text file',
+                        'snippet' : [
+                            'np.savetxt(filename, np.transpose((x, y, z)))',
+                        ],
+                    },
+                    {
+                        'name' : 'Write single array to single .npy file',
+                        'snippet' : [
+                            'np.save(filename, x)',
+                        ],
+                    },
+                    {
+                        'name' : 'Write multiple arrays to single .npy file',
+                        'snippet' : [
+                            'np.save(filename, np.transpose((x, y, z)))',
+                        ],
+                    },
+                    {
+                        'name' : 'Write multiple arrays to single .npz file',
+                        'snippet' : [
+                            'np.savez(filename, x, y, z)',
+                        ],
+                    },
+                    {
+                        'name' : 'Write multiple arrays to single compressed .npz file',
+                        'snippet' : [
+                            'np.savez_compressed(filename, x, y, z)',
+                        ],
+                    },
+                ],
+            },
+        ]
+    }
+}
+);

.local/share/jupyter/nbextensions/snippets_menu/snippets_submenus_python/numpy_polynomial.js

@@ -0,0 +1,129 @@
+define({
+    'name' : 'Polynomials',
+    'sub-menu' : [
+        {
+            'name' : 'Setup',
+            'snippet' : [
+                'import numpy as np',
+                'from numpy.polynomial import Polynomial as P',
+                'from numpy.polynomial import Chebyshev as T',
+                'from numpy.polynomial import Legendre as Le',
+                'from numpy.polynomial import Laguerre as La',
+                'from numpy.polynomial import Hermite as H',
+                'from numpy.polynomial import HermiteE as HE',
+            ],
+        },
+        '---',
+        {
+            'name' : 'Instantiate from coefficients',
+            'snippet' : [
+                'poly = P([1, 2, 3])',
+            ],
+        },
+        {
+            'name' : 'Instantiate from roots',
+            'snippet' : [
+                'poly = P.fromroots([1, 2, 3])',
+            ],
+        },
+        {
+            'name' : 'Instantiate from basis element $n$',
+            'snippet' : [
+                'poly = P.basis(n)',
+            ],
+        },
+        {
+            'name' : 'Convert between types',
+            'snippet' : [
+                'from numpy.polynomial import Chebyshev',
+                'polyT = poly.convert(kind=Chebyshev)',
+            ],
+        },
+        '---',
+        {
+            'name' : 'Get coefficients (constant at index 0, higher indices for higher orders)',
+            'snippet' : [
+                'poly.coeff',
+            ],
+        },
+        {
+            'name' : 'Get domain (scaled and offset domain of function for fitting)',
+            'snippet' : [
+                'poly.domain',
+            ],
+        },
+        {
+            'name' : 'Get window (natural domain of basis functions)',
+            'snippet' : [
+                'poly.window',
+            ],
+        },
+        {
+            'name' : 'Get degree of polynomial (one less than number of coefficients)',
+            'snippet' : [
+                'poly.degree()',
+            ],
+        },
+        '---',
+        {
+            'name' : 'Evaluate polynomial at given points',
+            'snippet' : [
+                'x = np.linspace(0, 3.14)',
+                'poly(x)',
+            ],
+        },
+        {
+            'name' : 'Return $n$ equally spaced $(x,y)$ values',
+            'snippet' : [
+                'x, y = poly.linspace(n=100)',
+            ],
+        },
+        {
+            'name' : 'Find roots',
+            'snippet' : [
+                'poly.roots()',
+            ],
+        },
+        {
+            'name' : 'Differentiate once',
+            'snippet' : [
+                'poly.deriv()',
+            ],
+        },
+        {
+            'name' : 'Differentiate $n$ times',
+            'snippet' : [
+                'poly.deriv(n)',
+            ],
+        },
+        {
+            'name' : 'Integrate once',
+            'snippet' : [
+                'poly.integ()',
+            ],
+        },
+        {
+            'name' : 'Integrate $n$ times',
+            'snippet' : [
+                'poly.integ(n)',
+            ],
+        },
+        {
+            'name' : 'Integrate with given lower bound and integration constant $k$',
+            'snippet' : [
+                'poly.integ(lbnd=0.1, k=-2.34',
+            ],
+        },
+        '---',
+        {
+            'name' : 'Fit to data with series of degree $n$',
+            'snippet' : [
+                'np.random.seed(11)',
+                'x = np.linspace(0, 2*np.pi, 20)',
+                'y = np.sin(x) + np.random.normal(scale=.1, size=x.shape)',
+                'n = 5',
+                'p = T.fit(x, y, n)',
+            ],
+        },
+    ],
+});

.local/share/jupyter/nbextensions/snippets_menu/snippets_submenus_python/numpy_ufuncs.js

@@ -0,0 +1,1068 @@
+define({
+    // See <http://docs.scipy.org/doc/numpy/reference/ufuncs.html#available-ufuncs> for a full list
+    'name' : 'Vectorized (universal) functions',
+    'sub-menu' : [
+        {
+            'name' : 'Characterizing arrays',
+            'sub-menu' : [
+                {
+                    'name' : 'max: Return the maximum along a given axis.',
+                    'snippet' : [
+                        'np.max(a, axis=0)',
+                    ],
+                },
+
+                {
+                    'name' : 'argmax: Return indices of the maximum values along the given axis.',
+                    'snippet' : [
+                        'np.argmax(a, axis=0)',
+                    ],
+                },
+
+                {
+                    'name' : 'min: Return the minimum along a given axis.',
+                    'snippet' : [
+                        'np.min(a, axis=0)',
+                    ],
+                },
+
+                {
+                    'name' : 'argmin: Return indices of the minimum values along the given axis of a.',
+                    'snippet' : [
+                        'np.argmin(a, axis=0)',
+                    ],
+                },
+
+                {
+                    'name' : 'ptp: Peak-to-peak (maximum - minimum) value along a given axis.',
+                    'snippet' : [
+                        'np.ptp(a, axis=0)',
+                    ],
+                },
+
+                {
+                    'name' : 'trace: Return the sum along diagonals of the array.',
+                    'snippet' : [
+                        'np.trace(a, axis1, axis2)',
+                    ],
+                },
+
+                {
+                    'name' : 'mean: Returns the average of the array elements along given axis.',
+                    'snippet' : [
+                        'np.mean(a, axis=0)',
+                    ],
+                },
+
+                {
+                    'name' : 'var: Returns the variance of the array elements, along given axis.',
+                    'snippet' : [
+                        'np.var(a, axis=0)',
+                    ],
+                },
+
+                {
+                    'name' : 'std: Returns the standard deviation of the array elements along given axis.',
+                    'snippet' : [
+                        'np.std(a, axis=0)',
+                    ],
+                },
+
+                {
+                    'name' : 'all: Returns True if all elements evaluate to True.',
+                    'snippet' : [
+                        'np.all(a, axis=0)',
+                    ],
+                },
+
+                {
+                    'name' : 'any: Returns True if any of the elements of a evaluate to True.',
+                    'snippet' : [
+                        'np.any(a, axis=0)',
+                    ],
+                },
+            ],
+        },
+
+        {
+            'name' : 'Sums, products, differences within array',
+            'sub-menu' : [
+                {
+                    'name' : 'prod: Product of array elements over a given axis',
+                    'snippet' : [
+                        'np.prod(a, axis=0)',
+                    ],
+                },
+
+                {
+                    'name' : 'sum: Sum of array elements over a given axis',
+                    'snippet' : [
+                        'np.sum(a, axis=0)',
+                    ],
+                },
+
+                {
+                    'name' : 'nansum: Sum of array elements over a given axis treating NaNs as zero',
+                    'snippet' : [
+                        'np.nansum(a, axis=0)',
+                    ],
+                },
+
+                {
+                    'name' : 'cumprod: Cumulative product of elements along a given axis',
+                    'snippet' : [
+                        'np.cumprod(a, axis=0)',
+                    ],
+                },
+
+                {
+                    'name' : 'cumsum: Cumulative sum of the elements along a given axis',
+                    'snippet' : [
+                        'np.cumsum(a, axis=0)',
+                    ],
+                },
+
+                {
+                    'name' : 'diff: Calculate the n-th order discrete difference along given axis',
+                    'snippet' : [
+                        'np.diff(a, n, axis=0)',
+                    ],
+                },
+
+                {
+                    'name' : 'ediff1d: Differences between consecutive elements of an array',
+                    'snippet' : [
+                        'np.ediff1d(a)',
+                    ],
+                },
+
+                {
+                    'name' : 'gradient: Gradient of an N-dimensional array',
+                    'snippet' : [
+                        'np.gradient(f, *varargs, **kwargs)',
+                    ],
+                },
+
+                {
+                    'name' : 'trapz: Integrate along the given axis using the composite trapezoidal rule',
+                    'snippet' : [
+                        'np.trapz(y, x, dx, axis)',
+                    ],
+                },
+
+                {
+                    'name' : 'convolve: Discrete, linear convolution of two one-dimensional sequences',
+                    'snippet' : [
+                        'np.convolve(a, v)',
+                    ],
+                },
+
+                {
+                    'name' : 'interp: One-dimensional linear interpolation',
+                    'snippet' : [
+                        'np.interp(x, xp, fp)',
+                    ],
+                },
+            ],
+        },
+
+
+        {
+            'name' : 'Logarithms and exponentials',
+            'sub-menu' : [
+                {
+                    'name' : 'logaddexp: Logarithm of the sum of exponentiations of the inputs',
+                    'snippet' : [
+                        'np.logaddexp(x1, x2)',
+                    ],
+                },
+
+                {
+                    'name' : 'logaddexp2: Logarithm of the sum of exponentiations of the inputs in base-2',
+                    'snippet' : [
+                        'np.logaddexp2(x1, x2)',
+                    ],
+                },
+
+                {
+                    'name' : 'power: First array elements raised to powers from second array, element-wise',
+                    'snippet' : [
+                        'np.power(x1, x2)',
+                    ],
+                },
+
+                {
+                    'name' : 'power: First array elements raised to powers from second array, element-wise with automatic domain',
+                    'snippet' : [
+                        '# Use np.emath.power when input dtypes are float, but may contain negatives',
+                        'np.emath.power(x1, x2)',
+                    ],
+                },
+
+                {
+                    'name' : 'exp: Calculate the exponential of all elements in the input array',
+                    'snippet' : [
+                        'np.exp(x)',
+                    ],
+                },
+
+                {
+                    'name' : 'exp2: Calculate $2^p$ for all $p$ in the input array',
+                    'snippet' : [
+                        'np.exp2(x)',
+                    ],
+                },
+
+                {
+                    'name' : 'log: Natural logarithm, element-wise',
+                    'snippet' : [
+                        'np.log(x)',
+                    ],
+                },
+
+                {
+                    'name' : 'log: Natural logarithm, element-wise with automatic domain',
+                    'snippet' : [
+                        '# Use np.emath.log when input dtype is float, but may contain negatives',
+                        'np.emath.log(x)',
+                    ],
+                },
+
+                {
+                    'name' : 'log2: Base-2 logarithm of $x$',
+                    'snippet' : [
+                        'np.log2(x)',
+                    ],
+                },
+
+                {
+                    'name' : 'log2: Base-2 logarithm of $x$ with automatic domain',
+                    'snippet' : [
+                        '# Use np.emath.log2 when input dtype is float, but may contain negatives',
+                        'np.emath.log2(x)',
+                    ],
+                },
+
+                {
+                    'name' : 'log10: Return the base 10 logarithm of the input array, element-wise',
+                    'snippet' : [
+                        'np.log10(x)',
+                    ],
+                },
+
+                {
+                    'name' : 'log10: Return the base 10 logarithm of the input array, element-wise with automatic domain',
+                    'snippet' : [
+                        '# Use np.emath.log10 when input dtype is float, but may contain negatives',
+                        'np.emath.log10(x)',
+                    ],
+                },
+
+                {
+                    'name' : 'logn: Return the base $n$ logarithm of the input array, element-wise with automatic domain',
+                    'snippet' : [
+                        '# np.emath.logn allows for inputs with dtype float but possibly containing negatives',
+                        'np.emath.logn(n, x)',
+                    ],
+                },
+
+                {
+                    'name' : 'expm1: Calculate $\\exp(x) - 1$ for all elements in the array',
+                    'snippet' : [
+                        'np.expm1(x)',
+                    ],
+                },
+
+                {
+                    'name' : 'log1p: Calculate $\\log(1+x)$ for all elements in the array',
+                    'snippet' : [
+                        'np.log1p(x)',
+                    ],
+                },
+
+                {
+                    'name' : 'sqrt: Return the positive square-root of an array, element-wise',
+                    'snippet' : [
+                        'np.sqrt(x)',
+                    ],
+                },
+
+                {
+                    'name' : 'sqrt: Return the positive square-root of an array, element-wise with automatic domain',
+                    'snippet' : [
+                        '# Use np.emath.sqrt when argument may contain negative real numbers',
+                        'np.emath.sqrt(x)',
+                    ],
+                },
+
+                {
+                    'name' : 'square: Return the element-wise square of the input',
+                    'snippet' : [
+                        'np.square(x)',
+                    ],
+                },
+
+                {
+                    'name' : 'reciprocal: Return the reciprocal of the argument, element-wise',
+                    'snippet' : [
+                        'np.reciprocal(x)',
+                    ],
+                },
+            ],
+        },
+
+        {
+            'name' : 'Trigonometric and hyperbolic functions',
+            'sub-menu' : [
+                {
+                    'name' : 'sin: Trigonometric sine, element-wise',
+                    'snippet' : [
+                        'np.sin(x)',
+                    ],
+                },
+
+                {
+                    'name' : 'cos: Cosine element-wise',
+                    'snippet' : [
+                        'np.cos(x)',
+                    ],
+                },
+
+                {
+                    'name' : 'tan: Compute tangent element-wise',
+                    'snippet' : [
+                        'np.tan(x)',
+                    ],
+                },
+
+                {
+                    'name' : 'arcsin: Trigonometric inverse sine, element-wise',
+                    'snippet' : [
+                        'np.arcsin(x)',
+                    ],
+                },
+
+                {
+                    'name' : 'arcsin: Trigonometric inverse sine, element-wise with automatic domain',
+                    'snippet' : [
+                        '# Use np.emath.arcsin when input dtype is float, but may contain values outside of [-1,1]',
+                        'np.emath.arcsin(x)',
+                    ],
+                },
+
+                {
+                    'name' : 'arccos: Trigonometric inverse cosine, element-wise',
+                    'snippet' : [
+                        'np.arccos(x)',
+                    ],
+                },
+
+                {
+                    'name' : 'arccos: Trigonometric inverse cosine, element-wise with automatic domain',
+                    'snippet' : [
+                        '# Use np.emath.arccos when input dtype is float, but may contain values outside of [-1,1]',
+                        'np.emath.arccos(x)',
+                    ],
+                },
+
+                {
+                    'name' : 'arctan: Trigonometric inverse tangent, element-wise',
+                    'snippet' : [
+                        'np.arctan(x)',
+                    ],
+                },
+
+                {
+                    'name' : 'arctan2: Element-wise arc tangent of $x_1/x_2$ choosing the quadrant correctly',
+                    'snippet' : [
+                        'np.arctan2(x1, x2)',
+                    ],
+                },
+
+                {
+                    'name' : 'hypot: Given the “legs” of a right triangle, return its hypotenuse',
+                    'snippet' : [
+                        'np.hypot(x1, x2)',
+                    ],
+                },
+
+                '---',
+                
+                {
+                    'name' : 'sinh: Hyperbolic sine, element-wise',
+                    'snippet' : [
+                        'np.sinh(x)',
+                    ],
+                },
+
+                {
+                    'name' : 'cosh: Hyperbolic cosine, element-wise',
+                    'snippet' : [
+                        'np.cosh(x)',
+                    ],
+                },
+
+                {
+                    'name' : 'tanh: Compute hyperbolic tangent element-wise',
+                    'snippet' : [
+                        'np.tanh(x)',
+                    ],
+                },
+
+                {
+                    'name' : 'arcsinh: Inverse hyperbolic sine element-wise',
+                    'snippet' : [
+                        'np.arcsinh(x)',
+                    ],
+                },
+
+                {
+                    'name' : 'arccosh: Inverse hyperbolic cosine, element-wise',
+                    'snippet' : [
+                        'np.arccosh(x)',
+                    ],
+                },
+
+                {
+                    'name' : 'arctanh: Inverse hyperbolic tangent, element-wise',
+                    'snippet' : [
+                        'np.arctanh(x)',
+                    ],
+                },
+
+                {
+                    'name' : 'arctanh: Inverse hyperbolic tangent, element-wise with automatic domain',
+                    'snippet' : [
+                        '# Use np.emath.arctanh when input dtype is float, but may contain values outside of (-1,1)',
+                        'np.emath.arctanh(x)',
+                    ],
+                },
+
+                '---',
+
+                {
+                    'name' : 'deg2rad: Convert angles from degrees to radians',
+                    'snippet' : [
+                        'np.deg2rad(x)',
+                    ],
+                },
+
+                {
+                    'name' : 'rad2deg: Convert angles from radians to degrees',
+                    'snippet' : [
+                        'np.rad2deg(x)',
+                    ],
+                },
+
+                {
+                    'name' : 'unwrap: Unwrap radian phase by changing jumps greater than $\\pi$ to their $2\\pi$ complement',
+                    'snippet' : [
+                        'np.unwrap(x)',
+                    ],
+                },
+            ],
+        },
+
+        {
+            'name' : 'Complex numbers',
+            'sub-menu' : [
+                {
+                    'name' : 'real: Real part of the elements of the array',
+                    'snippet' : [
+                        'np.real(a)',
+                    ],
+                },
+
+                {
+                    'name' : 'imag: Imaginary part of the elements of the array',
+                    'snippet' : [
+                        'np.imag(a)',
+                    ],
+                },
+
+                {
+                    'name' : 'conj: Complex conjugate, element-wise',
+                    'snippet' : [
+                        'np.conj(a)',
+                    ],
+                },
+                
+                {
+                    'name' : 'angle: Angle of the complex argument',
+                    'snippet' : [
+                        'np.angle(a)',
+                    ],
+                },
+
+                {
+                    'name' : 'unwrap: Unwrap radian phase by changing jumps greater than $\\pi$ to their $2\\pi$ complement',
+                    'snippet' : [
+                        'np.unwrap(x)',
+                    ],
+                },
+            ],
+        },
+
+        {
+            'name' : 'Rounding and clipping',
+            'sub-menu' : [
+                {
+                    'name' : 'around: Evenly round to the given number of decimals',
+                    'snippet' : [
+                        'np.around(a, decimals=2)',
+                    ],
+                },
+
+                {
+                    'name' : 'rint: Round elements of the array to the nearest integer',
+                    'snippet' : [
+                        'np.rint(a)',
+                    ],
+                },
+
+                {
+                    'name' : 'fix: Round to nearest integer towards zero',
+                    'snippet' : [
+                        'np.fix(a)',
+                    ],
+                },
+
+                {
+                    'name' : 'floor: Floor of the input, element-wise',
+                    'snippet' : [
+                        'np.floor(a)',
+                    ],
+                },
+
+                {
+                    'name' : 'ceil: Ceiling of the input, element-wise',
+                    'snippet' : [
+                        'np.ceil(a)',
+                    ],
+                },
+
+                {
+                    'name' : 'trunc: Truncated value of the input, element-wise',
+                    'snippet' : [
+                        'np.trunc(a)',
+                    ],
+                },
+
+                {
+                    'name' : 'clip: Clip (limit) the values in an array',
+                    'snippet' : [
+                        'np.clip(a, a_min, a_max)',
+                    ],
+                },
+
+                {
+                    'name' : 'nan_to_num: Replace NaNs with zero and inf with finite numbers',
+                    'snippet' : [
+                        'np.nan_to_num(a)',
+                    ],
+                },
+
+                {
+                    'name' : 'real_if_close: Truncate complex parts if within `tol` times machine epsilon of zero',
+                    'snippet' : [
+                        'np.real_if_close(a, tol=100)',
+                    ],
+                },
+            ],
+        },
+
+        {
+            'name' : 'Float functions',
+            'sub-menu' : [
+                {
+                    'name' : 'isreal: Returns a bool array, where True if input element is real',
+                    'snippet' : [
+                        'np.isreal(x)',
+                    ],
+                },
+
+                {
+                    'name' : 'iscomplex: Returns a bool array, where True if input element is complex',
+                    'snippet' : [
+                        'np.iscomplex(x)',
+                    ],
+                },
+
+                {
+                    'name' : 'isfinite: Test element-wise for finiteness (not infinity and not NaN)',
+                    'snippet' : [
+                        'np.isfinite(x)',
+                    ],
+                },
+
+                {
+                    'name' : 'isinf: Test element-wise for positive or negative infinity',
+                    'snippet' : [
+                        'np.isinf(x)',
+                    ],
+                },
+
+                {
+                    'name' : 'isnan: Test element-wise for NaN and return result as a boolean array',
+                    'snippet' : [
+                        'np.isnan(x)',
+                    ],
+                },
+
+                {
+                    'name' : 'signbit: Returns element-wise True where signbit is set (less than zero)',
+                    'snippet' : [
+                        'np.signbit(x)',
+                    ],
+                },
+
+                {
+                    'name' : 'copysign: Change the sign of $x_1$ to that of $x_2$, element-wise',
+                    'snippet' : [
+                        'np.copysign(x1, x2)',
+                    ],
+                },
+
+                {
+                    'name' : 'nextafter: Return the next floating-point value after $x_1$ towards $x_2$, element-wise',
+                    'snippet' : [
+                        'np.nextafter(x1, x2)',
+                    ],
+                },
+
+                {
+                    'name' : 'modf: Return the fractional and integral parts of an array, element-wise',
+                    'snippet' : [
+                        'np.modf(x)',
+                    ],
+                },
+
+                {
+                    'name' : 'ldexp: Returns $x_1\\, 2^{x_2}$, element-wise',
+                    'snippet' : [
+                        'np.ldexp(x1, x2)',
+                    ],
+                },
+
+                {
+                    'name' : 'frexp: Decompose the elements of $x$ into mantissa and twos exponent',
+                    'snippet' : [
+                        'np.frexp(x)',
+                    ],
+                },
+
+                {
+                    'name' : 'fmod: Return the element-wise remainder of division',
+                    'snippet' : [
+                        'np.fmod(x1, x2)',
+                    ],
+                },
+
+                {
+                    'name' : 'floor: Return the floor of the input, element-wise',
+                    'snippet' : [
+                        'np.floor(x)',
+                    ],
+                },
+
+                {
+                    'name' : 'ceil: Return the ceiling of the input, element-wise',
+                    'snippet' : [
+                        'np.ceil(x)',
+                    ],
+                },
+
+                {
+                    'name' : 'trunc: Return the truncated value of the input, element-wise',
+                    'snippet' : [
+                        'np.trunc(x)',
+                    ],
+                },
+            ],
+        },
+
+        {
+            'name' : 'Bit-twiddling functions',
+            'sub-menu' : [
+                {
+                    'name' : 'bitwise_and: Compute the bit-wise AND of two arrays element-wise',
+                    'snippet' : [
+                        'np.bitwise_and(x1, x2)',
+                    ],
+                },
+
+                {
+                    'name' : 'bitwise_or: Compute the bit-wise OR of two arrays element-wise',
+                    'snippet' : [
+                        'np.bitwise_or(x1, x2)',
+                    ],
+                },
+
+                {
+                    'name' : 'bitwise_xor: Compute the bit-wise XOR of two arrays element-wise',
+                    'snippet' : [
+                        'np.bitwise_xor(x1, x2)',
+                    ],
+                },
+
+                {
+                    'name' : 'invert: Compute bit-wise inversion, or bit-wise NOT, element-wise',
+                    'snippet' : [
+                        'np.invert(x)',
+                    ],
+                },
+
+                {
+                    'name' : 'left_shift: Shift the bits of an integer to the left',
+                    'snippet' : [
+                        'np.left_shift(x1, x2)',
+                    ],
+                },
+
+                {
+                    'name' : 'right_shift: Shift the bits of an integer to the right',
+                    'snippet' : [
+                        'np.right_shift(x1, x2)',
+                    ],
+                },
+            ],
+        },
+
+        {
+            'name' : 'Special functions (see scipy.special)',
+            'sub-menu' : [
+                {
+                    'name' : 'i0: Modified Bessel function of the first kind, order 0',
+                    'snippet' : [
+                        'np.i0(x)',
+                    ],
+                },
+
+                {
+                    'name' : 'sinc: Return the sinc function',
+                    'snippet' : [
+                        'np.sinc(x)',
+                    ],
+                },
+            ],
+        },
+
+        '---',
+
+        {
+            'name' : 'Arithmetic',
+            'sub-menu' : [
+                {
+                    'name' : 'add: Add arguments element-wise',
+                    'snippet' : [
+                        'np.add(x1, x2)',
+                    ],
+                },
+
+                {
+                    'name' : 'subtract: Subtract arguments, element-wise',
+                    'snippet' : [
+                        'np.subtract(x1, x2)',
+                    ],
+                },
+
+                {
+                    'name' : 'multiply: Multiply arguments element-wise',
+                    'snippet' : [
+                        'np.multiply(x1, x2)',
+                    ],
+                },
+
+                {
+                    'name' : 'divide: Divide arguments element-wise',
+                    'snippet' : [
+                        'np.divide(x1, x2)',
+                    ],
+                },
+
+                {
+                    'name' : 'true_divide: Returns a true division of the inputs, element-wise',
+                    'snippet' : [
+                        'np.true_divide(x1, x2)',
+                    ],
+                },
+
+                {
+                    'name' : 'floor_divide: Return the largest integer smaller or equal to the division of the inputs',
+                    'snippet' : [
+                        'np.floor_divide(x1, x2)',
+                    ],
+                },
+
+                {
+                    'name' : 'negative: Numerical negative, element-wise',
+                    'snippet' : [
+                        'np.negative(x)',
+                    ],
+                },
+
+                {
+                    'name' : 'remainder: Return element-wise remainder of integer division',
+                    'snippet' : [
+                        'np.remainder(x1, x2)',
+                    ],
+                },
+
+                {
+                    'name' : 'mod: Return element-wise remainder of integer division',
+                    'snippet' : [
+                        'np.mod(x1, x2) # identical to np.remainder',
+                    ],
+                },
+
+                {
+                    'name' : 'fmod: Return element-wise remainder of float division',
+                    'snippet' : [
+                        'np.fmod(x1, x2)',
+                    ],
+                },
+
+                {
+                    'name' : 'modf: Return the fractional and integral parts of an array, element-wise',
+                    'snippet' : [
+                        'np.modf(x)',
+                    ],
+                },
+
+                {
+                    'name' : 'absolute: Calculate the absolute value element-wise',
+                    'snippet' : [
+                        'np.absolute(x)',
+                    ],
+                },
+
+                {
+                    'name' : 'rint: Round elements of the array to the nearest integer',
+                    'snippet' : [
+                        'np.rint(x)',
+                    ],
+                },
+
+                {
+                    'name' : 'sign: Returns an element-wise indication of the sign of a number',
+                    'snippet' : [
+                        'np.sign(x)',
+                    ],
+                },
+
+                {
+                    'name' : 'conj: Return the complex conjugate, element-wise',
+                    'snippet' : [
+                        'np.conj(x)',
+                    ],
+                },
+
+                {
+                    'name' : 'sqrt: Return the positive square-root of an array, element-wise',
+                    'snippet' : [
+                        'np.sqrt(x)',
+                    ],
+                },
+
+                {
+                    'name' : 'sqrt: Return the positive square-root of an array, element-wise with automatic domain',
+                    'snippet' : [
+                        '# Use np.emath.sqrt when argument may contain negative real numbers',
+                        'np.emath.sqrt(x)',
+                    ],
+                },
+
+                {
+                    'name' : 'square: Return the element-wise square of the input',
+                    'snippet' : [
+                        'np.square(x)',
+                    ],
+                },
+
+                {
+                    'name' : 'reciprocal: Return the reciprocal of the argument, element-wise',
+                    'snippet' : [
+                        'np.reciprocal(x)',
+                    ],
+                },
+            ],
+        },
+
+        {
+            'name' : 'Matrix and vector products',
+            'sub-menu' : [
+                {
+                    'name' : 'tensordot: Tensor dot product over last $n$ axes of a and first $n$ of b',
+                    'snippet' : [
+                        'a = np.arange(60).reshape((5,3,4))',
+                        'b = np.arange(84).reshape((3,4,7))',
+                        'n = 2',
+                        'np.tensordot(a, b, n)',
+                    ],
+                },
+                {
+                    'name' : 'tensordot: Tensor dot product over given pairs of axes',
+                    'snippet' : [
+                        'a = np.arange(24).reshape((3,4,2))',
+                        'axes_a = (2, 0)',
+                        'b = np.arange(30).reshape((2,3,5))',
+                        'axes_b = (0, 1)',
+                        'np.tensordot(a, b, (axes_a, axes_b)',
+                    ],
+                },
+                {
+                    'name' : 'einsum: Evaluate Einstein summation convention on operands',
+                    'snippet' : [
+                        'a = np.arange(6).reshape((3,2))',
+                        'b = np.arange(12).reshape((4,3))',
+                        "np.einsum('ki,jk->ij', a, b)",
+                    ],
+                },
+                {
+                    'name' : 'inner: Inner product, summing over last two axes',
+                    'snippet' : [
+                        'a = np.arange(24).reshape((2,3,4))',
+                        'b = np.arange(4)',
+                        'np.inner(a, b)',
+                    ],
+                },
+                {
+                    'name' : 'outer: Compute outer product of two vectors (automatically flattened)',
+                    'snippet' : [
+                        'a = np.ones((5,))',
+                        'b = np.linspace(-2, 2, 5)',
+                        'np.outer(a, b)',
+                    ],
+                },
+                {
+                    'name' : 'kron: Kronecker product of arrays',
+                    'snippet' : [
+                        'np.kron(np.eye(2), np.ones((2,2)))',
+                    ],
+                },
+                {
+                    'name' : 'vdot: Dot product of two complex vectors, conjugating the first',
+                    'snippet' : [
+                        '',
+                    ],
+                },
+                {
+                    'name' : 'dot: Dot product of two arrays over last and second-to-last dimensions, respectively',
+                    'snippet' : [
+                        '',
+                    ],
+                },
+                {
+                    'name' : 'cross: Cross product of two (arrays of) vectors',
+                    'snippet' : [
+                        'np.cross(a, b)',
+                    ],
+                },
+            ],
+        },
+
+        {
+            'name' : 'Comparisons between two arrays',
+            'sub-menu' : [
+                {
+                    'name' : 'greater: Return the truth value of $(x_1 > x_2)$ element-wise',
+                    'snippet' : [
+                        'np.greater(x1, x2)',
+                    ],
+                },
+
+                {
+                    'name' : 'greater_equal: Return the truth value of $(x_1 \\geq x_2)$ element-wise',
+                    'snippet' : [
+                        'np.greater_equal(x1, x2)',
+                    ],
+                },
+
+                {
+                    'name' : 'less: Return the truth value of $(x_1 < x_2)$ element-wise',
+                    'snippet' : [
+                        'np.less(x1, x2)',
+                    ],
+                },
+
+                {
+                    'name' : 'less_equal: Return the truth value of $(x_1 \\leq x_2)$ element-wise',
+                    'snippet' : [
+                        'np.less_equal(x1, x2)',
+                    ],
+                },
+
+                {
+                    'name' : 'not_equal: Return $(x_1 != x_2)$ element-wise',
+                    'snippet' : [
+                        'np.not_equal(x1, x2)',
+                    ],
+                },
+
+                {
+                    'name' : 'equal: Return $(x_1 == x_2)$ element-wise',
+                    'snippet' : [
+                        'np.equal(x1, x2)',
+                    ],
+                },
+
+                {
+                    'name' : 'logical_and: Compute the truth value of $x_1$ AND $x_2$ element-wise',
+                    'snippet' : [
+                        'np.logical_and(x1, x2)',
+                    ],
+                },
+
+                {
+                    'name' : 'logical_or: Compute the truth value of $x_1$ OR $x_2$ element-wise',
+                    'snippet' : [
+                        'np.logical_or(x1, x2)',
+                    ],
+                },
+
+                {
+                    'name' : 'logical_xor: Compute the truth value of $x_1$ XOR $x_2$, element-wise',
+                    'snippet' : [
+                        'np.logical_xor(x1, x2)',
+                    ],
+                },
+
+                {
+                    'name' : 'logical_not: Compute the truth value of NOT $x$ element-wise',
+                    'snippet' : [
+                        'np.logical_not(x)',
+                    ],
+                },
+
+                {
+                    'name' : 'maximum: Element-wise maximum of array elements',
+                    'snippet' : [
+                        'np.maximum(x1, x2)',
+                    ],
+                },
+
+                {
+                    'name' : 'minimum: Element-wise minimum of array elements',
+                    'snippet' : [
+                        'np.minimum(x1, x2)',
+                    ],
+                },
+
+                {
+                    'name' : 'fmax: Element-wise maximum of array elements',
+                    'snippet' : [
+                        'np.fmax(x1, x2)',
+                    ],
+                },
+
+                {
+                    'name' : 'fmin: Element-wise minimum of array elements',
+                    'snippet' : [
+                        'np.fmin(x1, x2)',
+                    ],
+                },
+            ],
+        },
+
+    ],
+});

.local/share/jupyter/nbextensions/snippets_menu/snippets_submenus_python/python.js

@@ -0,0 +1,209 @@
+define([
+    "require",
+    "./python_regex",
+], function (requirejs, python_regex) {
+    return {
+        'name' : 'Python',
+        'sub-menu' : [
+            {
+                'name' : 'Setup',
+                'snippet' : ['from __future__ import print_function, division',],
+            },
+            {
+                'name' : 'Documentation',
+                'external-link' : 'https://docs.python.org/',
+            },
+            '---',
+
+            {
+                'name' : 'Lists',
+                'sub-menu' : [
+                    {
+                        'name' : 'List comprehension',
+                        'snippet' : ['[x**2 for x in range(-10, 11)]',],
+                    },
+                    {
+                        'name' : 'Conditional list comprehension',
+                        'snippet' : ['[x**2 for x in range(-10, 11) if (x%3)==0]',],
+                    },
+                    {
+                        'name' : 'Conditional alternative list comprehension',
+                        'snippet' : ['[x**2 if (x%3)==0 else x**3 for x in range(-10, 11)]',],
+                    },
+                    {
+                        'name' : 'Reversed list',
+                        'snippet' : ['reversed(l)'],
+                    },
+                    {
+                        'name' : 'Sorted list',
+                        'snippet' : ['sorted(l)'],
+                    },
+                    {
+                        'name' : 'Sort two lists at the same time',
+                        'snippet' : ['x, y = [list(tmp) for tmp in zip(*sorted(zip(x,y), key=lambda pair: pair[0]))]'],
+                    },
+                ],
+            },
+
+            {
+                'name' : 'Basic file input/output',
+                'sub-menu' : [
+                    {
+                        'name' : 'Read file into string',
+                        'snippet' : [
+                            'with open("some/file.txt", "r") as file_handle:',
+                            '    file_contents = file_handle.read()',
+                        ],
+                    },
+                    {
+                        'name' : 'Read file into string, operating on each line',
+                        'snippet' : [
+                            'file_contents = ""',
+                            'with open("some/file.txt", "r") as file_handle:',
+                            '    for line in file_handle.readlines():',
+                            '        file_contents += line.replace("-", "_")',
+                        ],
+                    }
+                ],
+            },
+            
+            {
+                'name' : 'Defining functions',
+                'sub-menu' : [
+                    {
+                        'name' : 'Simple function',
+                        'snippet'  : [
+                            'def bp_some_func(x):',
+                            '    r"""Brief description of the function"""',
+                            '    return x**2',
+                        ],
+                    },
+                    {
+                        'name' : 'Complicated function',
+                        'snippet'  : [
+                            'def bp_some_func(x, y, z=3.14, **kwargs):',
+                            '    r"""Some function',
+                            '    ',
+                            '    Does some stuff.',
+                            '    ',
+                            '    Parameters',
+                            '    ----------',
+                            '    x : int',
+                            '        Description of x',
+                            '    y : str',
+                            '        Description of y',
+                            '    z : float, optional',
+                            '        Description of z.  Defaults to 3.14',
+                            '    **kwargs',
+                            '        Arbitrary optional keyword arguments.',
+                            '        w : float',
+                            '            Defaults to 6.28',
+                            '    ',
+                            '    Returns',
+                            '    -------',
+                            '    double',
+                            '        Some nonsensical number computed from some ugly formula',
+                            '    ',
+                            '    """',
+                            '    w = kwargs.pop("w", 6.28)',
+                            '    if kwargs:',
+                            '        print("Got {0} unused kwargs".format(len(kwargs)))',
+                            '    return (x**2 + len(y)) * (w + z)',
+                        ],
+                    },
+                ],
+            },
+            
+            {
+                'name' : 'Defining classes',
+                'sub-menu' : [
+                    {
+                        'name' : 'Simple class',
+                        'snippet'  : [
+                            'class BPSomeClass(object):',
+                            '    r"""Describe the class"""',
+                            '    def __init__(self, arg1, arg2):',
+                            '        self.attr1 = arg1',
+                            '        self.attr2 = arg2',
+                            '    ',
+                            '    def attribute1(self):',
+                            '        return self.attr1',
+                            'bp_obj = BPSomeClass("a", 2.7182)',
+                            'bp_obj.attribute1()',
+                        ],
+                    },
+                    {
+                        'name' : 'Complicated class',
+                        'snippet'  : [
+                            'class BPSomeClass(object):',
+                            '    """Brief class description',
+                            '    ',
+                            '    Some more extensive description',
+                            '    ',
+                            '    Attributes',
+                            '    ----------',
+                            '    attr1 : string',
+                            '        Purpose of attr1.',
+                            '    attr2 : float',
+                            '        Purpose of attr2.',
+                            '    ',
+                            '    """',
+                            '    ',
+                            '    def __init__(self, param1, param2, param3=0):',
+                            '        """Example of docstring on the __init__ method.',
+                            '        ',
+                            '        Parameters',
+                            '        ----------',
+                            '        param1 : str',
+                            '            Description of `param1`.',
+                            '        param2 : float',
+                            '            Description of `param2`.',
+                            '        param3 : int, optional',
+                            '            Description of `param3`, defaults to 0.',
+                            '        ',
+                            '        """',
+                            '        self.attr1 = param1',
+                            '        self.attr2 = param2',
+                            '        print(param3 // 4)',
+                            '    ',
+                            '    @property',
+                            '    def attribute2(self):',
+                            '        return self.attr2',
+                            '    ',
+                            '    @attribute2.setter',
+                            '    def attribute2(self, new_attr2):',
+                            '        if not isinstance(float, new_attr2):',
+                            '            raise ValueError("attribute2 must be a float, not {0}".format(new_attr2))',
+                            '        self.attr2 = new_attr2',
+                            '',
+                            '',
+                            'bp_obj = BPSomeClass("a", 1.618)',
+                            'print(bp_obj.attribute2)',
+                            'bp_obj.attribute2 = 3.236',
+                            '',
+                        ],
+                    },
+                    {
+                        'name' : 'Subclass',
+                        'snippet'  : [
+                            'class BP_A(object):',
+                            '    def __init__(self, param1):',
+                            '        self.attr1 = param1',
+                            '',
+                            'class BP_B(BP_A):',
+                            '    def __init__(self, param1, param2):',
+                            '        super(BP_B, self).__init__(param1)',
+                            '        self.attr2 = param2',
+                            '',
+                            '',
+                            'bp_b = BP_B("a", "b")',
+                            'print(bp_b.attr1, bp_b.attr2)',
+                        ],
+                    },
+                ],
+            },
+
+            python_regex,
+        ],
+    };
+});

.local/share/jupyter/nbextensions/snippets_menu/snippets_submenus_python/python_regex.js

@@ -0,0 +1,309 @@
+define({
+    'name' : 'Regular expressions',
+    'sub-menu' : [
+        {
+            'name' : 'Setup',
+            'snippet' : [
+                'import re',
+            ],
+        },
+        '---',
+        {
+            'name' : 'Basic search for pattern anywhere in string',
+            'snippet' : [
+                'string = " abc def "',
+                'pattern = re.compile(r"[a-z]+")',
+                'result = re.search(pattern, string)',
+                'if result is not None:',
+                '    print("Substring \'{0}\' was found in the range {1}".format(result.group(), result.span()))',
+            ],
+        },
+        {
+            'name' : 'Basic search (match) for exact pattern at beginning of string',
+            'snippet' : [
+                'string = " abc def "',
+                'pattern = re.compile(r".*[a-z]+")',
+                'result = re.match(pattern, string)',
+                'if result is not None:',
+                '    print("Substring \'{0}\' was found in the range {1}".format(result.group(), result.span()))',
+            ],
+        },
+        {
+            'name' : 'Basic substitution',
+            'snippet' : [
+                'string = " abc def "',
+                'pattern = re.compile(r"[a-z]+")',
+                'new_string = re.sub(pattern, "something", string)',
+                'print("New string is \'{0}\'".format(new_string))',
+            ],
+        },
+        {
+            'name' : 'Substitution with backreferences',
+            'snippet' : [
+                'string = "John Doe lives at 221B Baker Street."',
+                'pattern = re.compile(r"""',
+                '    ([a-zA-Z ]+)      # Save as many letters and spaces as possible to group 1',
+                '    \\ lives\\ at\\      # Match " lives at "',
+                '    (?P<address>.*)   # Save everything in between as a group named `address`',
+                '    \\.                # Match the period at the end',
+                '""", re.VERBOSE)',
+                'new_string = re.sub(pattern, r"\\g<address> is occupied by \\1.", string)',
+                'print("New string is \'{0}\'".format(new_string))',
+            ],
+        },
+        '---',
+        {
+            'name' : 'Escaped special characters',
+            'sub-menu' : [
+                {
+                    'name' : '.',
+                    'snippet' : ['\\.',],
+                },
+                {
+                    'name' : '^',
+                    'snippet' : ['\\^',],
+                },
+                {
+                    'name' : '$',
+                    'snippet' : ['\\$',],
+                },
+                {
+                    'name' : '*',
+                    'snippet' : ['\\*',],
+                },
+                {
+                    'name' : '+',
+                    'snippet' : ['\\+',],
+                },
+                {
+                    'name' : '?',
+                    'snippet' : ['\\?',],
+                },
+                {
+                    'name' : '{',
+                    'snippet' : ['\\{',],
+                },
+                {
+                    'name' : '}',
+                    'snippet' : ['\\}',],
+                },
+                {
+                    'name' : '[',
+                    'snippet' : ['\\[',],
+                },
+                {
+                    'name' : ']',
+                    'snippet' : ['\\]',],
+                },
+                {
+                    'name' : '\\',
+                    'snippet' : ['\\\\',],
+                },
+                {
+                    'name' : '|',
+                    'snippet' : ['\\|',],
+                },
+                {
+                    'name' : '(',
+                    'snippet' : ['\\(',],
+                },
+                {
+                    'name' : ')',
+                    'snippet' : ['\\)',],
+                },
+            ],
+        },
+
+        {
+            'name' : 'Character classes and alternatives',
+            'sub-menu' : [
+                {
+                    'name' : 'Standard character-class abbreviations',
+                    'sub-menu' : [
+                        {
+                            'name' : 'Any decimal digit',
+                            'snippet' : ['\\d',],
+                        },
+                        {
+                            'name' : 'Any non-digit character',
+                            'snippet' : ['\\D',],
+                        },
+                        {
+                            'name' : 'Any whitespace character',
+                            'snippet' : ['\\s',],
+                        },
+                        {
+                            'name' : 'Any non-whitespace character',
+                            'snippet' : ['\\S',],
+                        },
+                        {
+                            'name' : 'Any alphanumeric character',
+                            'snippet' : ['\\w',],
+                        },
+                        {
+                            'name' : 'Any non-alphanumeric character',
+                            'snippet' : ['\\W',],
+                        },
+                    ],
+                },
+                {
+                    'name' : 'Inclusive character classes',
+                    'snippet' : [
+                        '[a-zA-Z0-9 \\t\\n\\r\\f\\v]',
+                    ],
+                },
+                {
+                    'name' : 'Exclusive character classes',
+                    'snippet' : [
+                        '[^a-zA-Z0-9]',
+                    ],
+                },
+                {
+                    'name' : 'Alternatives',
+                    'snippet' : [
+                        '(?:abc|def)',
+                    ],
+                },
+                
+            ],
+        },
+
+        {
+            'name' : 'Repetition',
+            'sub-menu' : [
+                {
+                    'name' : 'Match 0 or more repetitions of the preceding, greedily',
+                    'snippet' : ['*',],
+                },
+                {
+                    'name' : 'Match 1 or more repetitions of the preceding, greedily',
+                    'snippet' : ['+',],
+                },
+                {
+                    'name' : 'Match 0 or 1 repetitions of the preceding, greedily',
+                    'snippet' : ['?',],
+                },
+                '---',
+                {
+                    'name' : 'Match 0 or more repetitions of the preceding, non-greedily',
+                    'snippet' : ['*?',],
+                },
+                {
+                    'name' : 'Match 1 or more repetitions of the preceding, non-greedily',
+                    'snippet' : ['+?',],
+                },
+                {
+                    'name' : 'Match 0 or 1 repetitions of the preceding, non-greedily',
+                    'snippet' : ['??',],
+                },
+                '---',
+                {
+                    'name' : 'Match exactly n repeititions of the preceding',
+                    'snippet' : ['{3}',],
+                },
+                {
+                    'name' : 'Match between m and n repetions of the preceding, greedily',
+                    'snippet' : ['{3,5}',],
+                },
+                {
+                    'name' : 'Match between m and n repetions of the preceding, non-greedily',
+                    'snippet' : ['{3,5}?',],
+                },
+            ],
+        },
+
+        // {
+        //     'name' : '',
+        //     'sub-menu' : [
+                
+        //     ],
+        // },
+
+        // {
+        //     'name' : '',
+        //     'sub-menu' : [
+                
+        //     ],
+        // },
+
+        {
+            'name' : 'Lookahead/behind',
+            'sub-menu' : [
+                {
+                    'name' : 'Positive lookahead',
+                    'snippet' : [
+                        'string = "Isaac Asimov"',
+                        'pattern = re.compile(r"Isaac(?= Asimov)")  # Only match "Isaac Asimov", but drop the " Asimov"',
+                        'result = re.match(pattern, string)',
+                        'if result is not None:',
+                        '    print("Substring \'{0}\' was found in the range {1}".format(result.group(), result.span()))',
+                    ],
+                },
+                {
+                    'name' : 'Negative lookahead',
+                    'snippet' : [
+                        'string = "Isaac Newton"',
+                        'pattern = re.compile(r"Isaac(?! Asimov)")  # Match any Isaac except Asimov, and only keep the "Isaac"',
+                        'result = re.match(pattern, string)',
+                        'if result is not None:',
+                        '    print("Substring \'{0}\' was found in the range {1}".format(result.group(), result.span()))',
+                    ],
+                },
+                {
+                    'name' : 'Positive lookbehind',
+                    'snippet' : [
+                        'string = "Janet Asimov"',
+                        'pattern = re.compile(r"(?<=Janet )Asimov")  # Only match "Janet Asimov", but drop the "Janet "',
+                        'result = re.search(pattern, string)',
+                        'if result is not None:',
+                        '    print("Substring \'{0}\' was found in the range {1}".format(result.group(), result.span()))',
+                    ],
+                },
+                {
+                    'name' : 'Negative lookbehind',
+                    'snippet' : [
+                        'string = "Janet Asimov"',
+                        'pattern = re.compile(r"(?<!Isaac )Asimov")  # Will match any Asimov except Isaac, and only keep "Asimov"',
+                        'result = re.search(pattern, string)',
+                        'if result is not None:',
+                        '    print("Substring \'{0}\' was found in the range {1}".format(result.group(), result.span()))',
+                    ],
+                },
+            ],
+        },
+
+        {
+            'name' : 'Compilation flags',
+            'sub-menu' : [
+                {
+                    'name' : 'Enable verbose REs, for cleaner and more organized code',
+                    'snippet' : ['re.VERBOSE',],
+                },
+                {
+                    'name' : 'Do case-insensitive matches',
+                    'snippet' : ['re.IGNORECASE',],
+                },
+                {
+                    'name' : 'Make "." match any character, including newlines',
+                    'snippet' : ['re.DOTALL',],
+                },
+                {
+                    'name' : 'Multi-line matching, affecting "^" and "$"',
+                    'snippet' : ['re.MULTILINE',],
+                },
+                {
+                    'name' : 'Make \\w, \\W, \\b, \\B, \\s, and \\S Unicode aware',
+                    'snippet' : ['re.UNICODE',],
+                },
+                {
+                    'name' : 'Make \\w, \\W, \\b, \\B, \\s, and \\S dependent on the current locale',
+                    'snippet' : ['re.LOCALE',],
+                },
+                {
+                    'name' : 'Display debug info about compiled regex',
+                    'snippet' : ['re.DEBUG',],
+                },
+            ],
+        },
+    ],
+});

.local/share/jupyter/nbextensions/snippets_menu/snippets_submenus_python/sympy.js

@@ -0,0 +1,750 @@
+define([
+    "require",
+    "./sympy_functions",
+    "./sympy_assumptions",
+], function (requirejs, sympy_functions, sympy_assumptions) {
+    return {
+        'name' : 'SymPy',
+        'sub-menu' : [
+            {
+                'name' : 'Setup',
+                'snippet'  : [
+                    'from __future__ import print_function, division',
+                    'from sympy import *',
+                    'a, s, t, u, v, w, x, y, z = symbols("a, s, t, u, v, w, x, y, z")',
+                    'k, m, n = symbols("k, m, n", integer=True)',
+                    'f, g, h = symbols("f, g, h", cls=Function)',
+                    'init_printing()',
+                ],
+            },
+            {
+                'name' : 'Documentation',
+                'external-link' : 'http://docs.sympy.org/latest/index.html',
+            },
+            '---',
+            {
+                'name' : 'Constants',
+                'sub-menu' : [
+                    {
+                        'name' : '1',
+                        'snippet' : ['S(1)',], //'S.One',],
+                    },
+                    // {
+                    //     'name' : '0',
+                    //     'snippet' : ['S.Zero',],
+                    // },
+                    // {
+                    //     'name' : '-1',
+                    //     'snippet' : ['S.NegativeOne',],
+                    // },
+                    {
+                        'name' : '1/2',
+                        'snippet' : ['S(1)/2',], //'S.Half',],
+                    },
+                    {
+                        'name' : 'Rational numbers',
+                        'snippet' : ['Rational(3, 7)',],
+                    },
+                    '---',
+                    {
+                        'name' : 'Base of natural logarithm, \\(e\\)',
+                        'snippet' : ['E',],
+                    },
+                    {
+                        'name' : 'Unit imaginary number, \\(i\\)',
+                        'snippet' : ['I',],
+                    },
+                    {
+                        'name' : 'Geometric constant, \\(\\pi\\)',
+                        'snippet' : ['pi',],
+                    },
+                    {
+                        'name' : 'Golden ratio, \\(\\phi\\)',
+                        'snippet' : ['GoldenRatio',],
+                    },
+                    {
+                        'name' : 'Euler-Mascheroni constant, \\(\\gamma\\)',
+                        'snippet' : ['EulerGamma',],
+                    },
+                    {
+                        'name' : 'Catalan\'s constant, \\(K\\)',
+                        'snippet' : ['Catalan',],
+                    },
+                    '---',
+                    {
+                        'name' : 'Infinity, \\(\\infty\\)',
+                        'snippet' : ['oo',], // 'S.Infinity'
+                    },
+                    // {
+                    //     'name' : 'Negative infinity, \\(-\\infty\\)',
+                    //     'snippet' : ['S.NegativeInfinity',],
+                    // },
+                    {
+                        'name' : 'Complex infinity, \\(\\tilde{\\infty}\\)',
+                        'snippet' : ['zoo'], //'S.ComplexInfinity',],
+                    },
+                    {
+                        'name' : 'NaN',
+                        'snippet' : ['nan',], // 'S.NaN'
+                    },
+                ],
+            },
+            sympy_functions,
+            {
+                'name' : 'Calculus',
+                'sub-menu' : [
+                    {
+                        'name' : 'Differentiate once',
+                        'snippet' : [
+                            'expr = exp(x**2)',
+                            'deriv = diff(expr, x)',
+                        ],
+                    },
+                    {
+                        'name' : 'Differentiate multiple times',
+                        'snippet' : [
+                            'expr = x**4',
+                            'deriv = diff(expr, x, 3)',
+                        ],
+                    },
+                    {
+                        'name' : 'Mixed partial derivatives',
+                        'snippet' : [
+                            'expr = exp(x*y*z)',
+                            'deriv = diff(expr, x, y, 2, z, 4)',
+                        ],
+                    },
+                    {
+                        'name' : 'Finite differences',
+                        'snippet' : [
+                            'dx0, dx1 = symbols("dx0, dx1")',
+                            'formula = as_finite_diff(f(x).diff(x), [x-dx0, x, x+dx1])',
+                        ],
+                    },
+                    '---',
+                    {
+                        'name' : 'Indefinite integral',
+                        'snippet' : [
+                            'integral = integrate(cos(x), x)',
+                        ],
+                    },
+                    {
+                        'name' : 'Definite integral',
+                        'snippet' : [
+                            'integral = integrate(exp(-x), (x, 0, oo))',
+                        ],
+                    },
+                    {
+                        'name' : 'Double integral',
+                        'snippet' : [
+                            'integral = integrate(exp(-x**2-y**2), (x, -oo, oo), (y, -oo, oo))',
+                        ],
+                    },
+                    '---',
+                    {
+                        'name' : 'Limits',
+                        'snippet' : [
+                            'lim = limit(sin(x)/x, x, 0, "+")',
+                        ],
+                    },
+                    {
+                        'name' : 'Series expansion',
+                        'snippet' : [
+                            'expr = exp(sin(x))',
+                            'ser = series(expr, x, 0, 6)',
+                        ],
+                    },
+                    {
+                        'name' : 'Series expansion, removing order term',
+                        'snippet' : [
+                            'expr = exp(sin(x))',
+                            'ser = series(expr, x, 0, 6).removeO()',
+                        ],
+                    },
+                    {
+                        'name' : 'Summations',
+                        'snippet' : [
+                            'ell_min,ell,ell_max = symbols("ell_min,ell,ell_max", integer=True)',
+                            'summ = summation((2*ell + 1), (ell, ell_min, ell_max))',
+                        ],
+                    },
+                ],
+            },
+
+            {
+                'name' : 'Solvers',
+                'sub-menu' : [
+                    {
+                        'name' : 'Solve for one variable',
+                        'snippet' : [
+                            'expr = x**4 - 4*x**3 + 2*x**2 - x',
+                            'eqn = Eq(expr, 0)',
+                            'soln = solve(eqn, x)',
+                        ],
+                    },
+                    {
+                        'name' : 'Solve for two variables',
+                        'snippet' : [
+                            'eqns = Eq(x + y, 4), Eq(x*y, 3)',
+                            'soln = solve(eqns, [x,y])',
+                        ],
+                    },
+                    {
+                        'name' : 'Solve differential equation',
+                        'snippet' : [
+                            'expr = f(x).diff(x, x) + 9*f(x)',
+                            "eqn = Eq(expr, 1)  # f''(x) + 9f(x) = 1",
+                            'soln = dsolve(eqn, f(x))',
+                        ],
+                    },
+                ],
+            },
+            {
+                'name' : 'Manipulating expressions',
+                'sub-menu' : [
+                    {
+                        'name' : 'Simplify',
+                        'snippet' : [
+                            'expr = (x**3 + x**2 - x - 1)/(x**2 + 2*x + 1)',
+                            'expr = simplify(expr)',
+                        ],
+                    },
+                    {
+                        'name' : 'Refine, using assumptions',
+                        // 'snippet' : [
+                        //     'expr = exp(pi*I*2*x)',
+                        //     'assumption = Q.integer(x) & Q.integer(y)',
+                        //     'expr = refine(expr, assumption)',
+                        // ],
+                        'sub-menu' : [
+                            {
+                                'name' : 'Refine',
+                                'snippet' : [
+                                    'expr = exp(pi*I*2*(x+y))',
+                                    'assumption = Q.integer(x) & Q.integer(y)',
+                                    'expr = refine(expr, assumption)',
+                                ],
+                            },
+                            {
+                                'name' : 'Refine in context manager',
+                                'snippet' : [
+                                    'expr = exp(pi*I*2*(x+y))',
+                                    'with assuming(Q.integer(x) & Q.integer(y)):',
+                                    '    expr = refine(expr)',
+                                ],
+                            },
+                            sympy_assumptions,
+                        ],
+                    },
+                    {
+                        'name' : 'Expansion',
+                        'sub-menu' : [
+                            {
+                                'name' : 'Expand basic expressions',
+                                'snippet' : [
+                                    'expr = (x + 2)*(x - 3)',
+                                    'expr = expand(expr)',
+                                ],
+                            },
+                            '---',
+                            {
+                                'name' : 'Expand, including complex parts',
+                                'snippet' : [
+                                    'expr = cos(x)',
+                                    'expr = expand(expr, complex=True)',
+                                ],
+                            },
+                            {
+                                'name' : 'Expand, including functions',
+                                'snippet' : [
+                                    'expr = gamma(x+3)',
+                                    'expr = expand(expr, func=True)',
+                                ],
+                            },
+                            {
+                                'name' : 'Expand, including trig',
+                                'snippet' : [
+                                    'expr = sin(x+y)*(x+y)',
+                                    'expr = expand(expr, trig=True)',
+                                ],
+                            },
+                            '---',
+                            {
+                                'name' : 'Expand only real and imaginary parts',
+                                'snippet' : [
+                                    'expand_complex(x)',
+                                ],
+                            },
+                            {
+                                'name' : 'Expand only functions',
+                                'snippet' : [
+                                    'expr = gamma(x + 2)',
+                                    'expr = expand_func(expr)',
+                                ],
+                            },
+                            {
+                                'name' : 'Expand only hypergeometric functions',
+                                'snippet' : [
+                                    'expr = hyper([1,1], [1,], z) + gamma(z)',
+                                    'expr = hyperexpand(expr)',
+                                ],
+                            },
+                            {
+                                'name' : 'Expand only logarithms',
+                                'snippet' : [
+                                    'a, b = symbols("a, b", positive=True)',
+                                    'expr = log(a**2*b)',
+                                    'expr = expand_log(expr)',
+                                ],
+                            },
+                            {
+                                'name' : 'Expand only multiplication over addition',
+                                'snippet' : [
+                                    'expr = y*(x + z)',
+                                    'expr = expand_mul(expr)',
+                                ],
+                            },
+                            {
+                                'name' : 'Expand only multinomials',
+                                'snippet' : [
+                                    'expr = (x + y + z)**3',
+                                    'expr = expand_multinomial(expr)',
+                                ],
+                            },
+                            {
+                                'name' : 'Expand only powers of multiplied bases',
+                                'snippet' : [
+                                    'a, b = symbols("a, b", positive=True)',
+                                    'expr = (a*b)**z',
+                                    'expr = expand_power_base(expr)',
+                                ],
+                            },
+                            {
+                                'name' : 'Expand only addition in exponents',
+                                'snippet' : [
+                                    'expr = x**(y + 2)',
+                                    'expr = expand_power_exp(expr)',
+                                ],
+                            },
+                            {
+                                'name' : 'Expand only trig',
+                                'snippet' : [
+                                    'expr = sin(x+y)*(x+y)',
+                                    'expr = expand_trig(expr)',
+                                ],
+                            },
+                        ],
+                    },
+                    {
+                        'name' : 'Collect terms',
+                        'sub-menu' : [
+                            {
+                                'name' : 'Collect as coefficients of one factor',
+                                'snippet' : [
+                                    'expr = y*x**2 + z*x**2 + t*x - 2*x + 3',
+                                    'expr = collect(expr, x)',
+                                ],
+                            },
+                            {
+                                'name' : 'Collect as coefficients of multiple factors',
+                                'snippet' : [
+                                    'expr = x**2 + y*x**2 + x*y + y + z*y',
+                                    'expr = collect(expr, [x, y])',
+                                ],
+                            },
+                            {
+                                'name' : 'Collect with respect to wild card',
+                                'snippet' : [
+                                    'w = Wild("w")',
+                                    'expr = z*x**y - t*z**y',
+                                    'expr = collect(expr, w**y)',
+                                ],
+                            },
+                            {
+                                'name' : 'Collect and apply function to each coefficient',
+                                'snippet' : [
+                                    'expr = expand((x + y + 1)**3)',
+                                    'expr = collect(expr, x, factor)',
+                                ],
+                            },
+                            {
+                                'name' : 'Recursively collect',
+                                'snippet' : [
+                                    'expr = (x**2*y + x*y + x + y)/(x*y + z*y)',
+                                    'expr = rcollect(expr, y)',
+                                ],
+                            },
+                            {
+                                'name' : 'Collect constants',
+                                'snippet' : [
+                                    'expr = sqrt(3)*x + sqrt(7)*x + sqrt(3) + sqrt(7)',
+                                    'expr = collect_const(expr)',
+                                ],
+                            },
+                        ],
+                    },
+                    {
+                        'name' : 'Substitutions and replacements',
+                        'sub-menu' : [
+                            {
+                                'name' : 'Substitute one subexpression for another',
+                                'snippet' : [
+                                    'expr = 1 + x*y',
+                                    'expr = expr.subs(x, pi)',
+                                ],
+                            },
+                            {
+                                'name' : 'Substitute multiple subexpressions successively',
+                                'snippet' : [
+                                    'expr = (x+y)/y',
+                                    'substitutions = [(x+y, y), (y, x+y)]',
+                                    'expr = expr.subs(substitutions)',
+                                ],
+                            },
+                            {
+                                'name' : 'Substitute multiple subexpressions simultaneously',
+                                'snippet' : [
+                                    'expr = (x+y)/y',
+                                    'substitutions = [(x+y, y), (y, x+y)]',
+                                    'expr = expr.subs(substitutions, simultaneous=True)',
+                                ],
+                            },
+                            '---',
+                            {
+                                'name' : 'Replace one object with another',
+                                'snippet' : [
+                                    'expr = 1 + x*y',
+                                    'expr = expr.replace(x, pi)',
+                                ],
+                            },
+                            {
+                                'name' : 'Replace one object with some function of its arguments',
+                                'snippet' : [
+                                    'expr = log(sin(x)) + tan(sin(x**2))',
+                                    'expr = expr.replace(sin, lambda arg: sin(2*arg))',
+                                ],
+                            },
+                            {
+                                'name' : 'Replace a pattern with an object',
+                                'snippet' : [
+                                    '# Note: `exclude=` specifies that the Wild cannot match any item in the list',
+                                    'a, b = symbols("a, b", cls=Wild, exclude=[x,y])',
+                                    'expr = 2*x + y + z',
+                                    'wild = a*x + b',
+                                    'replacement = b - a',
+                                    '# Note: `exact=True` demands that all Wilds have nonzero matches',
+                                    'expr = expr.replace(wild, replacement, exact=True)',
+                                ],
+                            },
+                            {
+                                'name' : 'Replace a pattern with some function of that object',
+                                'snippet' : [
+                                    'a = symbols("a", cls=Wild, exclude=[])',
+                                    'expr = log(sin(x)) + tan(sin(x**2))',
+                                    'expr.replace(sin(a), lambda a: sin(2*a))',
+                                ],
+                            },
+                            {
+                                'name' : 'Replace anything with some function of that thing',
+                                'snippet' : [
+                                    'g = 2*sin(x**3)',
+                                    'g.replace(lambda expr: expr.is_Function, lambda expr: expr**2)',
+                                ],
+                            },
+                            '---',
+                            {
+                                'name' : 'Replace exact subexpressions',
+                                'snippet' : [
+                                    'expr = x**2 + x**4',
+                                    'replacements = {x**2: y}',
+                                    'expr = expr.xreplace(replacements)',
+                                ],
+                            },
+                            // {
+                            //     'name' : 'rewrite',
+                            //     'snippet' : [
+                            //         'expr = tan(x)',
+                            //         'expr = expr.rewrite(sin)',
+                            //     ],
+                            // },
+                        ],
+                    },
+                    {
+                        'name' : 'Evaluation',
+                        'sub-menu' : [
+                            {
+                                'name' : 'Evaluate numerically to arbitrary precision',
+                                'snippet' : [
+                                    'expr = x * sqrt(8)',
+                                    'precision = 50',
+                                    'val = N(expr, precision, subs={x:2.4})',
+                                ],
+                            },
+                            {
+                                'name' : 'Evaluate numerically to python float',
+                                'snippet' : [
+                                    'expr = x * sqrt(8)',
+                                    'val = float(expr.subs([(x, 2.4)]))',
+                                ],
+                            },
+                            {
+                                'name' : 'Create numpy function for efficient evaluation',
+                                'snippet' : [
+                                    'import numpy',
+                                    'a = numpy.arange(10)',
+                                    'expr = sin(x)',
+                                    'f = lambdify(x, expr, "numpy")',
+                                    'vals = f(a)',
+                                ],
+                            },
+                        ],
+                    },
+                    '---',
+                    {
+                        'name' : 'Polynomials',
+                        'sub-menu' : [
+                            {
+                                'name' : 'Factor polynomial over rationals',
+                                'snippet' : [
+                                    'expr = x**3 - x**2 + x - 1',
+                                    'expr = factor(expr)',
+                                ],
+                            },
+                            {
+                                'name' : 'Collect common powers of a term',
+                                'snippet' : [
+                                    'expr = x*y + x - 3 + 2*x**2 - z*x**2 + x**3',
+                                    'expr = collect(expr, x)',
+                                ],
+                            },
+                            {
+                                'name' : 'Extract coefficient of a term',
+                                'snippet' : [
+                                    'expr = 3+2*x+4*x**2',
+                                    'expr = expr.coeff(x**2)',
+                                ],
+                            },
+                        ],
+                    },
+                    {
+                        'name' : 'Rational functions',
+                        'sub-menu' : [
+                            {
+                                'name' : 'Cancel',
+                                'snippet' : [
+                                    'expr = (x**2 + 2*x + 1)/(x**2 + x)',
+                                    'expr = cancel(expr)',
+                                ],
+                            },
+                            {
+                                'name' : 'Decompose into partial fractions',
+                                'snippet' : [
+                                    'expr = (4*x**3 + 21*x**2 + 10*x + 12)/(x**4 + 5*x**3 + 5*x**2 + 4*x)',
+                                    'expr = apart(expr)',
+                                ],
+                            },
+                            {
+                                'name' : 'Join over common denominator',
+                                'snippet' : [
+                                    'expr = 1/x + 1/y',
+                                    'expr = ratsimp(expr)',
+                                ],
+                            },
+                            {
+                                'name' : 'Remove square roots from denominator',
+                                'snippet' : [
+                                    'expr = 1/(1+I)',
+                                    'expr = radsimp(expr)',
+                                ],
+                            },
+                        ],
+                    },
+                    {
+                        'name' : 'Powers',
+                        'sub-menu' : [
+                            {
+                                'name' : 'Important caveats',
+                                'external-link' : 'http://docs.sympy.org/dev/tutorial/simplification.html#powers'
+                            },
+                            '---',
+                            // {
+                            //     'name' : 'Setup for these snippets',
+                            //     'snippet' : [
+                            //         'x, y = symbols("x, y", positive=True)',
+                            //         'a, b = symbols("a, b", real=True)',
+                            //         'z, t, c = symbols("z, t, c")',
+                            //     ],
+                            // },
+                            {
+                                'name' : 'Simplify powers for general arguments',
+                                'snippet' : [
+                                    'powsimp(x**y * x**z)',
+                                ],
+                            },
+                            {
+                                'name' : 'Simplify powers, forcing assumptions',
+                                'snippet' : [
+                                    'powsimp(x**y * x**z, force=True)',
+                                ],
+                            },
+                            {
+                                'name' : 'Expand powers by exponent for general arguments',
+                                'snippet' : [
+                                    'expand_power_exp(x**(y + z))',
+                                ],
+                            },
+                            {
+                                'name' : 'Expand powers of multiplied bases, forcing assumptions',
+                                'snippet' : [
+                                    'expand_power_base((x*y)**z, force=True)',
+                                ],
+                            },
+                            {
+                                'name' : 'Collect exponents on powers for general arguments',
+                                'snippet' : [
+                                    'powdenest((x**y)**z)',
+                                ],
+                            },
+                            {
+                                'name' : 'Collect exponents on powers, forcing assumptions',
+                                'snippet' : [
+                                    'powdenest((x**y)**z, force=True)',
+                                ],
+                            },
+                            {
+                                'name' : 'Collect exponents on powers, forcing assumptions and polar simplifications',
+                                'snippet' : [
+                                    'powdenest((z**a)**b, force=True, polar=True)',
+                                ],
+                            },
+                            {
+                                'name' : 'Denest square-roots',
+                                'snippet' : [
+                                    'sqrtdenest(sqrt(5 + 2*sqrt(6)))',
+                                ],
+                            },
+                        ],
+                    },
+                    {
+                        'name' : 'Exponentials and Logarithms',
+                        'sub-menu' : [
+                            {
+                                'name' : 'Important caveats',
+                                'external-link' : 'http://docs.sympy.org/dev/tutorial/simplification.html#exponentials-and-logarithms'
+                            },
+                            '---',
+                            // {
+                            //     'name' : 'Setup for these snippets',
+                            //     'snippet' : [
+                            //         'x, y = symbols("x, y", positive=True)',
+                            //         'n = symbols("n", real=True)',
+                            //     ],
+                            // },
+                            {
+                                'name' : 'Combine exponentials',
+                                'snippet' : [
+                                    'powsimp(exp(y) * exp(z))',
+                                ],
+                            },
+                            {
+                                'name' : 'Expand logarithms for general arguments',
+                                'snippet' : [
+                                    'expand_log(log(x*y))',
+                                ],
+                            },
+                            {
+                                'name' : 'Expand logarithms, forcing assumptions',
+                                'snippet' : [
+                                    'expand_log(log(z**2), force=True)',
+                                ],
+                            },
+                            {
+                                'name' : 'Combine logarithms for general arguments',
+                                'snippet' : [
+                                    'logcombine(log(x) + z*log(y))',
+                                ],
+                            },
+                            {
+                                'name' : 'Combine logarithms, forcing assumptions',
+                                'snippet' : [
+                                    'logcombine(log(x) + z*log(y))',
+                                ],
+                            },
+                            {
+                                'name' : 'Simplification, possibly to trig functions',
+                                'snippet' : [
+                                    'exptrigsimp(exp(z) + exp(-z))',
+                                ],
+                            },
+                        ],
+                    },
+                    {
+                        'name' : 'Trigonometric functions',
+                        'sub-menu' : [
+                            {
+                                'name' : 'Expansion',
+                                'snippet' : [
+                                    'expr = sin(x + y)',
+                                    'expr = expand(expr, trig=True)',
+                                ],
+                            },
+                            {
+                                'name' : 'Simplification',
+                                'snippet' : [
+                                    'expr = sin(x)**4 - 2*cos(x)**2*sin(x)**2 + cos(x)**4',
+                                    'expr = trigsimp(expr)',
+                                ],
+                            },
+                            {
+                                'name' : 'Simplification, possibly to exponentials',
+                                'snippet' : [
+                                    'expr = cosh(z) - sinh(z)',
+                                    'expr = exptrigsimp(expr)',
+                                ],
+                            },
+                        ],
+                    },
+                    {
+                        'name' : 'Miscellaneous',
+                        'sub-menu' : [
+                            {
+                                'name' : 'Simplify factorials',
+                                'snippet' : [
+                                    'expr = factorial(n)/factorial(n - 3)',
+                                    'expr = combsimp(expr)',
+                                ],
+                            },
+                            {
+                                'name' : 'Simplify binomials',
+                                'snippet' : [
+                                    'expr = binomial(n+1, k+1)/binomial(n, k)',
+                                    'expr = combsimp(expr)',
+                                ],
+                            },
+                            {
+                                'name' : 'Simplify numerical expressions to exact values',
+                                'snippet' : [
+                                    'nsimplify(4.0/(1+sqrt(5.0)), constants=[GoldenRatio,])',
+                                ],
+                            },
+                            {
+                                'name' : 'Expand gamma functions',
+                                'snippet' : [
+                                    'expr = gamma(z+3)',
+                                    'expr = expand_func(expr)',
+                                ],
+                            },
+                            {
+                                'name' : 'Simplify Bessel functions',
+                                'snippet' : [
+                                    'expr = besselj(x, z*polar_lift(-1))',
+                                    'expr = besselsimp(expr)',
+                                ],
+                            },
+                        ],
+                    },
+                ],
+            },
+        ],
+    };
+});

.local/share/jupyter/nbextensions/spellchecker/config.yaml

@@ -0,0 +1,27 @@
+Type: IPython Notebook Extension
+Compatibility: 4.x, 5.x
+Name: spellchecker
+Main: main.js
+Description: 'Adds a CodeMirror overlay mode for Typo.js spellchecking'
+Link: README.md
+Parameters:
+- name: spellchecker.enable_on_load
+  input_type: checkbox
+  description: enable spellchecker for all Markdown/Raw cells on notebook load
+  default: true
+- name: spellchecker.add_toolbar_button
+  input_type: checkbox
+  description: add a toolbar button to toggle spellchecker on and off for all Markdown/Raw cells
+  default: true
+- name: spellchecker.lang_code
+  intput_type: text
+  description: language code to use with typo.js
+  default: 'en_US'
+- name: spellchecker.dic_url
+  intput_type: url
+  description: url for the dictionary .dic file to use
+  default: 'https://cdn.jsdelivr.net/codemirror.spell-checker/latest/en_US.dic'
+- name: spellchecker.aff_url
+  intput_type: url
+  description: url for the dictionary .aff file to use
+  default: 'https://cdn.jsdelivr.net/codemirror.spell-checker/latest/en_US.aff'

.local/share/jupyter/nbextensions/spellchecker/main.css

@@ -0,0 +1,12 @@
+.CodeMirror .cm-spell-error:not(.cm-url):not(.cm-tag):not(.cm-word) {
+	 background: rgba(255, 0, 0, .15);
+}
+
+#spellchecker_btn > .fa:after {
+	content: 'abc';
+	position: absolute;
+ 	top: 2px;
+ 	left: 4px;
+	text-align: left;
+	font-size: 0.5em;
+}

.local/share/jupyter/nbextensions/spellchecker/typo/LICENSE.txt

@@ -0,0 +1,28 @@
+The typo.js file included as part of this nbextension is a requirejs-compatible
+adaptation of typo.js from
+	https://github.com/cfinke/Typo.js/
+essentially just wrapping it in a define call. The license for typo.js follows:
+
+Copyright (c) 2011, Christopher Finke
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+    * Redistributions of source code must retain the above copyright
+      notice, this list of conditions and the following disclaimer.
+    * Redistributions in binary form must reproduce the above copyright
+      notice, this list of conditions and the following disclaimer in the
+      documentation and/or other materials provided with the distribution.
+    * The name of the author may not be used to endorse or promote products
+      derived from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE AUTHOR FINKE BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

.local/share/jupyter/nbextensions/table_beautifier/main.js

@@ -0,0 +1,78 @@
+/**
+* ----------------------------------------------------------------------------
+* Copyright (c) 2016 - Jan Schulz
+*
+* Distributed under the terms of the Modified BSD License.
+*
+* Extension to style markdown and output tables in the notebook with bootstrap
+* ----------------------------------------------------------------------------
+*/
+
+define([
+  'require',
+  'jquery',
+  'base/js/events'
+ ], function (
+    requirejs,
+    $,
+    events
+) {
+  'use strict';
+
+  var sortable;
+  var bst = requirejs(
+    ['https://cdnjs.cloudflare.com/ajax/libs/jquery.tablesorter/2.25.7/js/jquery.tablesorter.min.js'],
+    function () {
+      sortable = true;
+      bootstrapify_all();
+    },
+    function (err) {
+      sortable = false;
+    }
+  );
+
+  function bootstrapify_tables($tables, wherefound) {
+    wherefound = wherefound ? ' in '+ wherefound : '';
+    $tables.addClass('table table-condensed table-nonfluid');
+    if (sortable) {
+      $tables.tablesorter();
+    }
+    if ($tables.length > 0) {
+      console.log('beautified', $tables.length, 'tables' + wherefound + '...');
+    }
+  }
+
+  function bootstrapify_all (){
+    bootstrapify_tables($('.rendered_html table'));
+  }
+
+  function bootstrapify_output (event, type, value, metadata, $toinsert){
+    bootstrapify_tables($toinsert.find('table'), 'output');
+  }
+
+  function bootstrapify_mdcell (event, mdcell){
+    bootstrapify_tables(mdcell.cell.element.find('table'), 'md');
+  }
+
+  function load_css (name) {
+    $('<link/>').attr({
+      type: 'text/css',
+      rel: 'stylesheet',
+      href: requirejs.toUrl(name)
+    }).appendTo('head');
+  }
+
+  var load_jupyter_extension = function () {
+    load_css('./main.css');
+    events.on("notebook_loaded.Notebook", bootstrapify_all);
+    events.on("kernel_ready.Kernel", bootstrapify_all);
+    events.on("output_appended.OutputArea", bootstrapify_output);
+    events.on("rendered.MarkdownCell", bootstrapify_mdcell);
+  };
+
+  return {
+    'load_jupyter_extension': load_jupyter_extension,
+    'load_ipython_extension': load_jupyter_extension
+  };
+
+});

.local/share/jupyter/nbextensions/toc2/toc2.yaml

@@ -0,0 +1,104 @@
+Type: Jupyter Notebook Extension
+Name: Table of Contents (2)
+Description: The toc2 extension enables to collect all running headers and display them in a floating window, as a sidebar or with a navigation menu. The extension is also draggable, resizable, collapsable, dockable and features automatic numerotation with unique links ids, and an optional toc cell.
+Link: README.md
+Icon: icon.png
+Main: main.js
+Compatibility: 4.x, 5.x
+Parameters:
+- name: toc2.number_sections
+  description: Automatically number notebook's sections
+  input_type: checkbox
+  default: true
+- name: toc2.threshold
+  description: Maximum level of nested sections to display on the tables of contents
+  input_type: number
+  min: -1
+  step: 1
+  default: 4
+
+- name: toc2.skip_h1_title
+  description: |
+    Skip h1 headings from numbering, so that they can serve as a notebook title.
+    See the README for details, caveats and alternatives
+  input_type: checkbox
+  default: false
+
+- name: toc2.toc_cell
+  description: Add a Table of Contents cell at the top of the notebook
+  input_type: checkbox
+  default: false
+
+- name: toc2.title_cell
+  description: Default heading used for ToC cell (can also be set per-notebook)
+  default: 'Table of Contents'
+
+- name: toc2.title_sidebar
+  description: Default title used for ToC sidebar/window (can also be set per-notebook)
+  default: 'Contents'
+
+- name: toc2.toc_window_display
+  description: Display toc window/sidebar at startup
+  input_type: checkbox
+  default: false
+- name: toc2.sideBar
+  description: Display Table of Contents as a sidebar (otherwise as a floating window)
+  input_type: checkbox
+  default: true
+- name: toc2.markTocItemOnScroll
+  description: Mark toc item of header in viewport when scrolling
+  input_type: checkbox
+  default: true
+- name: toc2.widenNotebook
+  description: Widen the display area to fit the browser window (may be useful with sidebar option)
+  input_type: checkbox
+  default: true
+- name: toc2.navigate_menu
+  description: Display Table of Contents as a navigation menu
+  input_type: checkbox
+  default: true
+- name: toc2.moveMenuLeft
+  description: Move notebook's title and menu on the left instead of being centered -- This provides a better look when the toc/sidebar is present
+  input_type: checkbox
+  default: true
+
+- name: toc2.collapse_to_match_collapsible_headings
+  input_type: checkbox
+  default: false
+  description: |
+    Collapse/uncollapse ToC sections when the collapsible_headings nbextension
+    is used to collapse/uncollapse sections in the notebook. For the inverse
+    behaviour, see collapsible_headings' configuration
+
+- name: toc2.colors.hover_highlight
+  input_type: color
+  description: Hover color in toc
+  default: "#DAA520"
+- name: toc2.colors.on_scroll
+  input_type: color
+  description: Color of highlight mark on scrolling
+  default: '#2447f0'
+- name: toc2.colors.selected_highlight
+  input_type: color
+  description: Color of sections with selected elements
+  default: "#FFD700"
+- name: toc2.colors.running_highlight
+  input_type: color
+  description: Color of sections with running cells
+  default: "#FF0000"
+- name: toc2.colors.wrapper_background
+  input_type: color
+  description: Color of wrapper window background
+  default: "#FFFFFF"
+- name: toc2.colors.sidebar_border
+  input_type: color
+  description: Color of sidebar border
+  default: "#EEEEEE"
+- name: toc2.colors.navigate_text
+  input_type: color
+  description: Color of navigate text
+  default: "#333333"
+- name: toc2.colors.navigate_num
+  input_type: color
+  description: Color of navigate number
+  default: "#000000"

.local/share/jupyter/nbextensions/varInspector/main.css

@@ -0,0 +1,119 @@
+
+.varInspector {
+  max-height: 500px;
+  min-height: 100px;
+  font-size: 80%;
+  padding: 0px;
+  overflow-y: auto;
+  font-weight: normal;
+  color: #333333;
+  white-space: nowrap;
+  overflow-x: auto;
+} 
+
+.varInspector-float-wrapper {
+  position: fixed !important;
+  top: 120px;
+  width:350px;
+  max-width:800px;
+  right: 20px;
+  border: thin solid rgba(0, 0, 0, 0.38);
+  border-radius: 5px;
+  padding:10px;
+  background-color: #fff;
+  opacity: .95;
+  z-index: 100;
+  overflow: hidden;
+}
+
+.hide-btn{
+  float: right;
+}
+
+.reload-btn{
+  float: right;
+}
+
+.kill-btn{
+  float: right;
+}
+
+.col-md-9 {
+  overflow:hidden;
+  margin-left: 14%;
+  width: 80%}
+
+#varInspector-wrapper.closed {
+  min-width: 250px;
+  width: auto;
+  transition: width;
+}
+#varInspector-wrapper:hover{
+  opacity: 1;
+}
+#varInspector-wrapper .header {
+  font-size: 16px;
+  font-weight: bold;
+}
+#varInspector-wrapper .hide-btn {
+  font-size: 14px;
+  font-family: monospace;
+}
+
+#varInspector-wrapper .reload-btn {
+  font-size: 14px;
+  font-family: monospace;
+}
+
+#varInspector-wrapper .kill-btn {
+  font-size: 14px;
+  font-family: monospace;
+}
+
+
+
+/* don't waste so much screen space... */
+#varInspector-wrapper .toc-item{
+  padding-left: 20px;
+}
+
+#varInspector-wrapper .toc-item .toc-item{
+  padding-left: 10px;
+}
+
+
+
+table.table, table.table tr, table.table td, table.table th {
+    border: 0;
+}
+table.table-nonfluid {
+    width: auto !important;
+}
+table.table {
+    margin-left: 0;
+    margin-right: 0;
+}
+/* stuff for tablesorter plugin */
+.tablesorter-default .header,
+.tablesorter-default .tablesorter-header {
+  background-image: url(data:image/gif;base64,R0lGODlhFQAJAIAAACMtMP///yH5BAEAAAEALAAAAAAVAAkAAAIXjI+AywnaYnhUMoqt3gZXPmVg94yJVQAAOw==);
+  background-position: right center;
+  background-repeat: no-repeat;
+  cursor: pointer;
+  padding-right: 20px;
+}
+.tablesorter-default thead .headerSortUp,
+.tablesorter-default thead .tablesorter-headerSortUp,
+.tablesorter-default thead .tablesorter-headerAsc {
+  background-image: url(data:image/gif;base64,R0lGODlhFQAEAIAAACMtMP///yH5BAEAAAEALAAAAAAVAAQAAAINjI8Bya2wnINUMopZAQA7);
+}
+.tablesorter-default thead .headerSortDown,
+.tablesorter-default thead .tablesorter-headerSortDown,
+.tablesorter-default thead .tablesorter-headerDesc {
+  background-image: url(data:image/gif;base64,R0lGODlhFQAEAIAAACMtMP///yH5BAEAAAEALAAAAAAVAAQAAAINjB+gC+jP2ptn0WskLQA7);
+}
+.tablesorter-default thead .sorter-false {
+  background-image: none;
+  cursor: default;
+  padding-right: 5px;
+}

.triton/dump/11759acf26ac56366b171628132485d6/triton_.llir

@@ -0,0 +1,347 @@
+; ModuleID = 'LLVMDialectModule'
+source_filename = "LLVMDialectModule"
+
+@global_smem = external addrspace(3) global [0 x i8]
+@.str = private unnamed_addr constant [11 x i8] c"__CUDA_FTZ\00", align 1
+
+define void @triton__0d1d2d3d4d5d6d7d8de9de(ptr addrspace(1) %0, ptr addrspace(1) %1, ptr addrspace(1) %2, ptr addrspace(1) %3, ptr addrspace(1) %4, ptr addrspace(1) %5, ptr addrspace(1) %6, ptr addrspace(1) %7, i32 %8, i32 %9) local_unnamed_addr !dbg !7 {
+  %11 = tail call i32 @llvm.nvvm.read.ptx.sreg.tid.x(), !dbg !10
+  %12 = and i32 %11, 31, !dbg !10
+  %13 = lshr i32 %11, 5, !dbg !10
+  %14 = and i32 %13, 1, !dbg !10
+  %urem = and i32 %11, 63, !dbg !10
+  %15 = shl nuw nsw i32 %urem, 2, !dbg !10
+  %16 = tail call i32 asm "mov.u32 $0, %ctaid.x;", "=r"() #6, !dbg !11
+  %17 = shl i32 %16, 8, !dbg !12
+  %18 = or i32 %17, %15, !dbg !13
+  %19 = sext i32 %18 to i64, !dbg !14
+  %20 = getelementptr float, ptr addrspace(1) %1, i64 %19, !dbg !14
+  %21 = tail call { i32, i32, i32, i32 } asm sideeffect "mov.u32 $0, 0x0;\0A\09mov.u32 $1, 0x0;\0A\09mov.u32 $2, 0x0;\0A\09mov.u32 $3, 0x0;\0A\09@$5 ld.global.v4.b32 { $0, $1, $2, $3 }, [ $4 + 0 ];\0A\09@!$7 mov.u32 $0, $6;\0A\09@!$9 mov.u32 $1, $8;\0A\09@!$11 mov.u32 $2, $10;\0A\09@!$13 mov.u32 $3, $12;", "=r,=r,=r,=r,l,b,r,b,r,b,r,b,r,b"(ptr addrspace(1) %20, i1 true, i32 0, i1 true, i32 0, i1 true, i32 0, i1 true, i32 0, i1 true) #6, !dbg !15
+  %22 = extractvalue { i32, i32, i32, i32 } %21, 0, !dbg !15
+  %23 = extractvalue { i32, i32, i32, i32 } %21, 1, !dbg !15
+  %24 = extractvalue { i32, i32, i32, i32 } %21, 2, !dbg !15
+  %25 = extractvalue { i32, i32, i32, i32 } %21, 3, !dbg !15
+  %26 = bitcast i32 %24 to float, !dbg !15
+  %27 = bitcast i32 %25 to float, !dbg !15
+  %28 = getelementptr i16, ptr addrspace(1) %2, i64 %19, !dbg !16
+  %29 = tail call { i32, i32 } asm sideeffect "mov.u32 $0, 0x0;\0A\09mov.u32 $1, 0x0;\0A\09@$3 ld.global.v2.b32 { $0, $1 }, [ $2 + 0 ];\0A\09@!$5 mov.u32 $0, $4;\0A\09@!$7 mov.u32 $1, $6;", "=r,=r,l,b,r,b,r,b"(ptr addrspace(1) %28, i1 true, i32 0, i1 true, i32 0, i1 true) #6, !dbg !17
+  %30 = extractvalue { i32, i32 } %29, 0, !dbg !17
+  %31 = extractvalue { i32, i32 } %29, 1, !dbg !17
+  %32 = trunc i32 %30 to i16, !dbg !17
+  %extelt.offset = lshr i32 %30, 16, !dbg !17
+  %33 = trunc i32 %extelt.offset to i16, !dbg !17
+  %34 = trunc i32 %31 to i16, !dbg !17
+  %extelt.offset1 = lshr i32 %31, 16, !dbg !17
+  %35 = trunc i32 %extelt.offset1 to i16, !dbg !17
+  %36 = tail call float asm "cvt.f32.bf16 $0, $1;", "=r,h"(i16 %32) #6, !dbg !18
+  %37 = tail call float asm "cvt.f32.bf16 $0, $1;", "=r,h"(i16 %33) #6, !dbg !18
+  %38 = tail call float asm "cvt.f32.bf16 $0, $1;", "=r,h"(i16 %34) #6, !dbg !18
+  %39 = tail call float asm "cvt.f32.bf16 $0, $1;", "=r,h"(i16 %35) #6, !dbg !18
+  %40 = getelementptr i16, ptr addrspace(1) %3, i64 %19, !dbg !19
+  %41 = tail call { i32, i32 } asm sideeffect "mov.u32 $0, 0x0;\0A\09mov.u32 $1, 0x0;\0A\09@$3 ld.global.v2.b32 { $0, $1 }, [ $2 + 0 ];\0A\09@!$5 mov.u32 $0, $4;\0A\09@!$7 mov.u32 $1, $6;", "=r,=r,l,b,r,b,r,b"(ptr addrspace(1) %40, i1 true, i32 0, i1 true, i32 0, i1 true) #6, !dbg !20
+  %42 = extractvalue { i32, i32 } %41, 0, !dbg !20
+  %43 = extractvalue { i32, i32 } %41, 1, !dbg !20
+  %44 = trunc i32 %42 to i16, !dbg !20
+  %extelt.offset2 = lshr i32 %42, 16, !dbg !20
+  %45 = trunc i32 %extelt.offset2 to i16, !dbg !20
+  %46 = trunc i32 %43 to i16, !dbg !20
+  %extelt.offset3 = lshr i32 %43, 16, !dbg !20
+  %47 = trunc i32 %extelt.offset3 to i16, !dbg !20
+  %48 = tail call float asm "cvt.f32.bf16 $0, $1;", "=r,h"(i16 %44) #6, !dbg !21
+  %49 = tail call float asm "cvt.f32.bf16 $0, $1;", "=r,h"(i16 %45) #6, !dbg !21
+  %50 = tail call float asm "cvt.f32.bf16 $0, $1;", "=r,h"(i16 %46) #6, !dbg !21
+  %51 = tail call float asm "cvt.f32.bf16 $0, $1;", "=r,h"(i16 %47) #6, !dbg !21
+  %52 = getelementptr i16, ptr addrspace(1) %4, i64 %19, !dbg !22
+  %53 = tail call { i32, i32 } asm sideeffect "mov.u32 $0, 0x0;\0A\09mov.u32 $1, 0x0;\0A\09@$3 ld.global.v2.b32 { $0, $1 }, [ $2 + 0 ];\0A\09@!$5 mov.u32 $0, $4;\0A\09@!$7 mov.u32 $1, $6;", "=r,=r,l,b,r,b,r,b"(ptr addrspace(1) %52, i1 true, i32 0, i1 true, i32 0, i1 true) #6, !dbg !23
+  %54 = extractvalue { i32, i32 } %53, 0, !dbg !23
+  %55 = extractvalue { i32, i32 } %53, 1, !dbg !23
+  %56 = trunc i32 %54 to i16, !dbg !23
+  %extelt.offset4 = lshr i32 %54, 16, !dbg !23
+  %57 = trunc i32 %extelt.offset4 to i16, !dbg !23
+  %58 = trunc i32 %55 to i16, !dbg !23
+  %extelt.offset5 = lshr i32 %55, 16, !dbg !23
+  %59 = trunc i32 %extelt.offset5 to i16, !dbg !23
+  %60 = tail call float asm "cvt.f32.bf16 $0, $1;", "=r,h"(i16 %56) #6, !dbg !24
+  %61 = tail call float asm "cvt.f32.bf16 $0, $1;", "=r,h"(i16 %57) #6, !dbg !24
+  %62 = tail call float asm "cvt.f32.bf16 $0, $1;", "=r,h"(i16 %58) #6, !dbg !24
+  %63 = tail call float asm "cvt.f32.bf16 $0, $1;", "=r,h"(i16 %59) #6, !dbg !24
+  %64 = zext nneg i32 %15 to i64, !dbg !25
+  %65 = getelementptr float, ptr addrspace(1) %5, i64 %64, !dbg !25
+  %66 = tail call { i32, i32, i32, i32 } asm sideeffect "mov.u32 $0, 0x0;\0A\09mov.u32 $1, 0x0;\0A\09mov.u32 $2, 0x0;\0A\09mov.u32 $3, 0x0;\0A\09@$5 ld.global.L1::evict_last.v4.b32 { $0, $1, $2, $3 }, [ $4 + 0 ];\0A\09@!$7 mov.u32 $0, $6;\0A\09@!$9 mov.u32 $1, $8;\0A\09@!$11 mov.u32 $2, $10;\0A\09@!$13 mov.u32 $3, $12;", "=r,=r,=r,=r,l,b,r,b,r,b,r,b,r,b"(ptr addrspace(1) %65, i1 true, i32 0, i1 true, i32 0, i1 true, i32 0, i1 true, i32 0, i1 true) #6, !dbg !26
+  %67 = fadd float %38, %26, !dbg !27
+  %68 = fadd float %39, %27, !dbg !27
+  %69 = fadd float %67, %50, !dbg !28
+  %70 = fadd float %68, %51, !dbg !28
+  %71 = insertelement <2 x i32> poison, i32 %22, i64 0, !dbg !15
+  %72 = insertelement <2 x i32> %71, i32 %23, i64 1, !dbg !15
+  %73 = bitcast <2 x i32> %72 to <2 x float>, !dbg !15
+  %74 = insertelement <2 x float> poison, float %36, i64 0, !dbg !27
+  %75 = insertelement <2 x float> %74, float %37, i64 1, !dbg !27
+  %76 = fadd <2 x float> %75, %73, !dbg !27
+  %77 = insertelement <2 x float> poison, float %48, i64 0, !dbg !28
+  %78 = insertelement <2 x float> %77, float %49, i64 1, !dbg !28
+  %79 = fadd <2 x float> %76, %78, !dbg !28
+  %80 = insertelement <2 x float> poison, float %60, i64 0, !dbg !29
+  %81 = insertelement <2 x float> %80, float %61, i64 1, !dbg !29
+  %82 = fadd <2 x float> %79, %81, !dbg !29
+  %83 = fadd float %69, %62, !dbg !29
+  %84 = fadd float %70, %63, !dbg !29
+  %85 = extractelement <2 x float> %82, i64 0, !dbg !30
+  %86 = extractelement <2 x float> %82, i64 1, !dbg !30
+  %87 = fadd float %85, %86, !dbg !30
+  %88 = fadd float %87, %83, !dbg !30
+  %89 = fadd float %88, %84, !dbg !30
+  %90 = bitcast float %89 to i32, !dbg !36
+  %91 = tail call i32 @llvm.nvvm.shfl.sync.bfly.i32(i32 -1, i32 %90, i32 16, i32 31), !dbg !36
+  %92 = bitcast i32 %91 to float, !dbg !36
+  %93 = fadd float %89, %92, !dbg !30
+  %94 = bitcast float %93 to i32, !dbg !36
+  %95 = tail call i32 @llvm.nvvm.shfl.sync.bfly.i32(i32 -1, i32 %94, i32 8, i32 31), !dbg !36
+  %96 = bitcast i32 %95 to float, !dbg !36
+  %97 = fadd float %93, %96, !dbg !30
+  %98 = bitcast float %97 to i32, !dbg !36
+  %99 = tail call i32 @llvm.nvvm.shfl.sync.bfly.i32(i32 -1, i32 %98, i32 4, i32 31), !dbg !36
+  %100 = bitcast i32 %99 to float, !dbg !36
+  %101 = fadd float %97, %100, !dbg !30
+  %102 = bitcast float %101 to i32, !dbg !36
+  %103 = tail call i32 @llvm.nvvm.shfl.sync.bfly.i32(i32 -1, i32 %102, i32 2, i32 31), !dbg !36
+  %104 = bitcast i32 %103 to float, !dbg !36
+  %105 = fadd float %101, %104, !dbg !30
+  %106 = bitcast float %105 to i32, !dbg !36
+  %107 = tail call i32 @llvm.nvvm.shfl.sync.bfly.i32(i32 -1, i32 %106, i32 1, i32 31), !dbg !36
+  %108 = bitcast i32 %107 to float, !dbg !36
+  %109 = fadd float %105, %108, !dbg !30
+  %110 = icmp eq i32 %12, 0, !dbg !36
+  %111 = zext nneg i32 %14 to i64, !dbg !36
+  %112 = getelementptr float, ptr addrspace(3) @global_smem, i64 %111, !dbg !36
+  tail call void asm sideeffect "@$2 st.shared.b32 [ $0 + 0 ], $1;", "r,r,b"(ptr addrspace(3) %112, float %109, i1 %110) #6, !dbg !36
+  tail call void @llvm.nvvm.barrier0(), !dbg !36
+  %113 = icmp slt i32 %11, 2, !dbg !36
+  %114 = sext i32 %11 to i64, !dbg !36
+  %115 = getelementptr float, ptr addrspace(3) @global_smem, i64 %114, !dbg !36
+  %116 = tail call float asm sideeffect "@$2 ld.shared.b32 $0, [ $1 + 0 ];", "=r,r,b"(ptr addrspace(3) %115, i1 %113) #6, !dbg !36
+  %117 = bitcast float %116 to i32, !dbg !36
+  %118 = tail call i32 @llvm.nvvm.shfl.sync.bfly.i32(i32 -1, i32 %117, i32 1, i32 31), !dbg !36
+  %119 = bitcast i32 %118 to float, !dbg !36
+  %120 = fadd float %116, %119, !dbg !30
+  %121 = and i32 %11, 1, !dbg !36
+  %122 = icmp eq i32 %121, 0, !dbg !36
+  %123 = and i1 %113, %122, !dbg !36
+  tail call void asm sideeffect "@$2 st.shared.b32 [ $0 + 0 ], $1;", "r,r,b"(ptr addrspace(3) %115, float %120, i1 %123) #6, !dbg !36
+  tail call void @llvm.nvvm.barrier0(), !dbg !36
+  %124 = load float, ptr addrspace(3) @global_smem, align 4, !dbg !36
+  %125 = fadd float %124, 0.000000e+00, !dbg !38
+  %126 = tail call float asm "div.full.f32 $0, $1, $2;", "=r,r,r"(float %125, float 2.560000e+02) #6, !dbg !42
+  %127 = fsub float %85, %126, !dbg !43
+  %128 = fsub float %86, %126, !dbg !43
+  %129 = fsub float %83, %126, !dbg !43
+  %130 = fsub float %84, %126, !dbg !43
+  %131 = fmul float %127, %127, !dbg !44
+  %132 = fmul float %128, %128, !dbg !44
+  %133 = fmul float %129, %129, !dbg !44
+  %134 = fmul float %130, %130, !dbg !44
+  tail call void @llvm.nvvm.barrier0(), !dbg !45
+  %135 = fadd float %131, %132, !dbg !47
+  %136 = fadd float %133, %135, !dbg !47
+  %137 = fadd float %134, %136, !dbg !47
+  %138 = bitcast float %137 to i32, !dbg !45
+  %139 = tail call i32 @llvm.nvvm.shfl.sync.bfly.i32(i32 -1, i32 %138, i32 16, i32 31), !dbg !45
+  %140 = bitcast i32 %139 to float, !dbg !45
+  %141 = fadd float %137, %140, !dbg !47
+  %142 = bitcast float %141 to i32, !dbg !45
+  %143 = tail call i32 @llvm.nvvm.shfl.sync.bfly.i32(i32 -1, i32 %142, i32 8, i32 31), !dbg !45
+  %144 = bitcast i32 %143 to float, !dbg !45
+  %145 = fadd float %141, %144, !dbg !47
+  %146 = bitcast float %145 to i32, !dbg !45
+  %147 = tail call i32 @llvm.nvvm.shfl.sync.bfly.i32(i32 -1, i32 %146, i32 4, i32 31), !dbg !45
+  %148 = bitcast i32 %147 to float, !dbg !45
+  %149 = fadd float %145, %148, !dbg !47
+  %150 = bitcast float %149 to i32, !dbg !45
+  %151 = tail call i32 @llvm.nvvm.shfl.sync.bfly.i32(i32 -1, i32 %150, i32 2, i32 31), !dbg !45
+  %152 = bitcast i32 %151 to float, !dbg !45
+  %153 = fadd float %149, %152, !dbg !47
+  %154 = bitcast float %153 to i32, !dbg !45
+  %155 = tail call i32 @llvm.nvvm.shfl.sync.bfly.i32(i32 -1, i32 %154, i32 1, i32 31), !dbg !45
+  %156 = bitcast i32 %155 to float, !dbg !45
+  %157 = fadd float %153, %156, !dbg !47
+  tail call void asm sideeffect "@$2 st.shared.b32 [ $0 + 0 ], $1;", "r,r,b"(ptr addrspace(3) %112, float %157, i1 %110) #6, !dbg !45
+  tail call void @llvm.nvvm.barrier0(), !dbg !45
+  %158 = tail call float asm sideeffect "@$2 ld.shared.b32 $0, [ $1 + 0 ];", "=r,r,b"(ptr addrspace(3) %115, i1 %113) #6, !dbg !45
+  %159 = bitcast float %158 to i32, !dbg !45
+  %160 = tail call i32 @llvm.nvvm.shfl.sync.bfly.i32(i32 -1, i32 %159, i32 1, i32 31), !dbg !45
+  %161 = bitcast i32 %160 to float, !dbg !45
+  %162 = fadd float %158, %161, !dbg !47
+  tail call void asm sideeffect "@$2 st.shared.b32 [ $0 + 0 ], $1;", "r,r,b"(ptr addrspace(3) %115, float %162, i1 %123) #6, !dbg !45
+  tail call void @llvm.nvvm.barrier0(), !dbg !45
+  %163 = load float, ptr addrspace(3) @global_smem, align 4, !dbg !45
+  %164 = fadd float %163, 0.000000e+00, !dbg !50
+  %165 = tail call float asm "div.full.f32 $0, $1, $2;", "=r,r,r"(float %164, float 2.560000e+02) #6, !dbg !52
+  %166 = fadd float %165, 0x3EE4F8B580000000, !dbg !53
+  %167 = tail call i32 @__nvvm_reflect(ptr nonnull @.str) #6, !dbg !54
+  %.not.i = icmp eq i32 %167, 0, !dbg !54
+  br i1 %.not.i, label %170, label %168, !dbg !54
+
+168:                                              ; preds = %10
+  %169 = tail call float @llvm.nvvm.rsqrt.approx.ftz.f(float %166), !dbg !54
+  br label %__nv_rsqrtf.exit, !dbg !54
+
+170:                                              ; preds = %10
+  %171 = tail call float @llvm.nvvm.rsqrt.approx.f(float %166), !dbg !54
+  br label %__nv_rsqrtf.exit, !dbg !54
+
+__nv_rsqrtf.exit:                                 ; preds = %168, %170
+  %.0.i = phi float [ %169, %168 ], [ %171, %170 ], !dbg !54
+  %172 = extractvalue { i32, i32, i32, i32 } %66, 3, !dbg !26
+  %173 = bitcast i32 %172 to float, !dbg !26
+  %174 = extractvalue { i32, i32, i32, i32 } %66, 2, !dbg !26
+  %175 = bitcast i32 %174 to float, !dbg !26
+  %176 = extractvalue { i32, i32, i32, i32 } %66, 1, !dbg !26
+  %177 = bitcast i32 %176 to float, !dbg !26
+  %178 = extractvalue { i32, i32, i32, i32 } %66, 0, !dbg !26
+  %179 = bitcast i32 %178 to float, !dbg !26
+  %180 = fmul float %127, %.0.i, !dbg !55
+  %181 = fmul float %128, %.0.i, !dbg !55
+  %182 = fmul float %129, %.0.i, !dbg !55
+  %183 = fmul float %130, %.0.i, !dbg !55
+  %184 = fmul float %180, %179, !dbg !56
+  %185 = fmul float %181, %177, !dbg !56
+  %186 = fmul float %182, %175, !dbg !56
+  %187 = fmul float %183, %173, !dbg !56
+  tail call void @llvm.nvvm.barrier0(), !dbg !57
+  %188 = sext i32 %16 to i64, !dbg !58
+  %189 = getelementptr float, ptr addrspace(1) %0, i64 %188, !dbg !58
+  %190 = icmp eq i32 %urem, 0, !dbg !59
+  %191 = bitcast float %.0.i to i32, !dbg !59
+  tail call void asm sideeffect "@$2 st.global.b32 [ $1 + 0 ], { $0 };", "r,l,b"(i32 %191, ptr addrspace(1) %189, i1 %190) #6, !dbg !59
+  %192 = getelementptr i16, ptr addrspace(1) %7, i64 %19, !dbg !60
+  %193 = tail call i16 asm "cvt.rn.bf16.f32 $0, $1;", "=h,r"(float %184) #6, !dbg !61
+  %194 = tail call i16 asm "cvt.rn.bf16.f32 $0, $1;", "=h,r"(float %185) #6, !dbg !61
+  %195 = tail call i16 asm "cvt.rn.bf16.f32 $0, $1;", "=h,r"(float %186) #6, !dbg !61
+  %196 = tail call i16 asm "cvt.rn.bf16.f32 $0, $1;", "=h,r"(float %187) #6, !dbg !61
+  %197 = insertelement <2 x i16> undef, i16 %193, i64 0, !dbg !61
+  %198 = insertelement <2 x i16> %197, i16 %194, i64 1, !dbg !61
+  %199 = bitcast <2 x i16> %198 to i32, !dbg !61
+  %200 = insertelement <2 x i16> undef, i16 %195, i64 0, !dbg !61
+  %201 = insertelement <2 x i16> %200, i16 %196, i64 1, !dbg !61
+  %202 = bitcast <2 x i16> %201 to i32, !dbg !61
+  tail call void asm sideeffect "@$3 st.global.v2.b32 [ $2 + 0 ], { $0, $1 };", "r,r,l,b"(i32 %199, i32 %202, ptr addrspace(1) %192, i1 true) #6, !dbg !61
+  %203 = getelementptr float, ptr addrspace(1) %6, i64 %188, !dbg !62
+  %204 = bitcast float %126 to i32, !dbg !63
+  tail call void asm sideeffect "@$2 st.global.b32 [ $1 + 0 ], { $0 };", "r,l,b"(i32 %204, ptr addrspace(1) %203, i1 %190) #6, !dbg !63
+  ret void, !dbg !64
+}
+
+; Function Attrs: mustprogress nocallback nofree nosync nounwind speculatable willreturn memory(none)
+declare noundef i32 @llvm.nvvm.read.ptx.sreg.tid.x() #0
+
+; Function Attrs: convergent nocallback nounwind memory(inaccessiblemem: readwrite)
+declare i32 @llvm.nvvm.shfl.sync.bfly.i32(i32, i32, i32, i32) #1
+
+; Function Attrs: convergent nocallback nounwind
+declare void @llvm.nvvm.barrier0() #2
+
+; Function Attrs: alwaysinline nounwind
+define float @__nv_rsqrtf(float %x) local_unnamed_addr #3 {
+  %1 = tail call i32 @__nvvm_reflect(ptr nonnull @.str) #6
+  %.not = icmp eq i32 %1, 0
+  br i1 %.not, label %4, label %2
+
+2:                                                ; preds = %0
+  %3 = tail call float @llvm.nvvm.rsqrt.approx.ftz.f(float %x)
+  br label %6
+
+4:                                                ; preds = %0
+  %5 = tail call float @llvm.nvvm.rsqrt.approx.f(float %x)
+  br label %6
+
+6:                                                ; preds = %4, %2
+  %.0 = phi float [ %3, %2 ], [ %5, %4 ]
+  ret float %.0
+}
+
+declare i32 @__nvvm_reflect(ptr) local_unnamed_addr #4
+
+; Function Attrs: mustprogress nocallback nofree nosync nounwind willreturn memory(none)
+declare float @llvm.nvvm.rsqrt.approx.ftz.f(float) #5
+
+; Function Attrs: mustprogress nocallback nofree nosync nounwind willreturn memory(none)
+declare float @llvm.nvvm.rsqrt.approx.f(float) #5
+
+attributes #0 = { mustprogress nocallback nofree nosync nounwind speculatable willreturn memory(none) }
+attributes #1 = { convergent nocallback nounwind memory(inaccessiblemem: readwrite) }
+attributes #2 = { convergent nocallback nounwind }
+attributes #3 = { alwaysinline nounwind "disable-tail-calls"="false" "frame-pointer"="all" "less-precise-fpmad"="false" "no-infs-fp-math"="false" "no-nans-fp-math"="false" "stack-protector-buffer-size"="8" "unsafe-fp-math"="false" "use-soft-float"="false" }
+attributes #4 = { "disable-tail-calls"="false" "frame-pointer"="all" "less-precise-fpmad"="false" "no-infs-fp-math"="false" "no-nans-fp-math"="false" "stack-protector-buffer-size"="8" "unsafe-fp-math"="false" "use-soft-float"="false" }
+attributes #5 = { mustprogress nocallback nofree nosync nounwind willreturn memory(none) }
+attributes #6 = { nounwind }
+
+!llvm.module.flags = !{!0, !1}
+!llvm.dbg.cu = !{!2}
+!nvvm.annotations = !{!4, !5, !5, !4}
+!llvm.ident = !{!6}
+
+!0 = !{i32 2, !"Debug Info Version", i32 3}
+!1 = !{i32 4, !"nvvm-reflect-ftz", i32 1}
+!2 = distinct !DICompileUnit(language: DW_LANG_C, file: !3, producer: "triton", isOptimized: true, runtimeVersion: 0, emissionKind: FullDebug)
+!3 = !DIFile(filename: "cdxa5yqgsimvskocpuiz4ajfrjfcwys3opyrdv53xfphj4576qx7.py", directory: "/tmp/torchinductor_root/dx")
+!4 = !{ptr @triton__0d1d2d3d4d5d6d7d8de9de, !"kernel", i32 1}
+!5 = !{ptr @triton__0d1d2d3d4d5d6d7d8de9de, !"maxntidx", i32 64}
+!6 = !{!"clang version 3.8.0 (tags/RELEASE_380/final)"}
+!7 = distinct !DISubprogram(name: "triton__0d1d2d3d4d5d6d7d8de9de", linkageName: "triton__0d1d2d3d4d5d6d7d8de9de", scope: !3, file: !3, line: 18, type: !8, scopeLine: 18, spFlags: DISPFlagDefinition | DISPFlagOptimized, unit: !2)
+!8 = !DISubroutineType(cc: DW_CC_normal, types: !9)
+!9 = !{}
+!10 = !DILocation(line: 26, column: 26, scope: !7)
+!11 = !DILocation(line: 23, column: 28, scope: !7)
+!12 = !DILocation(line: 30, column: 40, scope: !7)
+!13 = !DILocation(line: 30, column: 36, scope: !7)
+!14 = !DILocation(line: 30, column: 30, scope: !7)
+!15 = !DILocation(line: 30, column: 46, scope: !7)
+!16 = !DILocation(line: 31, column: 30, scope: !7)
+!17 = !DILocation(line: 31, column: 46, scope: !7)
+!18 = !DILocation(line: 31, column: 67, scope: !7)
+!19 = !DILocation(line: 32, column: 30, scope: !7)
+!20 = !DILocation(line: 32, column: 46, scope: !7)
+!21 = !DILocation(line: 32, column: 67, scope: !7)
+!22 = !DILocation(line: 33, column: 30, scope: !7)
+!23 = !DILocation(line: 33, column: 46, scope: !7)
+!24 = !DILocation(line: 33, column: 67, scope: !7)
+!25 = !DILocation(line: 34, column: 31, scope: !7)
+!26 = !DILocation(line: 34, column: 36, scope: !7)
+!27 = !DILocation(line: 36, column: 18, scope: !7)
+!28 = !DILocation(line: 38, column: 18, scope: !7)
+!29 = !DILocation(line: 40, column: 18, scope: !7)
+!30 = !DILocation(line: 233, column: 15, scope: !31, inlinedAt: !34)
+!31 = distinct !DILexicalBlockFile(scope: !33, file: !32, discriminator: 0)
+!32 = !DIFile(filename: "standard.py", directory: "/usr/local/lib/python3.10/dist-packages/triton/language")
+!33 = distinct !DILexicalBlockFile(scope: !7, file: !32, discriminator: 0)
+!34 = !DILocation(line: 243, column: 36, scope: !31, inlinedAt: !35)
+!35 = !DILocation(line: 45, column: 59, scope: !31)
+!36 = !DILocation(line: 243, column: 36, scope: !33, inlinedAt: !37)
+!37 = !DILocation(line: 45, column: 59, scope: !33)
+!38 = !DILocation(line: 8, column: 15, scope: !39, inlinedAt: !41)
+!39 = distinct !DILexicalBlockFile(scope: !7, file: !40, discriminator: 0)
+!40 = !DIFile(filename: "triton_helpers.py", directory: "/usr/local/lib/python3.10/dist-packages/torch/_inductor")
+!41 = !DILocation(line: 45, column: 45, scope: !39)
+!42 = !DILocation(line: 48, column: 20, scope: !7)
+!43 = !DILocation(line: 49, column: 20, scope: !7)
+!44 = !DILocation(line: 50, column: 20, scope: !7)
+!45 = !DILocation(line: 243, column: 36, scope: !33, inlinedAt: !46)
+!46 = !DILocation(line: 53, column: 59, scope: !33)
+!47 = !DILocation(line: 233, column: 15, scope: !31, inlinedAt: !48)
+!48 = !DILocation(line: 243, column: 36, scope: !31, inlinedAt: !49)
+!49 = !DILocation(line: 53, column: 59, scope: !31)
+!50 = !DILocation(line: 8, column: 15, scope: !39, inlinedAt: !51)
+!51 = !DILocation(line: 53, column: 45, scope: !39)
+!52 = !DILocation(line: 55, column: 20, scope: !7)
+!53 = !DILocation(line: 57, column: 20, scope: !7)
+!54 = !DILocation(line: 58, column: 26, scope: !7)
+!55 = !DILocation(line: 60, column: 20, scope: !7)
+!56 = !DILocation(line: 61, column: 20, scope: !7)
+!57 = !DILocation(line: 63, column: 4, scope: !7)
+!58 = !DILocation(line: 64, column: 28, scope: !7)
+!59 = !DILocation(line: 64, column: 40, scope: !7)
+!60 = !DILocation(line: 65, column: 25, scope: !7)
+!61 = !DILocation(line: 65, column: 48, scope: !7)
+!62 = !DILocation(line: 66, column: 25, scope: !7)
+!63 = !DILocation(line: 66, column: 37, scope: !7)
+!64 = !DILocation(line: 66, column: 4, scope: !7)

.triton/dump/11759acf26ac56366b171628132485d6/triton_.ttgir

@@ -0,0 +1,78 @@
+#blocked = #triton_gpu.blocked<{sizePerThread = [4], threadsPerWarp = [32], warpsPerCTA = [2], order = [0], CTAsPerCGA = [1], CTASplitNum = [1], CTAOrder = [0]}>
+#blocked1 = #triton_gpu.blocked<{sizePerThread = [1], threadsPerWarp = [32], warpsPerCTA = [2], order = [0], CTAsPerCGA = [1], CTASplitNum = [1], CTAOrder = [0]}>
+module attributes {"triton_gpu.compute-capability" = 89 : i32, "triton_gpu.num-ctas" = 1 : i32, "triton_gpu.num-warps" = 2 : i32, "triton_gpu.threads-per-warp" = 32 : i32} {
+  tt.func public @triton__0d1d2d3d4d5d6d7d8de9de(%arg0: !tt.ptr<f32, 1> {tt.divisibility = 16 : i32}, %arg1: !tt.ptr<f32, 1> {tt.divisibility = 16 : i32}, %arg2: !tt.ptr<bf16, 1> {tt.divisibility = 16 : i32}, %arg3: !tt.ptr<bf16, 1> {tt.divisibility = 16 : i32}, %arg4: !tt.ptr<bf16, 1> {tt.divisibility = 16 : i32}, %arg5: !tt.ptr<f32, 1> {tt.divisibility = 16 : i32}, %arg6: !tt.ptr<f32, 1> {tt.divisibility = 16 : i32}, %arg7: !tt.ptr<bf16, 1> {tt.divisibility = 16 : i32}, %arg8: i32 {tt.divisibility = 16 : i32, tt.max_divisibility = 16 : i32}, %arg9: i32 {tt.divisibility = 16 : i32, tt.max_divisibility = 16 : i32}) attributes {noinline = false} {
+    %cst = arith.constant dense<256> : tensor<256xi32, #blocked>
+    %cst_0 = arith.constant 9.99999974E-6 : f32
+    %cst_1 = arith.constant 2.560000e+02 : f32
+    %cst_2 = arith.constant 0.000000e+00 : f32
+    %c256_i32 = arith.constant 256 : i32
+    %cst_3 = arith.constant dense<0.000000e+00> : tensor<256xf32, #blocked>
+    %cst_4 = arith.constant dense<0.000000e+00> : tensor<256xbf16, #blocked>
+    %0 = tt.get_program_id x : i32
+    %1 = tt.make_range {end = 256 : i32, start = 0 : i32} : tensor<256xi32, #blocked>
+    %2 = arith.cmpi slt, %1, %cst : tensor<256xi32, #blocked>
+    %3 = arith.muli %0, %c256_i32 : i32
+    %4 = tt.splat %3 : (i32) -> tensor<256xi32, #blocked>
+    %5 = arith.addi %1, %4 : tensor<256xi32, #blocked>
+    %6 = tt.splat %arg1 : (!tt.ptr<f32, 1>) -> tensor<256x!tt.ptr<f32, 1>, #blocked>
+    %7 = tt.addptr %6, %5 : tensor<256x!tt.ptr<f32, 1>, #blocked>, tensor<256xi32, #blocked>
+    %8 = tt.load %7, %2, %cst_3 {cache = 1 : i32, evict = 1 : i32, isVolatile = false} : tensor<256xf32, #blocked>
+    %9 = tt.splat %arg2 : (!tt.ptr<bf16, 1>) -> tensor<256x!tt.ptr<bf16, 1>, #blocked>
+    %10 = tt.addptr %9, %5 : tensor<256x!tt.ptr<bf16, 1>, #blocked>, tensor<256xi32, #blocked>
+    %11 = tt.load %10, %2, %cst_4 {cache = 1 : i32, evict = 1 : i32, isVolatile = false} : tensor<256xbf16, #blocked>
+    %12 = arith.extf %11 : tensor<256xbf16, #blocked> to tensor<256xf32, #blocked>
+    %13 = tt.splat %arg3 : (!tt.ptr<bf16, 1>) -> tensor<256x!tt.ptr<bf16, 1>, #blocked>
+    %14 = tt.addptr %13, %5 : tensor<256x!tt.ptr<bf16, 1>, #blocked>, tensor<256xi32, #blocked>
+    %15 = tt.load %14, %2, %cst_4 {cache = 1 : i32, evict = 1 : i32, isVolatile = false} : tensor<256xbf16, #blocked>
+    %16 = arith.extf %15 : tensor<256xbf16, #blocked> to tensor<256xf32, #blocked>
+    %17 = tt.splat %arg4 : (!tt.ptr<bf16, 1>) -> tensor<256x!tt.ptr<bf16, 1>, #blocked>
+    %18 = tt.addptr %17, %5 : tensor<256x!tt.ptr<bf16, 1>, #blocked>, tensor<256xi32, #blocked>
+    %19 = tt.load %18, %2, %cst_4 {cache = 1 : i32, evict = 1 : i32, isVolatile = false} : tensor<256xbf16, #blocked>
+    %20 = arith.extf %19 : tensor<256xbf16, #blocked> to tensor<256xf32, #blocked>
+    %21 = tt.splat %arg5 : (!tt.ptr<f32, 1>) -> tensor<256x!tt.ptr<f32, 1>, #blocked>
+    %22 = tt.addptr %21, %1 : tensor<256x!tt.ptr<f32, 1>, #blocked>, tensor<256xi32, #blocked>
+    %23 = tt.load %22, %2, %cst_3 {cache = 1 : i32, evict = 3 : i32, isVolatile = false} : tensor<256xf32, #blocked>
+    %24 = arith.addf %8, %12 : tensor<256xf32, #blocked>
+    %25 = arith.addf %24, %16 : tensor<256xf32, #blocked>
+    %26 = arith.addf %25, %20 : tensor<256xf32, #blocked>
+    %27 = arith.select %2, %26, %cst_3 : tensor<256xi1, #blocked>, tensor<256xf32, #blocked>
+    %28 = "tt.reduce"(%27) <{axis = 0 : i32}> ({
+    ^bb0(%arg10: f32, %arg11: f32):
+      %52 = arith.addf %arg10, %arg11 : f32
+      tt.reduce.return %52 : f32
+    }) : (tensor<256xf32, #blocked>) -> f32
+    %29 = arith.addf %28, %cst_2 : f32
+    %30 = arith.divf %29, %cst_1 : f32
+    %31 = tt.splat %30 : (f32) -> tensor<1xf32, #blocked1>
+    %32 = tt.splat %30 : (f32) -> tensor<256xf32, #blocked>
+    %33 = arith.subf %26, %32 : tensor<256xf32, #blocked>
+    %34 = arith.mulf %33, %33 : tensor<256xf32, #blocked>
+    %35 = arith.select %2, %34, %cst_3 : tensor<256xi1, #blocked>, tensor<256xf32, #blocked>
+    %36 = "tt.reduce"(%35) <{axis = 0 : i32}> ({
+    ^bb0(%arg10: f32, %arg11: f32):
+      %52 = arith.addf %arg10, %arg11 : f32
+      tt.reduce.return %52 : f32
+    }) : (tensor<256xf32, #blocked>) -> f32
+    %37 = arith.addf %36, %cst_2 : f32
+    %38 = arith.divf %37, %cst_1 : f32
+    %39 = arith.addf %38, %cst_0 : f32
+    %40 = tt.extern_elementwise %39 {libname = "libdevice", libpath = "/usr/local/lib/python3.10/dist-packages/triton/language/../third_party/cuda/lib/libdevice.10.bc", pure = true, symbol = "__nv_rsqrtf"} : (f32) -> f32
+    %41 = tt.splat %40 : (f32) -> tensor<1xf32, #blocked1>
+    %42 = tt.splat %40 : (f32) -> tensor<256xf32, #blocked>
+    %43 = arith.mulf %33, %42 : tensor<256xf32, #blocked>
+    %44 = arith.mulf %43, %23 : tensor<256xf32, #blocked>
+    gpu.barrier
+    %45 = tt.addptr %arg0, %0 : !tt.ptr<f32, 1>, i32
+    %46 = tt.splat %45 : (!tt.ptr<f32, 1>) -> tensor<1x!tt.ptr<f32, 1>, #blocked1>
+    tt.store %46, %41 {cache = 1 : i32, evict = 1 : i32} : tensor<1xf32, #blocked1>
+    %47 = tt.splat %arg7 : (!tt.ptr<bf16, 1>) -> tensor<256x!tt.ptr<bf16, 1>, #blocked>
+    %48 = tt.addptr %47, %5 : tensor<256x!tt.ptr<bf16, 1>, #blocked>, tensor<256xi32, #blocked>
+    %49 = arith.truncf %44 : tensor<256xf32, #blocked> to tensor<256xbf16, #blocked>
+    tt.store %48, %49, %2 {cache = 1 : i32, evict = 1 : i32} : tensor<256xbf16, #blocked>
+    %50 = tt.addptr %arg6, %0 : !tt.ptr<f32, 1>, i32
+    %51 = tt.splat %50 : (!tt.ptr<f32, 1>) -> tensor<1x!tt.ptr<f32, 1>, #blocked1>
+    tt.store %51, %31 {cache = 1 : i32, evict = 1 : i32} : tensor<1xf32, #blocked1>
+    tt.return
+  }
+}

.triton/dump/11759acf26ac56366b171628132485d6/triton_.ttir

@@ -0,0 +1,76 @@
+module {
+  tt.func public @triton__0d1d2d3d4d5d6d7d8de9de(%arg0: !tt.ptr<f32, 1> {tt.divisibility = 16 : i32}, %arg1: !tt.ptr<f32, 1> {tt.divisibility = 16 : i32}, %arg2: !tt.ptr<bf16, 1> {tt.divisibility = 16 : i32}, %arg3: !tt.ptr<bf16, 1> {tt.divisibility = 16 : i32}, %arg4: !tt.ptr<bf16, 1> {tt.divisibility = 16 : i32}, %arg5: !tt.ptr<f32, 1> {tt.divisibility = 16 : i32}, %arg6: !tt.ptr<f32, 1> {tt.divisibility = 16 : i32}, %arg7: !tt.ptr<bf16, 1> {tt.divisibility = 16 : i32}, %arg8: i32 {tt.divisibility = 16 : i32, tt.max_divisibility = 16 : i32}, %arg9: i32 {tt.divisibility = 16 : i32, tt.max_divisibility = 16 : i32}) attributes {noinline = false} {
+    %c256_i32 = arith.constant 256 : i32
+    %cst = arith.constant dense<0.000000e+00> : tensor<256xbf16>
+    %cst_0 = arith.constant 0.000000e+00 : f32
+    %cst_1 = arith.constant 2.560000e+02 : f32
+    %cst_2 = arith.constant 9.99999974E-6 : f32
+    %cst_3 = arith.constant dense<0.000000e+00> : tensor<256xf32>
+    %cst_4 = arith.constant dense<256> : tensor<256xi32>
+    %0 = tt.get_program_id x : i32
+    %1 = tt.make_range {end = 256 : i32, start = 0 : i32} : tensor<256xi32>
+    %2 = arith.cmpi slt, %1, %cst_4 : tensor<256xi32>
+    %3 = arith.muli %0, %c256_i32 : i32
+    %4 = tt.splat %3 : (i32) -> tensor<256xi32>
+    %5 = arith.addi %1, %4 : tensor<256xi32>
+    %6 = tt.splat %arg1 : (!tt.ptr<f32, 1>) -> tensor<256x!tt.ptr<f32, 1>>
+    %7 = tt.addptr %6, %5 : tensor<256x!tt.ptr<f32, 1>>, tensor<256xi32>
+    %8 = tt.load %7, %2, %cst_3 {cache = 1 : i32, evict = 1 : i32, isVolatile = false} : tensor<256xf32>
+    %9 = tt.splat %arg2 : (!tt.ptr<bf16, 1>) -> tensor<256x!tt.ptr<bf16, 1>>
+    %10 = tt.addptr %9, %5 : tensor<256x!tt.ptr<bf16, 1>>, tensor<256xi32>
+    %11 = tt.load %10, %2, %cst {cache = 1 : i32, evict = 1 : i32, isVolatile = false} : tensor<256xbf16>
+    %12 = arith.extf %11 : tensor<256xbf16> to tensor<256xf32>
+    %13 = tt.splat %arg3 : (!tt.ptr<bf16, 1>) -> tensor<256x!tt.ptr<bf16, 1>>
+    %14 = tt.addptr %13, %5 : tensor<256x!tt.ptr<bf16, 1>>, tensor<256xi32>
+    %15 = tt.load %14, %2, %cst {cache = 1 : i32, evict = 1 : i32, isVolatile = false} : tensor<256xbf16>
+    %16 = arith.extf %15 : tensor<256xbf16> to tensor<256xf32>
+    %17 = tt.splat %arg4 : (!tt.ptr<bf16, 1>) -> tensor<256x!tt.ptr<bf16, 1>>
+    %18 = tt.addptr %17, %5 : tensor<256x!tt.ptr<bf16, 1>>, tensor<256xi32>
+    %19 = tt.load %18, %2, %cst {cache = 1 : i32, evict = 1 : i32, isVolatile = false} : tensor<256xbf16>
+    %20 = arith.extf %19 : tensor<256xbf16> to tensor<256xf32>
+    %21 = tt.splat %arg5 : (!tt.ptr<f32, 1>) -> tensor<256x!tt.ptr<f32, 1>>
+    %22 = tt.addptr %21, %1 : tensor<256x!tt.ptr<f32, 1>>, tensor<256xi32>
+    %23 = tt.load %22, %2, %cst_3 {cache = 1 : i32, evict = 3 : i32, isVolatile = false} : tensor<256xf32>
+    %24 = arith.addf %8, %12 : tensor<256xf32>
+    %25 = arith.addf %24, %16 : tensor<256xf32>
+    %26 = arith.addf %25, %20 : tensor<256xf32>
+    %27 = arith.select %2, %26, %cst_3 : tensor<256xi1>, tensor<256xf32>
+    %28 = "tt.reduce"(%27) <{axis = 0 : i32}> ({
+    ^bb0(%arg10: f32, %arg11: f32):
+      %52 = arith.addf %arg10, %arg11 : f32
+      tt.reduce.return %52 : f32
+    }) : (tensor<256xf32>) -> f32
+    %29 = arith.addf %28, %cst_0 : f32
+    %30 = arith.divf %29, %cst_1 : f32
+    %31 = tt.splat %30 : (f32) -> tensor<1xf32>
+    %32 = tt.splat %30 : (f32) -> tensor<256xf32>
+    %33 = arith.subf %26, %32 : tensor<256xf32>
+    %34 = arith.mulf %33, %33 : tensor<256xf32>
+    %35 = arith.select %2, %34, %cst_3 : tensor<256xi1>, tensor<256xf32>
+    %36 = "tt.reduce"(%35) <{axis = 0 : i32}> ({
+    ^bb0(%arg10: f32, %arg11: f32):
+      %52 = arith.addf %arg10, %arg11 : f32
+      tt.reduce.return %52 : f32
+    }) : (tensor<256xf32>) -> f32
+    %37 = arith.addf %36, %cst_0 : f32
+    %38 = arith.divf %37, %cst_1 : f32
+    %39 = arith.addf %38, %cst_2 : f32
+    %40 = tt.extern_elementwise %39 {libname = "libdevice", libpath = "/usr/local/lib/python3.10/dist-packages/triton/language/../third_party/cuda/lib/libdevice.10.bc", pure = true, symbol = "__nv_rsqrtf"} : (f32) -> f32
+    %41 = tt.splat %40 : (f32) -> tensor<1xf32>
+    %42 = tt.splat %40 : (f32) -> tensor<256xf32>
+    %43 = arith.mulf %33, %42 : tensor<256xf32>
+    %44 = arith.mulf %43, %23 : tensor<256xf32>
+    gpu.barrier
+    %45 = tt.addptr %arg0, %0 : !tt.ptr<f32, 1>, i32
+    %46 = tt.splat %45 : (!tt.ptr<f32, 1>) -> tensor<1x!tt.ptr<f32, 1>>
+    tt.store %46, %41 {cache = 1 : i32, evict = 1 : i32} : tensor<1xf32>
+    %47 = tt.splat %arg7 : (!tt.ptr<bf16, 1>) -> tensor<256x!tt.ptr<bf16, 1>>
+    %48 = tt.addptr %47, %5 : tensor<256x!tt.ptr<bf16, 1>>, tensor<256xi32>
+    %49 = arith.truncf %44 : tensor<256xf32> to tensor<256xbf16>
+    tt.store %48, %49, %2 {cache = 1 : i32, evict = 1 : i32} : tensor<256xbf16>
+    %50 = tt.addptr %arg6, %0 : !tt.ptr<f32, 1>, i32
+    %51 = tt.splat %50 : (!tt.ptr<f32, 1>) -> tensor<1x!tt.ptr<f32, 1>>
+    tt.store %51, %31 {cache = 1 : i32, evict = 1 : i32} : tensor<1xf32>
+    tt.return
+  }
+}

.triton/dump/415aac87553b7d064f52694fa7254686/triton_.ttgir

@@ -0,0 +1,28 @@
+#blocked = #triton_gpu.blocked<{sizePerThread = [8], threadsPerWarp = [32], warpsPerCTA = [4], order = [0], CTAsPerCGA = [1], CTASplitNum = [1], CTAOrder = [0]}>
+module attributes {"triton_gpu.compute-capability" = 89 : i32, "triton_gpu.num-ctas" = 1 : i32, "triton_gpu.num-warps" = 4 : i32, "triton_gpu.threads-per-warp" = 32 : i32} {
+  tt.func public @triton__0d1d2de(%arg0: !tt.ptr<bf16, 1> {tt.divisibility = 16 : i32}, %arg1: !tt.ptr<bf16, 1> {tt.divisibility = 16 : i32}, %arg2: i32 {tt.divisibility = 16 : i32, tt.max_divisibility = 16 : i32}) attributes {noinline = false} {
+    %cst = arith.constant dense<1.000000e+00> : tensor<1024xf32, #blocked>
+    %cst_0 = arith.constant dense<0.707106769> : tensor<1024xf32, #blocked>
+    %cst_1 = arith.constant dense<5.000000e-01> : tensor<1024xf32, #blocked>
+    %c1024_i32 = arith.constant 1024 : i32
+    %0 = tt.get_program_id x : i32
+    %1 = arith.muli %0, %c1024_i32 : i32
+    %2 = tt.make_range {end = 1024 : i32, start = 0 : i32} : tensor<1024xi32, #blocked>
+    %3 = tt.splat %1 : (i32) -> tensor<1024xi32, #blocked>
+    %4 = arith.addi %3, %2 : tensor<1024xi32, #blocked>
+    %5 = tt.splat %arg0 : (!tt.ptr<bf16, 1>) -> tensor<1024x!tt.ptr<bf16, 1>, #blocked>
+    %6 = tt.addptr %5, %4 : tensor<1024x!tt.ptr<bf16, 1>, #blocked>, tensor<1024xi32, #blocked>
+    %7 = tt.load %6 {cache = 1 : i32, evict = 1 : i32, isVolatile = false} : tensor<1024xbf16, #blocked>
+    %8 = arith.extf %7 : tensor<1024xbf16, #blocked> to tensor<1024xf32, #blocked>
+    %9 = arith.mulf %8, %cst_1 : tensor<1024xf32, #blocked>
+    %10 = arith.mulf %8, %cst_0 : tensor<1024xf32, #blocked>
+    %11 = tt.extern_elementwise %10 {libname = "libdevice", libpath = "/usr/local/lib/python3.10/dist-packages/triton/language/../third_party/cuda/lib/libdevice.10.bc", pure = true, symbol = "__nv_erff"} : (tensor<1024xf32, #blocked>) -> tensor<1024xf32, #blocked>
+    %12 = arith.addf %11, %cst : tensor<1024xf32, #blocked>
+    %13 = arith.mulf %9, %12 : tensor<1024xf32, #blocked>
+    %14 = tt.splat %arg1 : (!tt.ptr<bf16, 1>) -> tensor<1024x!tt.ptr<bf16, 1>, #blocked>
+    %15 = tt.addptr %14, %4 : tensor<1024x!tt.ptr<bf16, 1>, #blocked>, tensor<1024xi32, #blocked>
+    %16 = arith.truncf %13 : tensor<1024xf32, #blocked> to tensor<1024xbf16, #blocked>
+    tt.store %15, %16 {cache = 1 : i32, evict = 1 : i32} : tensor<1024xbf16, #blocked>
+    tt.return
+  }
+}

.triton/dump/4c6ad48573c74d55ed79384f6b432d50/triton_.llir

@@ -0,0 +1,85 @@
+; ModuleID = 'LLVMDialectModule'
+source_filename = "LLVMDialectModule"
+
+define void @triton__0d1d2de(ptr addrspace(1) %0, ptr addrspace(1) %1, i32 %2) local_unnamed_addr !dbg !5 {
+  %4 = tail call i32 @llvm.nvvm.read.ptx.sreg.tid.x(), !dbg !8
+  %5 = shl i32 %4, 3, !dbg !8
+  %6 = and i32 %5, 1016, !dbg !8
+  %7 = tail call i32 asm "mov.u32 $0, %ctaid.x;", "=r"() #1, !dbg !9
+  %8 = shl i32 %7, 10, !dbg !10
+  %9 = or i32 %8, %6, !dbg !11
+  %10 = or i32 %9, 4, !dbg !11
+  %11 = sext i32 %9 to i64, !dbg !12
+  %12 = getelementptr float, ptr addrspace(1) %0, i64 %11, !dbg !12
+  %13 = sext i32 %10 to i64, !dbg !12
+  %14 = getelementptr float, ptr addrspace(1) %0, i64 %13, !dbg !12
+  %15 = tail call { i32, i32, i32, i32 } asm sideeffect "mov.u32 $0, 0x0;\0A\09mov.u32 $1, 0x0;\0A\09mov.u32 $2, 0x0;\0A\09mov.u32 $3, 0x0;\0A\09@$5 ld.global.v4.b32 { $0, $1, $2, $3 }, [ $4 + 0 ];", "=r,=r,=r,=r,l,b"(ptr addrspace(1) %12, i1 true) #1, !dbg !13
+  %16 = extractvalue { i32, i32, i32, i32 } %15, 0, !dbg !13
+  %17 = extractvalue { i32, i32, i32, i32 } %15, 1, !dbg !13
+  %18 = extractvalue { i32, i32, i32, i32 } %15, 2, !dbg !13
+  %19 = extractvalue { i32, i32, i32, i32 } %15, 3, !dbg !13
+  %20 = bitcast i32 %16 to float, !dbg !13
+  %21 = bitcast i32 %17 to float, !dbg !13
+  %22 = bitcast i32 %18 to float, !dbg !13
+  %23 = bitcast i32 %19 to float, !dbg !13
+  %24 = tail call { i32, i32, i32, i32 } asm sideeffect "mov.u32 $0, 0x0;\0A\09mov.u32 $1, 0x0;\0A\09mov.u32 $2, 0x0;\0A\09mov.u32 $3, 0x0;\0A\09@$5 ld.global.v4.b32 { $0, $1, $2, $3 }, [ $4 + 0 ];", "=r,=r,=r,=r,l,b"(ptr addrspace(1) %14, i1 true) #1, !dbg !13
+  %25 = extractvalue { i32, i32, i32, i32 } %24, 0, !dbg !13
+  %26 = extractvalue { i32, i32, i32, i32 } %24, 1, !dbg !13
+  %27 = extractvalue { i32, i32, i32, i32 } %24, 2, !dbg !13
+  %28 = extractvalue { i32, i32, i32, i32 } %24, 3, !dbg !13
+  %29 = bitcast i32 %25 to float, !dbg !13
+  %30 = bitcast i32 %26 to float, !dbg !13
+  %31 = bitcast i32 %27 to float, !dbg !13
+  %32 = bitcast i32 %28 to float, !dbg !13
+  %33 = getelementptr i16, ptr addrspace(1) %1, i64 %11, !dbg !14
+  %34 = tail call i16 asm "cvt.rn.bf16.f32 $0, $1;", "=h,r"(float %20) #1, !dbg !15
+  %35 = tail call i16 asm "cvt.rn.bf16.f32 $0, $1;", "=h,r"(float %21) #1, !dbg !15
+  %36 = tail call i16 asm "cvt.rn.bf16.f32 $0, $1;", "=h,r"(float %22) #1, !dbg !15
+  %37 = tail call i16 asm "cvt.rn.bf16.f32 $0, $1;", "=h,r"(float %23) #1, !dbg !15
+  %38 = tail call i16 asm "cvt.rn.bf16.f32 $0, $1;", "=h,r"(float %29) #1, !dbg !15
+  %39 = tail call i16 asm "cvt.rn.bf16.f32 $0, $1;", "=h,r"(float %30) #1, !dbg !15
+  %40 = tail call i16 asm "cvt.rn.bf16.f32 $0, $1;", "=h,r"(float %31) #1, !dbg !15
+  %41 = tail call i16 asm "cvt.rn.bf16.f32 $0, $1;", "=h,r"(float %32) #1, !dbg !15
+  %42 = insertelement <2 x i16> undef, i16 %34, i64 0, !dbg !15
+  %43 = insertelement <2 x i16> %42, i16 %35, i64 1, !dbg !15
+  %44 = bitcast <2 x i16> %43 to i32, !dbg !15
+  %45 = insertelement <2 x i16> undef, i16 %36, i64 0, !dbg !15
+  %46 = insertelement <2 x i16> %45, i16 %37, i64 1, !dbg !15
+  %47 = bitcast <2 x i16> %46 to i32, !dbg !15
+  %48 = insertelement <2 x i16> undef, i16 %38, i64 0, !dbg !15
+  %49 = insertelement <2 x i16> %48, i16 %39, i64 1, !dbg !15
+  %50 = bitcast <2 x i16> %49 to i32, !dbg !15
+  %51 = insertelement <2 x i16> undef, i16 %40, i64 0, !dbg !15
+  %52 = insertelement <2 x i16> %51, i16 %41, i64 1, !dbg !15
+  %53 = bitcast <2 x i16> %52 to i32, !dbg !15
+  tail call void asm sideeffect "@$5 st.global.v4.b32 [ $4 + 0 ], { $0, $1, $2, $3 };", "r,r,r,r,l,b"(i32 %44, i32 %47, i32 %50, i32 %53, ptr addrspace(1) %33, i1 true) #1, !dbg !15
+  ret void, !dbg !16
+}
+
+; Function Attrs: mustprogress nocallback nofree nosync nounwind speculatable willreturn memory(none)
+declare noundef i32 @llvm.nvvm.read.ptx.sreg.tid.x() #0
+
+attributes #0 = { mustprogress nocallback nofree nosync nounwind speculatable willreturn memory(none) }
+attributes #1 = { nounwind }
+
+!llvm.module.flags = !{!0}
+!llvm.dbg.cu = !{!1}
+!nvvm.annotations = !{!3, !4, !4, !3}
+
+!0 = !{i32 2, !"Debug Info Version", i32 3}
+!1 = distinct !DICompileUnit(language: DW_LANG_C, file: !2, producer: "triton", isOptimized: true, runtimeVersion: 0, emissionKind: FullDebug)
+!2 = !DIFile(filename: "czjxjqxojsyyr4zmce6q6twysnucw6p4l5ujgp6ts2ecrm3ue3ex.py", directory: "/tmp/torchinductor_root/zj")
+!3 = !{ptr @triton__0d1d2de, !"kernel", i32 1}
+!4 = !{ptr @triton__0d1d2de, !"maxntidx", i32 128}
+!5 = distinct !DISubprogram(name: "triton__0d1d2de", linkageName: "triton__0d1d2de", scope: !2, file: !2, line: 18, type: !6, scopeLine: 18, spFlags: DISPFlagDefinition | DISPFlagOptimized, unit: !1)
+!6 = !DISubroutineType(cc: DW_CC_normal, types: !7)
+!7 = !{}
+!8 = !DILocation(line: 21, column: 36, scope: !5)
+!9 = !DILocation(line: 20, column: 28, scope: !5)
+!10 = !DILocation(line: 20, column: 33, scope: !5)
+!11 = !DILocation(line: 21, column: 23, scope: !5)
+!12 = !DILocation(line: 24, column: 30, scope: !5)
+!13 = !DILocation(line: 24, column: 35, scope: !5)
+!14 = !DILocation(line: 26, column: 25, scope: !5)
+!15 = !DILocation(line: 26, column: 36, scope: !5)
+!16 = !DILocation(line: 26, column: 4, scope: !5)

.triton/dump/4c6ad48573c74d55ed79384f6b432d50/triton_.ptx

@@ -0,0 +1,312 @@
+//
+// Generated by LLVM NVPTX Back-End
+//
+
+.version 8.2
+.target sm_89
+.address_size 64
+
+	// .globl	triton__0d1d2de
+
+.visible .entry triton__0d1d2de(
+	.param .u64 triton__0d1d2de_param_0,
+	.param .u64 triton__0d1d2de_param_1,
+	.param .u32 triton__0d1d2de_param_2
+)
+.maxntid 128, 1, 1
+{
+	.reg .pred 	%p<4>;
+	.reg .b16 	%rs<9>;
+	.reg .b32 	%r<31>;
+	.reg .b64 	%rd<8>;
+	.loc	1 18 0
+$L__func_begin0:
+	.loc	1 18 0
+
+	ld.param.u64 	%rd4, [triton__0d1d2de_param_0];
+	ld.param.u64 	%rd5, [triton__0d1d2de_param_1];
+$L__tmp0:
+	.loc	1 21 36
+	mov.u32 	%r22, %tid.x;
+	shl.b32 	%r23, %r22, 3;
+	and.b32  	%r24, %r23, 1016;
+	.loc	1 20 28
+	mov.u32 %r1, %ctaid.x;
+	.loc	1 20 33
+	shl.b32 	%r25, %r1, 10;
+	.loc	1 21 23
+	or.b32  	%r26, %r25, %r24;
+	.loc	1 24 30
+	mul.wide.s32 	%rd6, %r26, 4;
+	add.s64 	%rd1, %rd4, %rd6;
+	add.s64 	%rd2, %rd1, 16;
+	mov.pred 	%p1, -1;
+	.loc	1 24 35
+	mov.u32 %r10, 0x0;
+	mov.u32 %r11, 0x0;
+	mov.u32 %r12, 0x0;
+	mov.u32 %r13, 0x0;
+	@%p1 ld.global.v4.b32 { %r10, %r11, %r12, %r13 }, [ %rd1 + 0 ];
+	mov.u32 %r14, 0x0;
+	mov.u32 %r15, 0x0;
+	mov.u32 %r16, 0x0;
+	mov.u32 %r17, 0x0;
+	@%p1 ld.global.v4.b32 { %r14, %r15, %r16, %r17 }, [ %rd2 + 0 ];
+	.loc	1 26 25
+	mul.wide.s32 	%rd7, %r26, 2;
+	add.s64 	%rd3, %rd5, %rd7;
+	.loc	1 26 36
+	cvt.rn.bf16.f32 %rs1, %r10;
+	cvt.rn.bf16.f32 %rs2, %r11;
+	cvt.rn.bf16.f32 %rs3, %r12;
+	cvt.rn.bf16.f32 %rs4, %r13;
+	cvt.rn.bf16.f32 %rs5, %r14;
+	cvt.rn.bf16.f32 %rs6, %r15;
+	cvt.rn.bf16.f32 %rs7, %r16;
+	cvt.rn.bf16.f32 %rs8, %r17;
+	mov.b32 	%r27, {%rs1, %rs2};
+	mov.b32 	%r28, {%rs3, %rs4};
+	mov.b32 	%r29, {%rs5, %rs6};
+	mov.b32 	%r30, {%rs7, %rs8};
+	@%p1 st.global.v4.b32 [ %rd3 + 0 ], { %r27, %r28, %r29, %r30 };
+	.loc	1 26 4
+	ret;
+$L__tmp1:
+$L__func_end0:
+
+}
+	.file	1 "/tmp/torchinductor_root/zj/czjxjqxojsyyr4zmce6q6twysnucw6p4l5ujgp6ts2ecrm3ue3ex.py"
+	.section	.debug_abbrev
+	{
+.b8 1
+.b8 17
+.b8 1
+.b8 37
+.b8 8
+.b8 19
+.b8 5
+.b8 3
+.b8 8
+.b8 16
+.b8 6
+.b8 27
+.b8 8
+.b8 180
+.b8 66
+.b8 12
+.b8 17
+.b8 1
+.b8 18
+.b8 1
+.b8 0
+.b8 0
+.b8 2
+.b8 46
+.b8 0
+.b8 17
+.b8 1
+.b8 18
+.b8 1
+.b8 64
+.b8 10
+.b8 135
+.b8 64
+.b8 8
+.b8 3
+.b8 8
+.b8 58
+.b8 11
+.b8 59
+.b8 11
+.b8 63
+.b8 12
+.b8 0
+.b8 0
+.b8 0
+	}
+	.section	.debug_info
+	{
+.b32 176
+.b8 2
+.b8 0
+.b32 .debug_abbrev
+.b8 8
+.b8 1
+.b8 116
+.b8 114
+.b8 105
+.b8 116
+.b8 111
+.b8 110
+.b8 0
+.b8 2
+.b8 0
+.b8 99
+.b8 122
+.b8 106
+.b8 120
+.b8 106
+.b8 113
+.b8 120
+.b8 111
+.b8 106
+.b8 115
+.b8 121
+.b8 121
+.b8 114
+.b8 52
+.b8 122
+.b8 109
+.b8 99
+.b8 101
+.b8 54
+.b8 113
+.b8 54
+.b8 116
+.b8 119
+.b8 121
+.b8 115
+.b8 110
+.b8 117
+.b8 99
+.b8 119
+.b8 54
+.b8 112
+.b8 52
+.b8 108
+.b8 53
+.b8 117
+.b8 106
+.b8 103
+.b8 112
+.b8 54
+.b8 116
+.b8 115
+.b8 50
+.b8 101
+.b8 99
+.b8 114
+.b8 109
+.b8 51
+.b8 117
+.b8 101
+.b8 51
+.b8 101
+.b8 120
+.b8 46
+.b8 112
+.b8 121
+.b8 0
+.b32 .debug_line
+.b8 47
+.b8 116
+.b8 109
+.b8 112
+.b8 47
+.b8 116
+.b8 111
+.b8 114
+.b8 99
+.b8 104
+.b8 105
+.b8 110
+.b8 100
+.b8 117
+.b8 99
+.b8 116
+.b8 111
+.b8 114
+.b8 95
+.b8 114
+.b8 111
+.b8 111
+.b8 116
+.b8 47
+.b8 122
+.b8 106
+.b8 0
+.b8 1
+.b64 $L__func_begin0
+.b64 $L__func_end0
+.b8 2
+.b64 $L__func_begin0
+.b64 $L__func_end0
+.b8 1
+.b8 156
+.b8 116
+.b8 114
+.b8 105
+.b8 116
+.b8 111
+.b8 110
+.b8 95
+.b8 95
+.b8 48
+.b8 100
+.b8 49
+.b8 100
+.b8 50
+.b8 100
+.b8 101
+.b8 0
+.b8 116
+.b8 114
+.b8 105
+.b8 116
+.b8 111
+.b8 110
+.b8 95
+.b8 95
+.b8 48
+.b8 100
+.b8 49
+.b8 100
+.b8 50
+.b8 100
+.b8 101
+.b8 0
+.b8 1
+.b8 18
+.b8 1
+.b8 0
+	}
+	.section	.debug_pubnames
+	{
+.b32 $L__pubNames_end0-$L__pubNames_start0
+$L__pubNames_start0:
+.b8 2
+.b8 0
+.b32 .debug_info
+.b32 180
+.b32 125
+.b8 116
+.b8 114
+.b8 105
+.b8 116
+.b8 111
+.b8 110
+.b8 95
+.b8 95
+.b8 48
+.b8 100
+.b8 49
+.b8 100
+.b8 50
+.b8 100
+.b8 101
+.b8 0
+.b32 0
+$L__pubNames_end0:
+	}
+	.section	.debug_pubtypes
+	{
+.b32 $L__pubTypes_end0-$L__pubTypes_start0
+$L__pubTypes_start0:
+.b8 2
+.b8 0
+.b32 .debug_info
+.b32 180
+.b32 0
+$L__pubTypes_end0:
+	}
+	.section	.debug_loc	{	}

.triton/dump/645565eaba0a18dd23ef200fe9abb0c0/triton_.llir

@@ -0,0 +1,349 @@
+; ModuleID = 'LLVMDialectModule'
+source_filename = "LLVMDialectModule"
+
+@assertFunc_0 = internal constant [25 x i8] c"_call_with_frames_removed"
+@assertFile_0 = internal constant [38 x i8] c"<frozen importlib._bootstrap_external>"
+@assertMessage_0 = internal constant [38 x i8] c"index out of bounds: 0 <= tmp3 < 50257"
+@global_smem = external addrspace(3) global [0 x i8]
+@.str = private unnamed_addr constant [11 x i8] c"__CUDA_FTZ\00", align 1
+
+declare void @__assertfail(ptr, ptr, i32, ptr, i64) local_unnamed_addr
+
+define void @triton__0d1d2d3d4d5d6d7d8de9de(ptr addrspace(1) %0, ptr addrspace(1) %1, ptr addrspace(1) %2, ptr addrspace(1) %3, ptr addrspace(1) %4, ptr addrspace(1) %5, ptr addrspace(1) %6, ptr addrspace(1) %7, i32 %8, i32 %9) local_unnamed_addr !dbg !7 {
+  %11 = tail call i32 @llvm.nvvm.read.ptx.sreg.tid.x(), !dbg !10
+  %urem = and i32 %11, 63, !dbg !10
+  %12 = shl nuw nsw i32 %urem, 2, !dbg !10
+  %13 = tail call i32 asm "mov.u32 $0, %ctaid.x;", "=r"() #6, !dbg !11
+  %14 = srem i32 %13, 512, !dbg !12
+  %15 = sext i32 %13 to i64, !dbg !13
+  %16 = getelementptr i64, ptr addrspace(1) %1, i64 %15, !dbg !13
+  %17 = tail call i64 asm sideeffect "mov.u64 $0, 0x0;\0A\09@$2 ld.global.L1::evict_last.b64 { $0 }, [ $1 + 0 ];", "=l,l,b"(ptr addrspace(1) %16, i1 true) #6, !dbg !14
+  %18 = tail call i64 asm sideeffect "mov.u64 $0, 0x0;\0A\09@$2 ld.global.L1::evict_last.b64 { $0 }, [ $1 + 0 ];", "=l,l,b"(ptr addrspace(1) %16, i1 true) #6, !dbg !14
+  %19 = tail call i64 asm sideeffect "mov.u64 $0, 0x0;\0A\09@$2 ld.global.L1::evict_last.b64 { $0 }, [ $1 + 0 ];", "=l,l,b"(ptr addrspace(1) %16, i1 true) #6, !dbg !14
+  %20 = tail call i64 asm sideeffect "mov.u64 $0, 0x0;\0A\09@$2 ld.global.L1::evict_last.b64 { $0 }, [ $1 + 0 ];", "=l,l,b"(ptr addrspace(1) %16, i1 true) #6, !dbg !14
+  %21 = tail call i64 asm sideeffect "mov.u64 $0, 0x0;\0A\09@$2 ld.global.L1::evict_last.b64 { $0 }, [ $1 + 0 ];", "=l,l,b"(ptr addrspace(1) %16, i1 true) #6, !dbg !14
+  %22 = shl nsw i32 %14, 8, !dbg !15
+  %23 = or i32 %22, %12, !dbg !16
+  %24 = sext i32 %23 to i64, !dbg !17
+  %25 = getelementptr float, ptr addrspace(1) %3, i64 %24, !dbg !17
+  %26 = tail call { i32, i32, i32, i32 } asm sideeffect "mov.u32 $0, 0x0;\0A\09mov.u32 $1, 0x0;\0A\09mov.u32 $2, 0x0;\0A\09mov.u32 $3, 0x0;\0A\09@$5 ld.global.L1::evict_last.v4.b32 { $0, $1, $2, $3 }, [ $4 + 0 ];\0A\09@!$7 mov.u32 $0, $6;\0A\09@!$9 mov.u32 $1, $8;\0A\09@!$11 mov.u32 $2, $10;\0A\09@!$13 mov.u32 $3, $12;", "=r,=r,=r,=r,l,b,r,b,r,b,r,b,r,b"(ptr addrspace(1) %25, i1 true, i32 0, i1 true, i32 0, i1 true, i32 0, i1 true, i32 0, i1 true) #6, !dbg !18
+  %27 = zext nneg i32 %12 to i64, !dbg !19
+  %28 = getelementptr float, ptr addrspace(1) %4, i64 %27, !dbg !19
+  %29 = tail call { i32, i32, i32, i32 } asm sideeffect "mov.u32 $0, 0x0;\0A\09mov.u32 $1, 0x0;\0A\09mov.u32 $2, 0x0;\0A\09mov.u32 $3, 0x0;\0A\09@$5 ld.global.L1::evict_last.v4.b32 { $0, $1, $2, $3 }, [ $4 + 0 ];\0A\09@!$7 mov.u32 $0, $6;\0A\09@!$9 mov.u32 $1, $8;\0A\09@!$11 mov.u32 $2, $10;\0A\09@!$13 mov.u32 $3, $12;", "=r,=r,=r,=r,l,b,r,b,r,b,r,b,r,b"(ptr addrspace(1) %28, i1 true, i32 0, i1 true, i32 0, i1 true, i32 0, i1 true, i32 0, i1 true) #6, !dbg !20
+  %30 = add i64 %21, 50257, !dbg !21
+  %31 = icmp slt i64 %21, 0, !dbg !22
+  %32 = select i1 %31, i64 %30, i64 %21, !dbg !23
+  %33 = icmp ugt i64 %32, 50256, !dbg !24
+  br i1 %33, label %34, label %35, !dbg !25
+
+34:                                               ; preds = %10
+  tail call void @__assertfail(ptr nonnull @assertMessage_0, ptr nonnull @assertFile_0, i32 883, ptr nonnull @assertFunc_0, i64 1), !dbg !25
+  br label %35, !dbg !25
+
+35:                                               ; preds = %34, %10
+  %36 = icmp slt i64 %17, 0, !dbg !22
+  %37 = extractvalue { i32, i32, i32, i32 } %26, 3, !dbg !18
+  %38 = extractvalue { i32, i32, i32, i32 } %26, 2, !dbg !18
+  %39 = extractvalue { i32, i32, i32, i32 } %26, 1, !dbg !18
+  %40 = extractvalue { i32, i32, i32, i32 } %26, 0, !dbg !18
+  %41 = lshr i32 %11, 5, !dbg !10
+  %42 = and i32 %41, 1, !dbg !10
+  %43 = and i32 %11, 31, !dbg !10
+  %44 = shl i64 %17, 8, !dbg !26
+  %45 = add i64 %44, 12865792, !dbg !26
+  %46 = select i1 %36, i64 %45, i64 %44, !dbg !26
+  %47 = or i64 %46, %27, !dbg !27
+  %48 = getelementptr float, ptr addrspace(1) %2, i64 %47, !dbg !28
+  %49 = tail call { i32, i32, i32, i32 } asm sideeffect "mov.u32 $0, 0x0;\0A\09mov.u32 $1, 0x0;\0A\09mov.u32 $2, 0x0;\0A\09mov.u32 $3, 0x0;\0A\09@$5 ld.global.v4.b32 { $0, $1, $2, $3 }, [ $4 + 0 ];\0A\09@!$7 mov.u32 $0, $6;\0A\09@!$9 mov.u32 $1, $8;\0A\09@!$11 mov.u32 $2, $10;\0A\09@!$13 mov.u32 $3, $12;", "=r,=r,=r,=r,l,b,r,b,r,b,r,b,r,b"(ptr addrspace(1) %48, i1 true, i32 0, i1 true, i32 0, i1 true, i32 0, i1 true, i32 0, i1 true) #6, !dbg !29
+  %50 = extractvalue { i32, i32, i32, i32 } %49, 0, !dbg !29
+  %51 = extractvalue { i32, i32, i32, i32 } %49, 1, !dbg !29
+  %52 = extractvalue { i32, i32, i32, i32 } %49, 2, !dbg !29
+  %53 = extractvalue { i32, i32, i32, i32 } %49, 3, !dbg !29
+  %54 = insertelement <2 x i32> poison, i32 %40, i64 0, !dbg !18
+  %55 = insertelement <2 x i32> %54, i32 %39, i64 1, !dbg !18
+  %56 = bitcast <2 x i32> %55 to <2 x float>, !dbg !18
+  %57 = insertelement <2 x i32> poison, i32 %50, i64 0, !dbg !29
+  %58 = insertelement <2 x i32> %57, i32 %51, i64 1, !dbg !29
+  %59 = bitcast <2 x i32> %58 to <2 x float>, !dbg !29
+  %60 = fadd <2 x float> %56, %59, !dbg !30
+  %61 = insertelement <2 x i32> poison, i32 %37, i64 0, !dbg !18
+  %62 = insertelement <2 x i32> %61, i32 %38, i64 1, !dbg !18
+  %63 = bitcast <2 x i32> %62 to <2 x float>, !dbg !18
+  %64 = insertelement <2 x i32> poison, i32 %53, i64 0, !dbg !29
+  %65 = insertelement <2 x i32> %64, i32 %52, i64 1, !dbg !29
+  %66 = bitcast <2 x i32> %65 to <2 x float>, !dbg !29
+  %67 = fadd <2 x float> %63, %66, !dbg !30
+  %68 = extractelement <2 x float> %60, i64 0, !dbg !31
+  %69 = extractelement <2 x float> %60, i64 1, !dbg !31
+  %70 = fadd float %68, %69, !dbg !31
+  %71 = extractelement <2 x float> %67, i64 1, !dbg !31
+  %72 = fadd float %71, %70, !dbg !31
+  %73 = extractelement <2 x float> %67, i64 0, !dbg !31
+  %74 = fadd float %73, %72, !dbg !31
+  %75 = bitcast float %74 to i32, !dbg !37
+  %76 = tail call i32 @llvm.nvvm.shfl.sync.bfly.i32(i32 -1, i32 %75, i32 16, i32 31), !dbg !37
+  %77 = bitcast i32 %76 to float, !dbg !37
+  %78 = fadd float %74, %77, !dbg !31
+  %79 = bitcast float %78 to i32, !dbg !37
+  %80 = tail call i32 @llvm.nvvm.shfl.sync.bfly.i32(i32 -1, i32 %79, i32 8, i32 31), !dbg !37
+  %81 = bitcast i32 %80 to float, !dbg !37
+  %82 = fadd float %78, %81, !dbg !31
+  %83 = bitcast float %82 to i32, !dbg !37
+  %84 = tail call i32 @llvm.nvvm.shfl.sync.bfly.i32(i32 -1, i32 %83, i32 4, i32 31), !dbg !37
+  %85 = bitcast i32 %84 to float, !dbg !37
+  %86 = fadd float %82, %85, !dbg !31
+  %87 = bitcast float %86 to i32, !dbg !37
+  %88 = tail call i32 @llvm.nvvm.shfl.sync.bfly.i32(i32 -1, i32 %87, i32 2, i32 31), !dbg !37
+  %89 = bitcast i32 %88 to float, !dbg !37
+  %90 = fadd float %86, %89, !dbg !31
+  %91 = bitcast float %90 to i32, !dbg !37
+  %92 = tail call i32 @llvm.nvvm.shfl.sync.bfly.i32(i32 -1, i32 %91, i32 1, i32 31), !dbg !37
+  %93 = bitcast i32 %92 to float, !dbg !37
+  %94 = fadd float %90, %93, !dbg !31
+  %95 = icmp eq i32 %43, 0, !dbg !37
+  %96 = zext nneg i32 %42 to i64, !dbg !37
+  %97 = getelementptr float, ptr addrspace(3) @global_smem, i64 %96, !dbg !37
+  tail call void asm sideeffect "@$2 st.shared.b32 [ $0 + 0 ], $1;", "r,r,b"(ptr addrspace(3) %97, float %94, i1 %95) #6, !dbg !37
+  tail call void @llvm.nvvm.barrier0(), !dbg !37
+  %98 = icmp slt i32 %11, 2, !dbg !37
+  %99 = sext i32 %11 to i64, !dbg !37
+  %100 = getelementptr float, ptr addrspace(3) @global_smem, i64 %99, !dbg !37
+  %101 = tail call float asm sideeffect "@$2 ld.shared.b32 $0, [ $1 + 0 ];", "=r,r,b"(ptr addrspace(3) %100, i1 %98) #6, !dbg !37
+  %102 = bitcast float %101 to i32, !dbg !37
+  %103 = tail call i32 @llvm.nvvm.shfl.sync.bfly.i32(i32 -1, i32 %102, i32 1, i32 31), !dbg !37
+  %104 = bitcast i32 %103 to float, !dbg !37
+  %105 = fadd float %101, %104, !dbg !31
+  %106 = and i32 %11, 1, !dbg !37
+  %107 = icmp eq i32 %106, 0, !dbg !37
+  %108 = and i1 %98, %107, !dbg !37
+  tail call void asm sideeffect "@$2 st.shared.b32 [ $0 + 0 ], $1;", "r,r,b"(ptr addrspace(3) %100, float %105, i1 %108) #6, !dbg !37
+  tail call void @llvm.nvvm.barrier0(), !dbg !37
+  %109 = load float, ptr addrspace(3) @global_smem, align 4, !dbg !37
+  %110 = fadd float %109, 0.000000e+00, !dbg !39
+  %111 = tail call float asm "div.full.f32 $0, $1, $2;", "=r,r,r"(float %110, float 2.560000e+02) #6, !dbg !43
+  %112 = fsub float %68, %111, !dbg !44
+  %113 = fsub float %69, %111, !dbg !44
+  %114 = fsub float %71, %111, !dbg !44
+  %115 = fsub float %73, %111, !dbg !44
+  %116 = fmul float %112, %112, !dbg !45
+  %117 = fmul float %113, %113, !dbg !45
+  %118 = fmul float %114, %114, !dbg !45
+  %119 = fmul float %115, %115, !dbg !45
+  tail call void @llvm.nvvm.barrier0(), !dbg !46
+  %120 = fadd float %116, %117, !dbg !48
+  %121 = fadd float %118, %120, !dbg !48
+  %122 = fadd float %119, %121, !dbg !48
+  %123 = bitcast float %122 to i32, !dbg !46
+  %124 = tail call i32 @llvm.nvvm.shfl.sync.bfly.i32(i32 -1, i32 %123, i32 16, i32 31), !dbg !46
+  %125 = bitcast i32 %124 to float, !dbg !46
+  %126 = fadd float %122, %125, !dbg !48
+  %127 = bitcast float %126 to i32, !dbg !46
+  %128 = tail call i32 @llvm.nvvm.shfl.sync.bfly.i32(i32 -1, i32 %127, i32 8, i32 31), !dbg !46
+  %129 = bitcast i32 %128 to float, !dbg !46
+  %130 = fadd float %126, %129, !dbg !48
+  %131 = bitcast float %130 to i32, !dbg !46
+  %132 = tail call i32 @llvm.nvvm.shfl.sync.bfly.i32(i32 -1, i32 %131, i32 4, i32 31), !dbg !46
+  %133 = bitcast i32 %132 to float, !dbg !46
+  %134 = fadd float %130, %133, !dbg !48
+  %135 = bitcast float %134 to i32, !dbg !46
+  %136 = tail call i32 @llvm.nvvm.shfl.sync.bfly.i32(i32 -1, i32 %135, i32 2, i32 31), !dbg !46
+  %137 = bitcast i32 %136 to float, !dbg !46
+  %138 = fadd float %134, %137, !dbg !48
+  %139 = bitcast float %138 to i32, !dbg !46
+  %140 = tail call i32 @llvm.nvvm.shfl.sync.bfly.i32(i32 -1, i32 %139, i32 1, i32 31), !dbg !46
+  %141 = bitcast i32 %140 to float, !dbg !46
+  %142 = fadd float %138, %141, !dbg !48
+  tail call void asm sideeffect "@$2 st.shared.b32 [ $0 + 0 ], $1;", "r,r,b"(ptr addrspace(3) %97, float %142, i1 %95) #6, !dbg !46
+  tail call void @llvm.nvvm.barrier0(), !dbg !46
+  %143 = tail call float asm sideeffect "@$2 ld.shared.b32 $0, [ $1 + 0 ];", "=r,r,b"(ptr addrspace(3) %100, i1 %98) #6, !dbg !46
+  %144 = bitcast float %143 to i32, !dbg !46
+  %145 = tail call i32 @llvm.nvvm.shfl.sync.bfly.i32(i32 -1, i32 %144, i32 1, i32 31), !dbg !46
+  %146 = bitcast i32 %145 to float, !dbg !46
+  %147 = fadd float %143, %146, !dbg !48
+  tail call void asm sideeffect "@$2 st.shared.b32 [ $0 + 0 ], $1;", "r,r,b"(ptr addrspace(3) %100, float %147, i1 %108) #6, !dbg !46
+  tail call void @llvm.nvvm.barrier0(), !dbg !46
+  %148 = load float, ptr addrspace(3) @global_smem, align 4, !dbg !46
+  %149 = fadd float %148, 0.000000e+00, !dbg !51
+  %150 = tail call float asm "div.full.f32 $0, $1, $2;", "=r,r,r"(float %149, float 2.560000e+02) #6, !dbg !53
+  %151 = fadd float %150, 0x3EE4F8B580000000, !dbg !54
+  %152 = tail call i32 @__nvvm_reflect(ptr nonnull @.str) #6, !dbg !55
+  %.not.i = icmp eq i32 %152, 0, !dbg !55
+  br i1 %.not.i, label %155, label %153, !dbg !55
+
+153:                                              ; preds = %35
+  %154 = tail call float @llvm.nvvm.rsqrt.approx.ftz.f(float %151), !dbg !55
+  br label %__nv_rsqrtf.exit, !dbg !55
+
+155:                                              ; preds = %35
+  %156 = tail call float @llvm.nvvm.rsqrt.approx.f(float %151), !dbg !55
+  br label %__nv_rsqrtf.exit, !dbg !55
+
+__nv_rsqrtf.exit:                                 ; preds = %153, %155
+  %.0.i = phi float [ %154, %153 ], [ %156, %155 ], !dbg !55
+  %157 = extractvalue { i32, i32, i32, i32 } %29, 0, !dbg !20
+  %158 = bitcast i32 %157 to float, !dbg !20
+  %159 = extractvalue { i32, i32, i32, i32 } %29, 1, !dbg !20
+  %160 = bitcast i32 %159 to float, !dbg !20
+  %161 = extractvalue { i32, i32, i32, i32 } %29, 2, !dbg !20
+  %162 = bitcast i32 %161 to float, !dbg !20
+  %163 = extractvalue { i32, i32, i32, i32 } %29, 3, !dbg !20
+  %164 = bitcast i32 %163 to float, !dbg !20
+  %165 = fmul float %112, %.0.i, !dbg !56
+  %166 = fmul float %113, %.0.i, !dbg !56
+  %167 = fmul float %114, %.0.i, !dbg !56
+  %168 = fmul float %115, %.0.i, !dbg !56
+  %169 = fmul float %165, %158, !dbg !57
+  %170 = fmul float %166, %160, !dbg !57
+  %171 = fmul float %167, %162, !dbg !57
+  %172 = fmul float %168, %164, !dbg !57
+  %173 = shl i32 %13, 8, !dbg !58
+  %174 = or i32 %173, %12, !dbg !59
+  %175 = sext i32 %174 to i64, !dbg !60
+  %176 = getelementptr float, ptr addrspace(1) %5, i64 %175, !dbg !60
+  %177 = bitcast float %68 to i32, !dbg !61
+  %178 = bitcast float %69 to i32, !dbg !61
+  %179 = bitcast float %71 to i32, !dbg !61
+  %180 = bitcast float %73 to i32, !dbg !61
+  tail call void asm sideeffect "@$5 st.global.v4.b32 [ $4 + 0 ], { $0, $1, $2, $3 };", "r,r,r,r,l,b"(i32 %177, i32 %178, i32 %179, i32 %180, ptr addrspace(1) %176, i1 true) #6, !dbg !61
+  tail call void @llvm.nvvm.barrier0(), !dbg !62
+  %181 = getelementptr float, ptr addrspace(1) %0, i64 %15, !dbg !63
+  %182 = icmp eq i32 %urem, 0, !dbg !64
+  %183 = bitcast float %.0.i to i32, !dbg !64
+  tail call void asm sideeffect "@$2 st.global.b32 [ $1 + 0 ], { $0 };", "r,l,b"(i32 %183, ptr addrspace(1) %181, i1 %182) #6, !dbg !64
+  %184 = getelementptr i16, ptr addrspace(1) %7, i64 %175, !dbg !65
+  %185 = tail call i16 asm "cvt.rn.bf16.f32 $0, $1;", "=h,r"(float %169) #6, !dbg !66
+  %186 = tail call i16 asm "cvt.rn.bf16.f32 $0, $1;", "=h,r"(float %170) #6, !dbg !66
+  %187 = tail call i16 asm "cvt.rn.bf16.f32 $0, $1;", "=h,r"(float %171) #6, !dbg !66
+  %188 = tail call i16 asm "cvt.rn.bf16.f32 $0, $1;", "=h,r"(float %172) #6, !dbg !66
+  %189 = insertelement <2 x i16> undef, i16 %185, i64 0, !dbg !66
+  %190 = insertelement <2 x i16> %189, i16 %186, i64 1, !dbg !66
+  %191 = bitcast <2 x i16> %190 to i32, !dbg !66
+  %192 = insertelement <2 x i16> undef, i16 %187, i64 0, !dbg !66
+  %193 = insertelement <2 x i16> %192, i16 %188, i64 1, !dbg !66
+  %194 = bitcast <2 x i16> %193 to i32, !dbg !66
+  tail call void asm sideeffect "@$3 st.global.v2.b32 [ $2 + 0 ], { $0, $1 };", "r,r,l,b"(i32 %191, i32 %194, ptr addrspace(1) %184, i1 true) #6, !dbg !66
+  %195 = getelementptr float, ptr addrspace(1) %6, i64 %15, !dbg !67
+  %196 = bitcast float %111 to i32, !dbg !68
+  tail call void asm sideeffect "@$2 st.global.b32 [ $1 + 0 ], { $0 };", "r,l,b"(i32 %196, ptr addrspace(1) %195, i1 %182) #6, !dbg !68
+  ret void, !dbg !69
+}
+
+; Function Attrs: mustprogress nocallback nofree nosync nounwind speculatable willreturn memory(none)
+declare noundef i32 @llvm.nvvm.read.ptx.sreg.tid.x() #0
+
+; Function Attrs: convergent nocallback nounwind memory(inaccessiblemem: readwrite)
+declare i32 @llvm.nvvm.shfl.sync.bfly.i32(i32, i32, i32, i32) #1
+
+; Function Attrs: convergent nocallback nounwind
+declare void @llvm.nvvm.barrier0() #2
+
+; Function Attrs: alwaysinline nounwind
+define float @__nv_rsqrtf(float %x) local_unnamed_addr #3 {
+  %1 = tail call i32 @__nvvm_reflect(ptr nonnull @.str) #6
+  %.not = icmp eq i32 %1, 0
+  br i1 %.not, label %4, label %2
+
+2:                                                ; preds = %0
+  %3 = tail call float @llvm.nvvm.rsqrt.approx.ftz.f(float %x)
+  br label %6
+
+4:                                                ; preds = %0
+  %5 = tail call float @llvm.nvvm.rsqrt.approx.f(float %x)
+  br label %6
+
+6:                                                ; preds = %4, %2
+  %.0 = phi float [ %3, %2 ], [ %5, %4 ]
+  ret float %.0
+}
+
+declare i32 @__nvvm_reflect(ptr) local_unnamed_addr #4
+
+; Function Attrs: mustprogress nocallback nofree nosync nounwind willreturn memory(none)
+declare float @llvm.nvvm.rsqrt.approx.ftz.f(float) #5
+
+; Function Attrs: mustprogress nocallback nofree nosync nounwind willreturn memory(none)
+declare float @llvm.nvvm.rsqrt.approx.f(float) #5
+
+attributes #0 = { mustprogress nocallback nofree nosync nounwind speculatable willreturn memory(none) }
+attributes #1 = { convergent nocallback nounwind memory(inaccessiblemem: readwrite) }
+attributes #2 = { convergent nocallback nounwind }
+attributes #3 = { alwaysinline nounwind "disable-tail-calls"="false" "frame-pointer"="all" "less-precise-fpmad"="false" "no-infs-fp-math"="false" "no-nans-fp-math"="false" "stack-protector-buffer-size"="8" "unsafe-fp-math"="false" "use-soft-float"="false" }
+attributes #4 = { "disable-tail-calls"="false" "frame-pointer"="all" "less-precise-fpmad"="false" "no-infs-fp-math"="false" "no-nans-fp-math"="false" "stack-protector-buffer-size"="8" "unsafe-fp-math"="false" "use-soft-float"="false" }
+attributes #5 = { mustprogress nocallback nofree nosync nounwind willreturn memory(none) }
+attributes #6 = { nounwind }
+
+!llvm.module.flags = !{!0, !1}
+!llvm.dbg.cu = !{!2}
+!nvvm.annotations = !{!4, !5, !5, !4}
+!llvm.ident = !{!6}
+
+!0 = !{i32 2, !"Debug Info Version", i32 3}
+!1 = !{i32 4, !"nvvm-reflect-ftz", i32 1}
+!2 = distinct !DICompileUnit(language: DW_LANG_C, file: !3, producer: "triton", isOptimized: true, runtimeVersion: 0, emissionKind: FullDebug)
+!3 = !DIFile(filename: "cpdqiwgwgnzx7tsvbieui7kffx5dt43uhgvg7z7egekxcsybpv34.py", directory: "/tmp/torchinductor_root/pd")
+!4 = !{ptr @triton__0d1d2d3d4d5d6d7d8de9de, !"kernel", i32 1}
+!5 = !{ptr @triton__0d1d2d3d4d5d6d7d8de9de, !"maxntidx", i32 64}
+!6 = !{!"clang version 3.8.0 (tags/RELEASE_380/final)"}
+!7 = distinct !DISubprogram(name: "triton__0d1d2d3d4d5d6d7d8de9de", linkageName: "triton__0d1d2d3d4d5d6d7d8de9de", scope: !3, file: !3, line: 18, type: !8, scopeLine: 18, spFlags: DISPFlagDefinition | DISPFlagOptimized, unit: !2)
+!8 = !DISubroutineType(cc: DW_CC_normal, types: !9)
+!9 = !{}
+!10 = !DILocation(line: 26, column: 26, scope: !7)
+!11 = !DILocation(line: 23, column: 28, scope: !7)
+!12 = !DILocation(line: 30, column: 18, scope: !7)
+!13 = !DILocation(line: 31, column: 30, scope: !7)
+!14 = !DILocation(line: 31, column: 35, scope: !7)
+!15 = !DILocation(line: 32, column: 40, scope: !7)
+!16 = !DILocation(line: 32, column: 36, scope: !7)
+!17 = !DILocation(line: 32, column: 30, scope: !7)
+!18 = !DILocation(line: 32, column: 46, scope: !7)
+!19 = !DILocation(line: 33, column: 31, scope: !7)
+!20 = !DILocation(line: 33, column: 36, scope: !7)
+!21 = !DILocation(line: 34, column: 18, scope: !7)
+!22 = !DILocation(line: 35, column: 18, scope: !7)
+!23 = !DILocation(line: 36, column: 32, scope: !7)
+!24 = !DILocation(line: 37, column: 36, scope: !7)
+!25 = !DILocation(line: 37, column: 51, scope: !7)
+!26 = !DILocation(line: 38, column: 40, scope: !7)
+!27 = !DILocation(line: 38, column: 36, scope: !7)
+!28 = !DILocation(line: 38, column: 30, scope: !7)
+!29 = !DILocation(line: 38, column: 48, scope: !7)
+!30 = !DILocation(line: 39, column: 18, scope: !7)
+!31 = !DILocation(line: 233, column: 15, scope: !32, inlinedAt: !35)
+!32 = distinct !DILexicalBlockFile(scope: !34, file: !33, discriminator: 0)
+!33 = !DIFile(filename: "standard.py", directory: "/usr/local/lib/python3.10/dist-packages/triton/language")
+!34 = distinct !DILexicalBlockFile(scope: !7, file: !33, discriminator: 0)
+!35 = !DILocation(line: 243, column: 36, scope: !32, inlinedAt: !36)
+!36 = !DILocation(line: 44, column: 59, scope: !32)
+!37 = !DILocation(line: 243, column: 36, scope: !34, inlinedAt: !38)
+!38 = !DILocation(line: 44, column: 59, scope: !34)
+!39 = !DILocation(line: 8, column: 15, scope: !40, inlinedAt: !42)
+!40 = distinct !DILexicalBlockFile(scope: !7, file: !41, discriminator: 0)
+!41 = !DIFile(filename: "triton_helpers.py", directory: "/usr/local/lib/python3.10/dist-packages/torch/_inductor")
+!42 = !DILocation(line: 44, column: 45, scope: !40)
+!43 = !DILocation(line: 47, column: 20, scope: !7)
+!44 = !DILocation(line: 48, column: 19, scope: !7)
+!45 = !DILocation(line: 49, column: 20, scope: !7)
+!46 = !DILocation(line: 243, column: 36, scope: !34, inlinedAt: !47)
+!47 = !DILocation(line: 52, column: 59, scope: !34)
+!48 = !DILocation(line: 233, column: 15, scope: !32, inlinedAt: !49)
+!49 = !DILocation(line: 243, column: 36, scope: !32, inlinedAt: !50)
+!50 = !DILocation(line: 52, column: 59, scope: !32)
+!51 = !DILocation(line: 8, column: 15, scope: !40, inlinedAt: !52)
+!52 = !DILocation(line: 52, column: 45, scope: !40)
+!53 = !DILocation(line: 54, column: 20, scope: !7)
+!54 = !DILocation(line: 56, column: 20, scope: !7)
+!55 = !DILocation(line: 57, column: 26, scope: !7)
+!56 = !DILocation(line: 59, column: 20, scope: !7)
+!57 = !DILocation(line: 60, column: 20, scope: !7)
+!58 = !DILocation(line: 62, column: 35, scope: !7)
+!59 = !DILocation(line: 62, column: 31, scope: !7)
+!60 = !DILocation(line: 62, column: 25, scope: !7)
+!61 = !DILocation(line: 62, column: 47, scope: !7)
+!62 = !DILocation(line: 63, column: 4, scope: !7)
+!63 = !DILocation(line: 64, column: 28, scope: !7)
+!64 = !DILocation(line: 64, column: 40, scope: !7)
+!65 = !DILocation(line: 65, column: 25, scope: !7)
+!66 = !DILocation(line: 65, column: 48, scope: !7)
+!67 = !DILocation(line: 66, column: 25, scope: !7)
+!68 = !DILocation(line: 66, column: 37, scope: !7)
+!69 = !DILocation(line: 66, column: 4, scope: !7)

.triton/dump/8c4bac4d904709a8b7e8c698132d974c/triton_.llir

@@ -0,0 +1,45 @@
+; ModuleID = 'LLVMDialectModule'
+source_filename = "LLVMDialectModule"
+
+define void @triton__0d1de(ptr addrspace(1) %0, i32 %1) local_unnamed_addr !dbg !5 {
+  %3 = tail call i32 @llvm.nvvm.read.ptx.sreg.tid.x(), !dbg !8
+  %4 = shl i32 %3, 1, !dbg !8
+  %5 = and i32 %4, 254, !dbg !8
+  %6 = tail call i32 asm "mov.u32 $0, %ctaid.x;", "=r"() #1, !dbg !9
+  %7 = shl i32 %6, 8, !dbg !10
+  %8 = or i32 %7, %5, !dbg !11
+  %9 = or i32 %8, 1, !dbg !11
+  %10 = icmp slt i32 %8, 512, !dbg !12
+  %11 = sext i32 %8 to i64, !dbg !13
+  %12 = getelementptr i64, ptr addrspace(1) %0, i64 %11, !dbg !13
+  %13 = sext i32 %9 to i64, !dbg !14
+  tail call void asm sideeffect "@$3 st.global.v2.b64 [ $2 + 0 ], { $0, $1 };", "l,l,l,b"(i64 %11, i64 %13, ptr addrspace(1) %12, i1 %10) #1, !dbg !14
+  ret void, !dbg !15
+}
+
+; Function Attrs: mustprogress nocallback nofree nosync nounwind speculatable willreturn memory(none)
+declare noundef i32 @llvm.nvvm.read.ptx.sreg.tid.x() #0
+
+attributes #0 = { mustprogress nocallback nofree nosync nounwind speculatable willreturn memory(none) }
+attributes #1 = { nounwind }
+
+!llvm.module.flags = !{!0}
+!llvm.dbg.cu = !{!1}
+!nvvm.annotations = !{!3, !4, !4, !3}
+
+!0 = !{i32 2, !"Debug Info Version", i32 3}
+!1 = distinct !DICompileUnit(language: DW_LANG_C, file: !2, producer: "triton", isOptimized: true, runtimeVersion: 0, emissionKind: FullDebug)
+!2 = !DIFile(filename: "cwxxgxdevnyc453z7hh4nxzgmvlhh6suwokktps3dw62btskgxt4.py", directory: "/tmp/torchinductor_root/wx")
+!3 = !{ptr @triton__0d1de, !"kernel", i32 1}
+!4 = !{ptr @triton__0d1de, !"maxntidx", i32 128}
+!5 = distinct !DISubprogram(name: "triton__0d1de", linkageName: "triton__0d1de", scope: !2, file: !2, line: 18, type: !6, scopeLine: 18, spFlags: DISPFlagDefinition | DISPFlagOptimized, unit: !1)
+!6 = !DISubroutineType(cc: DW_CC_normal, types: !7)
+!7 = !{}
+!8 = !DILocation(line: 21, column: 36, scope: !5)
+!9 = !DILocation(line: 20, column: 28, scope: !5)
+!10 = !DILocation(line: 20, column: 33, scope: !5)
+!11 = !DILocation(line: 21, column: 23, scope: !5)
+!12 = !DILocation(line: 22, column: 21, scope: !5)
+!13 = !DILocation(line: 25, column: 25, scope: !5)
+!14 = !DILocation(line: 25, column: 36, scope: !5)
+!15 = !DILocation(line: 25, column: 4, scope: !5)

.triton/dump/8c4bac4d904709a8b7e8c698132d974c/triton_.ptx

@@ -0,0 +1,280 @@
+//
+// Generated by LLVM NVPTX Back-End
+//
+
+.version 8.2
+.target sm_89
+.address_size 64
+
+	// .globl	triton__0d1de
+
+.visible .entry triton__0d1de(
+	.param .u64 triton__0d1de_param_0,
+	.param .u32 triton__0d1de_param_1
+)
+.maxntid 128, 1, 1
+{
+	.reg .pred 	%p<2>;
+	.reg .b32 	%r<8>;
+	.reg .b64 	%rd<6>;
+	.loc	1 18 0
+$L__func_begin0:
+	.loc	1 18 0
+
+	ld.param.u64 	%rd4, [triton__0d1de_param_0];
+$L__tmp0:
+	.loc	1 21 36
+	mov.u32 	%r2, %tid.x;
+	shl.b32 	%r3, %r2, 1;
+	and.b32  	%r4, %r3, 254;
+	.loc	1 20 28
+	mov.u32 %r1, %ctaid.x;
+	.loc	1 20 33
+	shl.b32 	%r5, %r1, 8;
+	.loc	1 21 23
+	or.b32  	%r6, %r5, %r4;
+	or.b32  	%r7, %r6, 1;
+	.loc	1 22 21
+	setp.lt.s32 	%p1, %r6, 512;
+	.loc	1 25 25
+	cvt.s64.s32 	%rd1, %r6;
+	mul.wide.s32 	%rd5, %r6, 8;
+	add.s64 	%rd3, %rd4, %rd5;
+	.loc	1 25 36
+	cvt.s64.s32 	%rd2, %r7;
+	@%p1 st.global.v2.b64 [ %rd3 + 0 ], { %rd1, %rd2 };
+	.loc	1 25 4
+	ret;
+$L__tmp1:
+$L__func_end0:
+
+}
+	.file	1 "/tmp/torchinductor_root/wx/cwxxgxdevnyc453z7hh4nxzgmvlhh6suwokktps3dw62btskgxt4.py"
+	.section	.debug_abbrev
+	{
+.b8 1
+.b8 17
+.b8 1
+.b8 37
+.b8 8
+.b8 19
+.b8 5
+.b8 3
+.b8 8
+.b8 16
+.b8 6
+.b8 27
+.b8 8
+.b8 180
+.b8 66
+.b8 12
+.b8 17
+.b8 1
+.b8 18
+.b8 1
+.b8 0
+.b8 0
+.b8 2
+.b8 46
+.b8 0
+.b8 17
+.b8 1
+.b8 18
+.b8 1
+.b8 64
+.b8 10
+.b8 135
+.b8 64
+.b8 8
+.b8 3
+.b8 8
+.b8 58
+.b8 11
+.b8 59
+.b8 11
+.b8 63
+.b8 12
+.b8 0
+.b8 0
+.b8 0
+	}
+	.section	.debug_info
+	{
+.b32 172
+.b8 2
+.b8 0
+.b32 .debug_abbrev
+.b8 8
+.b8 1
+.b8 116
+.b8 114
+.b8 105
+.b8 116
+.b8 111
+.b8 110
+.b8 0
+.b8 2
+.b8 0
+.b8 99
+.b8 119
+.b8 120
+.b8 120
+.b8 103
+.b8 120
+.b8 100
+.b8 101
+.b8 118
+.b8 110
+.b8 121
+.b8 99
+.b8 52
+.b8 53
+.b8 51
+.b8 122
+.b8 55
+.b8 104
+.b8 104
+.b8 52
+.b8 110
+.b8 120
+.b8 122
+.b8 103
+.b8 109
+.b8 118
+.b8 108
+.b8 104
+.b8 104
+.b8 54
+.b8 115
+.b8 117
+.b8 119
+.b8 111
+.b8 107
+.b8 107
+.b8 116
+.b8 112
+.b8 115
+.b8 51
+.b8 100
+.b8 119
+.b8 54
+.b8 50
+.b8 98
+.b8 116
+.b8 115
+.b8 107
+.b8 103
+.b8 120
+.b8 116
+.b8 52
+.b8 46
+.b8 112
+.b8 121
+.b8 0
+.b32 .debug_line
+.b8 47
+.b8 116
+.b8 109
+.b8 112
+.b8 47
+.b8 116
+.b8 111
+.b8 114
+.b8 99
+.b8 104
+.b8 105
+.b8 110
+.b8 100
+.b8 117
+.b8 99
+.b8 116
+.b8 111
+.b8 114
+.b8 95
+.b8 114
+.b8 111
+.b8 111
+.b8 116
+.b8 47
+.b8 119
+.b8 120
+.b8 0
+.b8 1
+.b64 $L__func_begin0
+.b64 $L__func_end0
+.b8 2
+.b64 $L__func_begin0
+.b64 $L__func_end0
+.b8 1
+.b8 156
+.b8 116
+.b8 114
+.b8 105
+.b8 116
+.b8 111
+.b8 110
+.b8 95
+.b8 95
+.b8 48
+.b8 100
+.b8 49
+.b8 100
+.b8 101
+.b8 0
+.b8 116
+.b8 114
+.b8 105
+.b8 116
+.b8 111
+.b8 110
+.b8 95
+.b8 95
+.b8 48
+.b8 100
+.b8 49
+.b8 100
+.b8 101
+.b8 0
+.b8 1
+.b8 18
+.b8 1
+.b8 0
+	}
+	.section	.debug_pubnames
+	{
+.b32 $L__pubNames_end0-$L__pubNames_start0
+$L__pubNames_start0:
+.b8 2
+.b8 0
+.b32 .debug_info
+.b32 176
+.b32 125
+.b8 116
+.b8 114
+.b8 105
+.b8 116
+.b8 111
+.b8 110
+.b8 95
+.b8 95
+.b8 48
+.b8 100
+.b8 49
+.b8 100
+.b8 101
+.b8 0
+.b32 0
+$L__pubNames_end0:
+	}
+	.section	.debug_pubtypes
+	{
+.b32 $L__pubTypes_end0-$L__pubTypes_start0
+$L__pubTypes_start0:
+.b8 2
+.b8 0
+.b32 .debug_info
+.b32 176
+.b32 0
+$L__pubTypes_end0:
+	}
+	.section	.debug_loc	{	}

.triton/dump/a4652f539404a11e3c068d96115a7427/triton_.llir

@@ -0,0 +1,53 @@
+; ModuleID = 'LLVMDialectModule'
+source_filename = "LLVMDialectModule"
+
+define void @triton__0d1d2de(ptr addrspace(1) %0, ptr addrspace(1) %1, i32 %2) local_unnamed_addr !dbg !5 {
+  %4 = tail call i32 @llvm.nvvm.read.ptx.sreg.tid.x(), !dbg !8
+  %5 = shl i32 %4, 1, !dbg !8
+  %6 = and i32 %5, 254, !dbg !8
+  %7 = tail call i32 asm "mov.u32 $0, %ctaid.x;", "=r"() #1, !dbg !9
+  %8 = shl i32 %7, 8, !dbg !10
+  %9 = or i32 %8, %6, !dbg !11
+  %10 = sext i32 %9 to i64, !dbg !12
+  %11 = getelementptr i16, ptr addrspace(1) %0, i64 %10, !dbg !12
+  %12 = tail call i32 asm sideeffect "mov.u32 $0, 0x0;\0A\09@$2 ld.global.b32 { $0 }, [ $1 + 0 ];", "=r,l,b"(ptr addrspace(1) %11, i1 true) #1, !dbg !13
+  %13 = trunc i32 %12 to i16, !dbg !13
+  %extelt.offset = lshr i32 %12, 16, !dbg !13
+  %14 = trunc i32 %extelt.offset to i16, !dbg !13
+  %15 = tail call float asm "cvt.f32.bf16 $0, $1;", "=r,h"(i16 %13) #1, !dbg !14
+  %16 = tail call float asm "cvt.f32.bf16 $0, $1;", "=r,h"(i16 %14) #1, !dbg !14
+  %17 = getelementptr float, ptr addrspace(1) %1, i64 %10, !dbg !15
+  %18 = bitcast float %15 to i32, !dbg !16
+  %19 = bitcast float %16 to i32, !dbg !16
+  tail call void asm sideeffect "@$3 st.global.v2.b32 [ $2 + 0 ], { $0, $1 };", "r,r,l,b"(i32 %18, i32 %19, ptr addrspace(1) %17, i1 true) #1, !dbg !16
+  ret void, !dbg !17
+}
+
+; Function Attrs: mustprogress nocallback nofree nosync nounwind speculatable willreturn memory(none)
+declare noundef i32 @llvm.nvvm.read.ptx.sreg.tid.x() #0
+
+attributes #0 = { mustprogress nocallback nofree nosync nounwind speculatable willreturn memory(none) }
+attributes #1 = { nounwind }
+
+!llvm.module.flags = !{!0}
+!llvm.dbg.cu = !{!1}
+!nvvm.annotations = !{!3, !4, !4, !3}
+
+!0 = !{i32 2, !"Debug Info Version", i32 3}
+!1 = distinct !DICompileUnit(language: DW_LANG_C, file: !2, producer: "triton", isOptimized: true, runtimeVersion: 0, emissionKind: FullDebug)
+!2 = !DIFile(filename: "czl6nmwasl7k4ic55xowihczcooh3mhu5v6ls6w2xzqqocdc2da7.py", directory: "/tmp/torchinductor_root/zl")
+!3 = !{ptr @triton__0d1d2de, !"kernel", i32 1}
+!4 = !{ptr @triton__0d1d2de, !"maxntidx", i32 128}
+!5 = distinct !DISubprogram(name: "triton__0d1d2de", linkageName: "triton__0d1d2de", scope: !2, file: !2, line: 18, type: !6, scopeLine: 18, spFlags: DISPFlagDefinition | DISPFlagOptimized, unit: !1)
+!6 = !DISubroutineType(cc: DW_CC_normal, types: !7)
+!7 = !{}
+!8 = !DILocation(line: 21, column: 36, scope: !5)
+!9 = !DILocation(line: 20, column: 28, scope: !5)
+!10 = !DILocation(line: 20, column: 33, scope: !5)
+!11 = !DILocation(line: 21, column: 23, scope: !5)
+!12 = !DILocation(line: 24, column: 30, scope: !5)
+!13 = !DILocation(line: 24, column: 35, scope: !5)
+!14 = !DILocation(line: 24, column: 44, scope: !5)
+!15 = !DILocation(line: 26, column: 25, scope: !5)
+!16 = !DILocation(line: 26, column: 36, scope: !5)
+!17 = !DILocation(line: 26, column: 4, scope: !5)