text:
/*jslint nomen:true*/
/*global define*/
define(function(require) {
    'use strict';

    var WorkflowActivateBtnView;
    var BaseView = require('oroui/js/app/views/base/view');
    var mediator = require('oroui/js/mediator');
    var messenger = require('oroui/js/messenger');
    var $ = require('jquery');
    var _ = require('underscore');
    var activationHandler = require('oroworkflow/js/activation-handler');

    WorkflowActivateBtnView = BaseView.extend({
        /**
         * @property {Object}
         */
        options: {
            selectors: {
                button: null
            }
        },

        $el: null,

        /**
         * @inheritDoc
         */
        initialize: function(options) {
            WorkflowActivateBtnView.__super__.initialize.apply(this, arguments);

            this.options = $.extend(true, {}, this.options, _.pick(options, _.keys(this.options)));
        },

        delegateEvents: function() {
            WorkflowActivateBtnView.__super__.delegateEvents.apply(this, arguments);
            this.$el.on('click' + this.eventNamespace(), this.options.selectors.button, $.proxy(this.onClick, this));
        },

        /**
         * @param {jQuery.Event} e
         */
        onClick: function(e) {
            e.preventDefault();

            var el = this.$el.find(this.options.selectors.button);

            el.on('activation_success', function(e, response) {
                mediator.once('page:afterChange', function() {
                    messenger.notificationFlashMessage('success', response.message);

                    if (response.deactivatedMessage) {
                        messenger.notificationFlashMessage('info', response.deactivatedMessage);
                    }
                });
                mediator.execute('refreshPage');
            });

            activationHandler.call(el, el.prop('href'), el.data('name'), el.data('label'));
        },

        dispose: function() {
            if (this.disposed) {
                return;
            }

            this.$el.off('click' + this.eventNamespace());

            WorkflowActivateBtnView.__super__.dispose.apply(this, arguments);
        }
    });

    return WorkflowActivateBtnView;
});


text:
<?php

/* SonataUserBundle:Admin/Core:user_block.html.twig */
class __TwigTemplate_e4663034036967edb1cb19110a4c6df68176ad74ae8227238ab6387bc7c42eaf extends Sonata\CacheBundle\Twig\TwigTemplate14
{
    public function __construct(Twig_Environment $env)
    {
        parent::__construct($env);

        $this->parent = false;

        $this->blocks = array(
            'user_block' => array($this, 'block_user_block'),
        );
    }

    protected function doDisplay(array $context, array $blocks = array())
    {
        // line 1
        $this->displayBlock('user_block', $context, $blocks);
    }

    public function block_user_block($context, array $blocks = array())
    {
        // line 2
        echo "    ";
        if ($this->getAttribute((isset($context["app"]) ? $context["app"] : $this->getContext($context, "app")), "user", array())) {
            // line 3
            echo "
        ";
            // line 4
            $context["_bg_class"] = "bg-light-blue";
            // line 5
            echo "        ";
            $context["_logout_uri"] = $this->env->getExtension('routing')->getUrl("sonata_user_admin_security_logout");
            // line 6
            echo "        ";
            $context["_logout_text"] = $this->env->getExtension('translator')->trans("user_block_logout", array(), "SonataUserBundle");
            // line 7
            echo "        ";
            $context["_user_image"] = $this->env->getExtension('assets')->getAssetUrl($this->getAttribute((isset($context["sonata_user"]) ? $context["sonata_user"] : $this->getContext($context, "sonata_user")), "defaultAvatar", array()));
            // line 8
            echo "        ";
            // line 9
            echo "        ";
            // line 10
            echo "
        ";
            // line 11
            if (($this->env->getExtension('security')->isGranted("ROLE_PREVIOUS_ADMIN") && $this->getAttribute((isset($context["sonata_user"]) ? $context["sonata_user"] : $this->getContext($context, "sonata_user")), "impersonating", array()))) {
                // line 12
                echo "            ";
                $context["_bg_class"] = "bg-light-green";
                // line 13
                echo "            ";
                $context["_logout_uri"] = $this->env->getExtension('routing')->getUrl($this->getAttribute($this->getAttribute((isset($context["sonata_user"]) ? $context["sonata_user"] : $this->getContext($context, "sonata_user")), "impersonating", array()), "route", array()), twig_array_merge($this->getAttribute($this->getAttribute((isset($context["sonata_user"]) ? $context["sonata_user"] : $this->getContext($context, "sonata_user")), "impersonating", array()), "parameters", array()), array("_switch_user" => "_exit")));
                // line 14
                echo "            ";
                $context["_logout_text"] = "(exit)";
                // line 15
                echo "        ";
            }
            // line 16
            echo "

env, (isset($context["_bg_class"]) ? $context["_bg_class"] : $this->getContext($context, "_bg_class")), "html", null, true);
            echo "\">
            ";
            // line 18
            if ((isset($context["_user_image"]) ? $context["_user_image"] : $this->getContext($context, "_user_image"))) {
                // line 19
                echo "                env, (isset($context["_user_image"]) ? $context["_user_image"] : $this->getContext($context, "_user_image")), "html", null, true);
                echo "\" class=\"img-circle\" alt=\"Avatar\" />
            ";
            }
            // line 21
            echo "
";
            echo twig_escape_filter($this->env, $this->getAttribute((isset($context["app"]) ? $context["app"] : $this->getContext($context, "app")), "user", array()), "html", null, true);
            echo "

";
            // line 30
            echo "

";
            // line 38
            echo "

                env, (isset($context["_logout_uri"]) ? $context["_logout_uri"] : $this->getContext($context, "_logout_uri")), "html", null, true);
            echo "\" class=\"btn btn-default btn-flat\"> ";
            echo twig_escape_filter($this->env, (isset($context["_logout_text"]) ? $context["_logout_text"] : $this->getContext($context, "_logout_text")), "html", null, true);
            echo "

    ";
        }
    }

    public function getTemplateName()
    {
        return "SonataUserBundle:Admin/Core:user_block.html.twig";
    }

    public function getDebugInfo()
    {
        return array (  94 => 40,  90 => 38,  86 => 30,  79 => 21,  73 => 19,  71 => 18,  67 => 17,  64 => 16,  61 => 15,  58 => 14,  55 => 13,  52 => 12,  50 => 11,  47 => 10,  45 => 9,  43 => 8,  40 => 7,  37 => 6,  34 => 5,  32 => 4,  29 => 3,  26 => 2,  20 => 1,);
    }
}

redpajama_set_name: RedPajamaGithub


text:
'use strict';

var _noop2 = require('lodash/noop');

var _noop3 = _interopRequireDefault(_noop2);

var _expect = require('expect');

var _expect2 = _interopRequireDefault(_expect);

var _getValue = require('../getValue');

var _getValue2 = _interopRequireDefault(_getValue);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

describe('getValue', function () {
  it('should return value if non-event value is passed', function () {
    (0, _expect2.default)((0, _getValue2.default)(undefined, true)).toBe(undefined);
    (0, _expect2.default)((0, _getValue2.default)(undefined, false)).toBe(undefined);
    (0, _expect2.default)((0, _getValue2.default)(null, true)).toBe(null);
    (0, _expect2.default)((0, _getValue2.default)(null, false)).toBe(null);
    (0, _expect2.default)((0, _getValue2.default)(5, true)).toBe(5);
    (0, _expect2.default)((0, _getValue2.default)(5, false)).toBe(5);
    (0, _expect2.default)((0, _getValue2.default)(true, true)).toBe(true);
    (0, _expect2.default)((0, _getValue2.default)(true, false)).toBe(true);
    (0, _expect2.default)((0, _getValue2.default)(false, true)).toBe(false);
    (0, _expect2.default)((0, _getValue2.default)(false, false)).toBe(false);
    (0, _expect2.default)((0, _getValue2.default)('dog', true)).toBe('dog');
    (0, _expect2.default)((0, _getValue2.default)('dog', false)).toBe('dog');
  });

  it('should not unwrap value if non-event object containing value key is passed', function () {
    (0, _expect2.default)((0, _getValue2.default)({ value: 5 }, true)).toEqual({ value: 5 });
    (0, _expect2.default)((0, _getValue2.default)({ value: 5 }, false)).toEqual({ value: 5 });
    (0, _expect2.default)((0, _getValue2.default)({ value: true }, true)).toEqual({ value: true });
    (0, _expect2.default)((0, _getValue2.default)({ value: true }, false)).toEqual({ value: true });
    (0, _expect2.default)((0, _getValue2.default)({ value: false }, true)).toEqual({ value: false });
    (0, _expect2.default)((0, _getValue2.default)({ value: false }, false)).toEqual({ value: false });
  });

  it('should return value if object NOT containing value key is passed', function () {
    var foo = { bar: 5, baz: 8 };
    (0, _expect2.default)((0, _getValue2.default)(foo)).toBe(foo);
  });

  it('should return event.nativeEvent.text if defined and not react-native', function () {
    (0, _expect2.default)((0, _getValue2.default)({
      preventDefault: _noop3.default,
      stopPropagation: _noop3.default,
      nativeEvent: {
        text: 'foo'
      }
    }, false)).toBe('foo');
  });

  it('should return event.nativeEvent.text if react-native', function () {
    (0, _expect2.default)((0, _getValue2.default)({
      preventDefault: _noop3.default,
      stopPropagation: _noop3.default,
      nativeEvent: {
        text: 'foo'
      }
    }, true)).toBe('foo');
    (0, _expect2.default)((0, _getValue2.default)({
      preventDefault: _noop3.default,
      stopPropagation: _noop3.default,
      nativeEvent: {
        text: undefined
      }
    }, true)).toBe(undefined);
    (0, _expect2.default)((0, _getValue2.default)({
      preventDefault: _noop3.default,
      stopPropagation: _noop3.default,
      nativeEvent: {
        text: null
      }
    }, true)).toBe(null);
  });

  it('should return event.target.checked if checkbox', function () {
    (0, _expect2.default)((0, _getValue2.default)({
      preventDefault: _noop3.default,
      stopPropagation: _noop3.default,
      target: {
        type: 'checkbox',
        checked: true
      }
    }, true)).toBe(true);
    (0, _expect2.default)((0, _getValue2.default)({
      preventDefault: _noop3.default,
      stopPropagation: _noop3.default,
      target: {
        type: 'checkbox',
        checked: true
      }
    }, false)).toBe(true);
    (0, _expect2.default)((0, _getValue2.default)({
      preventDefault: _noop3.default,
      stopPropagation: _noop3.default,
      target: {
        type: 'checkbox',
        checked: false
      }
    }, true)).toBe(false);
    (0, _expect2.default)((0, _getValue2.default)({
      preventDefault: _noop3.default,
      stopPropagation: _noop3.default,
      target: {
        type: 'checkbox',
        checked: false
      }
    }, false)).toBe(false);
  });

  it('should return a number type for numeric inputs, when a value is set', function () {
    (0, _expect2.default)((0, _getValue2.default)({
      preventDefault: _noop3.default,
      stopPropagation: _noop3.default,
      target: {
        type: 'number',
        value: '3.1415'
      }
    }, true)).toBe('3.1415');
    (0, _expect2.default)((0, _getValue2.default)({
      preventDefault: _noop3.default,
      stopPropagation: _noop3.default,
      target: {
        type: 'range',
        value: '2.71828'
      }
    }, true)).toBe('2.71828');
    (0, _expect2.default)((0, _getValue2.default)({
      preventDefault: _noop3.default,
      stopPropagation: _noop3.default,
      target: {
        type: 'number',
        value: '3'
      }
    }, false)).toBe('3');
    (0, _expect2.default)((0, _getValue2.default)({
      preventDefault: _noop3.default,
      stopPropagation: _noop3.default,
      target: {
        type: 'range',
        value: '3.1415'
      }
    }, false)).toBe('3.1415');

    (0, _expect2.default)((0, _getValue2.default)({
      preventDefault: _noop3.default,
      stopPropagation: _noop3.default,
      target: {
        type: 'range',
        value: ''
      }
    }, false)).toBe('');
  });

  it('should return event.target.files if file', function () {
    var myFiles = ['foo', 'bar'];
    (0, _expect2.default)((0, _getValue2.default)({
      preventDefault: _noop3.default,
      stopPropagation: _noop3.default,
      target: {
        type: 'file',
        files: myFiles
      }
    }, true)).toBe(myFiles);
    (0, _expect2.default)((0, _getValue2.default)({
      preventDefault: _noop3.default,
      stopPropagation: _noop3.default,
      target: {
        type: 'file',
        files: myFiles
      }
    }, false)).toBe(myFiles);
  });

  it('should return event.dataTransfer.files if file and files not in target.files', function () {
    var myFiles = ['foo', 'bar'];
    (0, _expect2.default)((0, _getValue2.default)({
      preventDefault: _noop3.default,
      stopPropagation: _noop3.default,
      target: {
        type: 'file'
      },
      dataTransfer: {
        files: myFiles
      }
    }, true)).toBe(myFiles);
    (0, _expect2.default)((0, _getValue2.default)({
      preventDefault: _noop3.default,
      stopPropagation: _noop3.default,
      target: {
        type: 'file'
      },
      dataTransfer: {
        files: myFiles
      }
    }, false)).toBe(myFiles);
  });

  it('should return selected options if is a multiselect', function () {
    var options = [{ selected: true, value: 'foo' }, { selected: true, value: 'bar' }, { selected: false, value: 'baz' }];
    var expected = options.filter(function (option) {
      return option.selected;
    }).map(function (option) {
      return option.value;
    });
    (0, _expect2.default)((0, _getValue2.default)({
      preventDefault: _noop3.default,
      stopPropagation: _noop3.default,
      target: {
        type: 'select-multiple',
        options: options
      }
    }, true)).toEqual(expected);
    (0, _expect2.default)((0, _getValue2.default)({
      preventDefault: _noop3.default,
      stopPropagation: _noop3.default,
      target: {
        type: 'select-multiple'
      }
    }, false)).toEqual([]); // no options specified
    (0, _expect2.default)((0, _getValue2.default)({
      preventDefault: _noop3.default,
      stopPropagation: _noop3.default,
      target: {
        type: 'select-multiple',
        options: options
      }
    }, false)).toEqual(expected);
  });

  it('should return event.target.value if not file or checkbox', function () {
    (0, _expect2.default)((0, _getValue2.default)({
      preventDefault: _noop3.default,
      stopPropagation: _noop3.default,
      target: {
        value: undefined
      }
    }, true)).toBe(undefined);
    (0, _expect2.default)((0, _getValue2.default)({
      preventDefault: _noop3.default,
      stopPropagation: _noop3.default,
      target: {
        value: undefined
      }
    }, false)).toBe(undefined);
    (0, _expect2.default)((0, _getValue2.default)({
      preventDefault: _noop3.default,
      stopPropagation: _noop3.default,
      target: {
        value: null
      }
    }, true)).toBe(null);
    (0, _expect2.default)((0, _getValue2.default)({
      preventDefault: _noop3.default,
      stopPropagation: _noop3.default,
      target: {
        value: null
      }
    }, false)).toBe(null);
    (0, _expect2.default)((0, _getValue2.default)({
      preventDefault: _noop3.default,
      stopPropagation: _noop3.default,
      target: {
        value: true
      }
    }, true)).toBe(true);
    (0, _expect2.default)((0, _getValue2.default)({
      preventDefault: _noop3.default,
      stopPropagation: _noop3.default,
      target: {
        value: true
      }
    }, false)).toBe(true);
    (0, _expect2.default)((0, _getValue2.default)({
      preventDefault: _noop3.default,
      stopPropagation: _noop3.default,
      target: {
        value: false
      }
    }, true)).toBe(false);
    (0, _expect2.default)((0, _getValue2.default)({
      preventDefault: _noop3.default,
      stopPropagation: _noop3.default,
      target: {
        value: false
      }
    }, false)).toBe(false);
    (0, _expect2.default)((0, _getValue2.default)({
      preventDefault: _noop3.default,
      stopPropagation: _noop3.default,
      target: {
        value: 42
      }
    }, true)).toBe(42);
    (0, _expect2.default)((0, _getValue2.default)({
      preventDefault: _noop3.default,
      stopPropagation: _noop3.default,
      target: {
        value: 42
      }
    }, false)).toBe(42);
    (0, _expect2.default)((0, _getValue2.default)({
      preventDefault: _noop3.default,
      stopPropagation: _noop3.default,
      target: {
        value: 'foo'
      }
    }, true)).toBe('foo');
    (0, _expect2.default)((0, _getValue2.default)({
      preventDefault: _noop3.default,
      stopPropagation: _noop3.default,
      target: {
        value: 'foo'
      }
    }, false)).toBe('foo');
  });
});


text:
<panel layout="GridBagLayout">
	<vbox>
		<gridbagconstraints
			gridx="0"
			gridy="0"
			weightx="1"
			weighty="1"
			gridheight="1"
			anchor="GridBagConstraints.NORTHWEST"
			fill="GridBagConstraints.BOTH"
			/>
		<hbox>
			<button text="Stop" id="stop" />
			<button text="Play" id="play" />
			<button text="Show Token" id="token" />
			<glue />
		</hbox>
	</vbox>
</panel>


text:
title: "Kyle Den Hartog's Resume"
description: This is my current and most up to date resume as of 3/28/2017.
date: 2017-03-28
layout: resume
---

[downloadable PDF version](/assets/Resume-KyleDenHartog.pdf)
<img src="/assets/img/Resume.jpg">


text:
<?php
declare(strict_types=1);

namespace Genkgo\Xsl\Callback;

use Closure;
use Genkgo\Xsl\TransformationContext;

final class ClosureFunction extends AbstractFunction
{
    /**
     * @var string
     */
    private $name;

    /**
     * @var Closure
     */
    private $callback;

    /**
     * @param string $name
     * @param Closure $callback
     */
    public function __construct(string $name, Closure $callback)
    {
        $this->name = $name;
        $this->callback = $callback;
    }

    /**
     * @return string
     */
    protected function getName(): string
    {
        return $this->name;
    }

    /**
     * @param Arguments $arguments
     * @param TransformationContext $context
     * @return mixed
     */
    public function call(Arguments $arguments, TransformationContext $context)
    {
        return \call_user_func($this->callback, $arguments, $context);
    }
}


text:
from random import randint
import math

def isE(num1, num2):
    if num1<num2:
        print"too small"
        return False;
    if num1>num2:
        print"too big"
        return False;
    if num1==num2:
        print"ops"
        return True

x=2**100000
num=randint(1,x)
print"guess which number i like"
ops=False
while ops==False:
    answer=input()
    ops=isE(answer, num)


text:
package net.minecraft.item.crafting;

import net.minecraft.item.ItemStack;

public class FurnaceRecipes {

    private static final FurnaceRecipes instance = new FurnaceRecipes();

    /** get shared instance */
    public static FurnaceRecipes func_77602_a() {
        return instance;
    }

    /** add smelting recipe */
    public void func_77600_a(int input, ItemStack output, float xp) {

    }
}


text:
Contributing wordlists is appreciated. CSV format, column one is the word and column 2 is the single-char part of speech.

The English wordlist is from wordfrequency.info


text:
Created based on how soda is extremely enjoyable yet lacks the fun
facts that come with various bottled drinks.

Now you can have it all - soda and facts!


text:
// Copyright (c) 2011-2021 The Bitcoin Core developers
// Distributed under the MIT software license, see the accompanying
// file COPYING or http://www.opensource.org/licenses/mit-license.php.

#ifndef BITCOIN_QT_PEERTABLEMODEL_H
#define BITCOIN_QT_PEERTABLEMODEL_H

#include <net_processing.h> // For CNodeStateStats
#include <net.h>

#include <QAbstractTableModel>
#include <QIcon>
#include <QList>
#include <QModelIndex>
#include <QStringList>
#include <QVariant>

class PeerTablePriv;
class PlatformStyle;

namespace interfaces {
class Node;
}

QT_BEGIN_NAMESPACE
class QTimer;
QT_END_NAMESPACE

struct CNodeCombinedStats {
    CNodeStats nodeStats;
    CNodeStateStats nodeStateStats;
    bool fNodeStateStatsAvailable;
};
Q_DECLARE_METATYPE(CNodeCombinedStats*)

/**
   Qt model providing information about connected peers, similar to the
   "getpeerinfo" RPC call. Used by the rpc console UI.
 */
class PeerTableModel : public QAbstractTableModel
{
    Q_OBJECT

public:
    explicit PeerTableModel(interfaces::Node& node, const PlatformStyle&, QObject* parent);
    ~PeerTableModel();
    void startAutoRefresh();
    void stopAutoRefresh();

    // See also RPCConsole::ColumnWidths in rpcconsole.h
    enum ColumnIndex {
        NetNodeId = 0,
        Age,
        Direction,
        Address,
        ConnectionType,
        Ping,
        Sent,
        Received,
        Subversion,
        Network,  // Not used, just kept at the end to avoid excessive code removal
    };

    enum {
        StatsRole = Qt::UserRole,
    };

    /** @name Methods overridden from QAbstractTableModel
        @{*/
    int rowCount(const QModelIndex& parent = QModelIndex()) const override;
    int columnCount(const QModelIndex& parent = QModelIndex()) const override;
    QVariant data(const QModelIndex& index, int role = Qt::DisplayRole) const override;
    QVariant headerData(int section, Qt::Orientation orientation, int role = Qt::DisplayRole) const override;
    QModelIndex index(int row, int column, const QModelIndex& parent = QModelIndex()) const override;
    Qt::ItemFlags flags(const QModelIndex &index) const override;
    /*@}*/

public Q_SLOTS:
    void refresh();
    void updatePalette();

private:
    //! Internal peer data structure.
    QList<CNodeCombinedStats> m_peers_data{};
    interfaces::Node& m_node;
    const PlatformStyle& m_platform_style;
    void DrawIcons();
    QIcon m_icon_conn_in, m_icon_conn_out;
    const QStringList columns{
        /*: Title of Peers Table column which contains a
            unique number used to identify a connection. */
        tr("id"),
        /*: Title of Peers Table column which indicates the duration (length of time)
            since the peer connection started. */
        tr("Age"),
        "",  // Direction column has no title
        /*: Title of Peers Table column which contains the
            IP/Onion/I2P address of the connected peer. */
        tr("Address"),
        /*: Title of Peers Table column which describes the type of
            peer connection. The "type" describes why the connection exists. */
        tr("Type"),
        /*: Title of Peers Table column which indicates the current latency
            of the connection with the peer. */
        tr("Ping"),
        /*: Title of Peers Table column which indicates the total amount of
            network information we have sent to the peer. */
        tr("Sent"),
        /*: Title of Peers Table column which indicates the total amount of
            network information we have received from the peer. */
        tr("Recv'd"),
        /*: Title of Peers Table column which contains the peer's
            User Agent string. */
        tr("User Agent")};
    QTimer *timer;
};

#endif // BITCOIN_QT_PEERTABLEMODEL_H


text:
package org.shirolang.dag;

import java.util.List;

/**
 *
 * @param <T>
 * @author Ankit Gupta, Jeffrey Guenther
 */
public class PathUpdater<T> implements Runnable{
    private List<GraphNode<T>> pathToUpdate = null;

    public void setPathToUpdate(List<GraphNode<T>> portPath) {
        pathToUpdate = portPath;
    }

    /**
     * Get the count of no yet updated dependencies
     * @param node graph node to check
     * @return the number of dependencies not yet updated
     */
    private int getUnupdatedDependencies(GraphNode<T> node){
        int counter = 0;
        for(GraphNode<T> dp: node.getNodesDependedOn()){
            if(dp.isUpdated()){
                counter++;
            }
        }

        return counter;
    }

    @Override
    public void run() {
        for (GraphNode<T> n : pathToUpdate) {
            synchronized (n) {
                if (!n.isUpdated() && n.isActive() && getUnupdatedDependencies(n) == 0) {
                    // do the action stored in the node
                    n.doAction();
                }
            }
        }
    }
}


text:
// Copyright (c) 2011-present, Facebook, Inc.  All rights reserved.
// This source code is licensed under the BSD-style license found in the
// LICENSE file in the root directory of this source tree. An additional grant
// of patent rights can be found in the PATENTS file in the same directory.
//
// This file implements the "bridge" between Java and C++ for
// rocksdb::ClockCache.

#include <jni.h>

#include "cache/clock_cache.h"
#include "include/org_rocksdb_ClockCache.h"

/*
 * Class:     org_rocksdb_ClockCache
 * Method:    newClockCache
 * Signature: (JIZ)J
 */
jlong Java_org_rocksdb_ClockCache_newClockCache(
    JNIEnv* env, jclass jcls, jlong jcapacity, jint jnum_shard_bits,
    jboolean jstrict_capacity_limit) {
  auto* sptr_clock_cache =
      new std::shared_ptr<rocksdb::Cache>(rocksdb::NewClockCache(
          static_cast<size_t>(jcapacity),
          static_cast<int>(jnum_shard_bits),
          static_cast<bool>(jstrict_capacity_limit)));
  return reinterpret_cast<jlong>(sptr_clock_cache);
}

/*
 * Class:     org_rocksdb_ClockCache
 * Method:    disposeInternal
 * Signature: (J)V
 */
void Java_org_rocksdb_ClockCache_disposeInternal(
    JNIEnv* env, jobject jobj, jlong jhandle) {
  auto* sptr_clock_cache =
      reinterpret_cast<std::shared_ptr<rocksdb::Cache> *>(jhandle);
  delete sptr_clock_cache;  // delete std::shared_ptr
}


text:
struct sharedObjectsStruct shared;

void peg(client * c) {

	if (need_switch_statstics() == 0 && c->argc != 3) {
		addReplyErrorFormat(c, "wrong number of arguments for peg command , %d." , c->argc);

		return;
	}

	(void)create_counter(c->argv[1]->ptr);

	if (need_switch_statstics() == 0) {
		(void)peg_counter(c->argv[1]->ptr , atoi(c->argv[2]->ptr));

		addReply(c, shared.ok);
	} else {
		int ret = peg_counter(c->argv[1]->ptr , 1);
		robj * rsp = createStringObjectFromLongLong(ret);

		addReply(c,shared.colon);
		addReply(c,rsp);
		addReply(c,shared.crlf);

		decrRefCount(rsp);
	}
}


text:
extern IFileSystem *filesystem;

// NOTE: If CStringRegistry allowed storing arbitrary data, we could just use that.
// in this case we have the "isPrivate" member and the replacement rules
// (activityIndex can be reused by private activities), so a custom table is necessary
struct activitylist_t
{
	int					activityIndex;
	unsigned short		stringKey;
	short				isPrivate;
};

CUtlVector<activitylist_t> g_ActivityList;

static CUtlDict< CActivityRemapCache, int > m_ActivityRemapDatabase;

// This stores the actual activity names.  Also, the string ID in the registry is simply an index
// into the g_ActivityList array.
CStringRegistry	g_ActivityStrings;

// this is just here to accelerate adds
static int g_HighestActivity = 0;

int g_nActivityListVersion = 1;

void ActivityList_Init( void )
{
	g_HighestActivity = 0;
}

void ActivityList_Free( void )
{
	g_ActivityStrings.ClearStrings();
	g_ActivityList.Purge();
	m_ActivityRemapDatabase.Purge();

	// So studiohdrs can reindex activity indices
	++g_nActivityListVersion;
}

// add a new activity to the database
activitylist_t *ActivityList_AddActivityEntry( const char *pName, int iActivityIndex, bool isPrivate )
{
	MEM_ALLOC_CREDIT();
	int index = g_ActivityList.AddToTail();
	activitylist_t *pList = &g_ActivityList[index];
	pList->activityIndex = iActivityIndex;
	pList->stringKey = g_ActivityStrings.AddString( pName, index );
	pList->isPrivate = isPrivate;

	// UNDONE: This implies that ALL shared activities are added before ANY custom activities
	// UNDONE: Segment these instead?  It's a 32-bit int, how many activities do we need?
	if ( iActivityIndex > g_HighestActivity )
	{
		g_HighestActivity = iActivityIndex;
	}

	return pList;
}

// get the database entry from a string
static activitylist_t *ListFromString( const char *pString )
{
	// just use the string registry to do this search/map
	int stringID = g_ActivityStrings.GetStringID( pString );
	if ( stringID < 0 )
		return NULL;

	return &g_ActivityList[stringID];
}

// Get the database entry for an index
static activitylist_t *ListFromActivity( int activityIndex )
{
	// ugly linear search
	for ( int i = 0; i < g_ActivityList.Count(); i++ )
	{
		if ( g_ActivityList[i].activityIndex == activityIndex )
		{
			return &g_ActivityList[i];
		}
	}

	return NULL;
}

bool ActivityList_RegisterSharedActivity( const char *pszActivityName, int iActivityIndex )
{
	// UNDONE: Do we want to do these checks when not in developer mode? or maybe DEBUG only?
	// They really only matter when you change the list of code controlled activities.  IDs
	// for content controlled activities never collide because they are generated.

	// technically order isn't dependent, but it's too damn easy to forget to add new ACT_'s to all three lists.
	static int lastActivityIndex = -1;
	Assert( iActivityIndex < LAST_SHARED_ACTIVITY && (iActivityIndex == lastActivityIndex + 1 || iActivityIndex == 0) );
	lastActivityIndex = iActivityIndex;

	// first, check to make sure the slot we're asking for is free. It must be for
	// a shared activity.
	activitylist_t *pList = ListFromString( pszActivityName );
	if ( !pList )
	{
		pList = ListFromActivity( iActivityIndex );
	}

	if ( pList )
	{
		Warning( "***\nShared activity collision! %s<->%s\n***\n", pszActivityName, g_ActivityStrings.GetStringForKey( pList->stringKey ) );
		Assert(0);
		return false;
	}
	// ----------------------------------------------------------------

	ActivityList_AddActivityEntry( pszActivityName, iActivityIndex, false );
	return true;
}

Activity ActivityList_RegisterPrivateActivity( const char *pszActivityName )
{
	activitylist_t *pList = ListFromString( pszActivityName );
	if ( pList )
	{
		// this activity is already in the list. If the activity we collided with is also private,
		// then the collision is OK. Otherwise, it's a bug.
		if ( pList->isPrivate )
		{
			return (Activity)pList->activityIndex;
		}
		else
		{
			// this private activity collides with a shared activity. That is not allowed.
			Warning( "***\nShared<->Private Activity collision!\n***\n" );
			Assert(0);
			return ACT_INVALID;
		}
	}

	pList = ActivityList_AddActivityEntry( pszActivityName, g_HighestActivity+1, true );
	return (Activity)pList->activityIndex;
}

// Get the index for a given activity name
// Done at load time for all models
int ActivityList_IndexForName( const char *pszActivityName )
{
	// this is a fast O(lgn) search (actually does 2 O(lgn) searches)
	activitylist_t *pList = ListFromString( pszActivityName );

	if ( pList )
	{
		return pList->activityIndex;
	}

	return -1;
}

// Get the name for a given index
// This should only be used in debug code, it does a linear search
// But at least it only compares integers
const char *ActivityList_NameForIndex( int activityIndex )
{
	activitylist_t *pList = ListFromActivity( activityIndex );
	if ( pList )
	{
		return g_ActivityStrings.GetStringForKey( pList->stringKey );
	}
	return NULL;
}

void ActivityList_RegisterSharedActivities( void )
{
	REGISTER_SHARED_ACTIVITY( ACT_RESET );
	REGISTER_SHARED_ACTIVITY( ACT_IDLE );
	REGISTER_SHARED_ACTIVITY( ACT_TRANSITION );
	REGISTER_SHARED_ACTIVITY( ACT_COVER );
	REGISTER_SHARED_ACTIVITY( ACT_COVER_MED );
	REGISTER_SHARED_ACTIVITY( ACT_COVER_LOW );
	REGISTER_SHARED_ACTIVITY( ACT_WALK );
	REGISTER_SHARED_ACTIVITY( ACT_WALK_AIM );
	REGISTER_SHARED_ACTIVITY( ACT_WALK_CROUCH );
	REGISTER_SHARED_ACTIVITY( ACT_WALK_CROUCH_AIM );
	REGISTER_SHARED_ACTIVITY( ACT_RUN );
	REGISTER_SHARED_ACTIVITY( ACT_RUN_AIM );
	REGISTER_SHARED_ACTIVITY( ACT_RUN_CROUCH );
	REGISTER_SHARED_ACTIVITY( ACT_RUN_CROUCH_AIM );
	REGISTER_SHARED_ACTIVITY( ACT_RUN_PROTECTED );
	REGISTER_SHARED_ACTIVITY( ACT_SCRIPT_CUSTOM_MOVE );
	REGISTER_SHARED_ACTIVITY( ACT_RANGE_ATTACK1 );
	REGISTER_SHARED_ACTIVITY( ACT_RANGE_ATTACK2 );
	REGISTER_SHARED_ACTIVITY( ACT_RANGE_ATTACK1_LOW );
	REGISTER_SHARED_ACTIVITY( ACT_RANGE_ATTACK2_LOW );
	REGISTER_SHARED_ACTIVITY( ACT_DIESIMPLE );
	REGISTER_SHARED_ACTIVITY( ACT_DIEBACKWARD );
	REGISTER_SHARED_ACTIVITY( ACT_DIEFORWARD );
	REGISTER_SHARED_ACTIVITY( ACT_DIEVIOLENT );
	REGISTER_SHARED_ACTIVITY( ACT_DIERAGDOLL );
	REGISTER_SHARED_ACTIVITY( ACT_FLY );
	REGISTER_SHARED_ACTIVITY( ACT_HOVER );
	REGISTER_SHARED_ACTIVITY( ACT_GLIDE );
	REGISTER_SHARED_ACTIVITY( ACT_SWIM );
	REGISTER_SHARED_ACTIVITY( ACT_JUMP );
	REGISTER_SHARED_ACTIVITY( ACT_HOP );
	REGISTER_SHARED_ACTIVITY( ACT_LEAP );
	REGISTER_SHARED_ACTIVITY( ACT_LAND );
	REGISTER_SHARED_ACTIVITY( ACT_CLIMB_UP );
	REGISTER_SHARED_ACTIVITY( ACT_CLIMB_DOWN );
	REGISTER_SHARED_ACTIVITY( ACT_CLIMB_DISMOUNT );
	REGISTER_SHARED_ACTIVITY( ACT_SHIPLADDER_UP );
	REGISTER_SHARED_ACTIVITY( ACT_SHIPLADDER_DOWN );
	REGISTER_SHARED_ACTIVITY( ACT_STRAFE_LEFT );
	REGISTER_SHARED_ACTIVITY( ACT_STRAFE_RIGHT );
	REGISTER_SHARED_ACTIVITY( ACT_ROLL_LEFT );
	REGISTER_SHARED_ACTIVITY( ACT_ROLL_RIGHT );
	REGISTER_SHARED_ACTIVITY( ACT_TURN_LEFT );
	REGISTER_SHARED_ACTIVITY( ACT_TURN_RIGHT );
	REGISTER_SHARED_ACTIVITY( ACT_CROUCH );
	REGISTER_SHARED_ACTIVITY( ACT_CROUCHIDLE );
	REGISTER_SHARED_ACTIVITY( ACT_STAND );
	REGISTER_SHARED_ACTIVITY( ACT_USE );
	REGISTER_SHARED_ACTIVITY( ACT_ALIEN_BURROW_IDLE );
	REGISTER_SHARED_ACTIVITY( ACT_ALIEN_BURROW_OUT );
	REGISTER_SHARED_ACTIVITY( ACT_SIGNAL1 );
	REGISTER_SHARED_ACTIVITY( ACT_SIGNAL2 );
	REGISTER_SHARED_ACTIVITY( ACT_SIGNAL3 );

	REGISTER_SHARED_ACTIVITY( ACT_SIGNAL_ADVANCE );
	REGISTER_SHARED_ACTIVITY( ACT_SIGNAL_FORWARD );
	REGISTER_SHARED_ACTIVITY( ACT_SIGNAL_GROUP );
	REGISTER_SHARED_ACTIVITY( ACT_SIGNAL_HALT );
	REGISTER_SHARED_ACTIVITY( ACT_SIGNAL_LEFT );
	REGISTER_SHARED_ACTIVITY( ACT_SIGNAL_RIGHT );
	REGISTER_SHARED_ACTIVITY( ACT_SIGNAL_TAKECOVER );

	REGISTER_SHARED_ACTIVITY( ACT_LOOKBACK_RIGHT );
	REGISTER_SHARED_ACTIVITY( ACT_LOOKBACK_LEFT );
	REGISTER_SHARED_ACTIVITY( ACT_COWER );
	REGISTER_SHARED_ACTIVITY( ACT_SMALL_FLINCH );
	REGISTER_SHARED_ACTIVITY( ACT_BIG_FLINCH );
	REGISTER_SHARED_ACTIVITY( ACT_MELEE_ATTACK1 );
	REGISTER_SHARED_ACTIVITY( ACT_MELEE_ATTACK2 );
	REGISTER_SHARED_ACTIVITY( ACT_RELOAD );
	REGISTER_SHARED_ACTIVITY( ACT_RELOAD_START );
	REGISTER_SHARED_ACTIVITY( ACT_RELOAD_FINISH );
	REGISTER_SHARED_ACTIVITY( ACT_RELOAD_LOW );
	REGISTER_SHARED_ACTIVITY( ACT_ARM );
	REGISTER_SHARED_ACTIVITY( ACT_DISARM );

	REGISTER_SHARED_ACTIVITY( ACT_DROP_WEAPON );
	REGISTER_SHARED_ACTIVITY( ACT_DROP_WEAPON_SHOTGUN );

	REGISTER_SHARED_ACTIVITY( ACT_PICKUP_GROUND );
	REGISTER_SHARED_ACTIVITY( ACT_PICKUP_RACK );
	REGISTER_SHARED_ACTIVITY( ACT_IDLE_ANGRY );

	REGISTER_SHARED_ACTIVITY( ACT_IDLE_RELAXED );
	REGISTER_SHARED_ACTIVITY( ACT_IDLE_STIMULATED );
	REGISTER_SHARED_ACTIVITY( ACT_IDLE_AGITATED );
	REGISTER_SHARED_ACTIVITY( ACT_IDLE_STEALTH );
	REGISTER_SHARED_ACTIVITY( ACT_IDLE_HURT );

	REGISTER_SHARED_ACTIVITY( ACT_WALK_RELAXED );
	REGISTER_SHARED_ACTIVITY( ACT_WALK_STIMULATED );
	REGISTER_SHARED_ACTIVITY( ACT_WALK_AGITATED );
	REGISTER_SHARED_ACTIVITY( ACT_WALK_STEALTH );

	REGISTER_SHARED_ACTIVITY( ACT_RUN_RELAXED );
	REGISTER_SHARED_ACTIVITY( ACT_RUN_STIMULATED );
	REGISTER_SHARED_ACTIVITY( ACT_RUN_AGITATED );
	REGISTER_SHARED_ACTIVITY( ACT_RUN_STEALTH );

	REGISTER_SHARED_ACTIVITY( ACT_IDLE_AIM_RELAXED );
	REGISTER_SHARED_ACTIVITY( ACT_IDLE_AIM_STIMULATED );
	REGISTER_SHARED_ACTIVITY( ACT_IDLE_AIM_AGITATED );
	REGISTER_SHARED_ACTIVITY( ACT_IDLE_AIM_STEALTH );

	REGISTER_SHARED_ACTIVITY( ACT_WALK_AIM_RELAXED );
	REGISTER_SHARED_ACTIVITY( ACT_WALK_AIM_STIMULATED );
	REGISTER_SHARED_ACTIVITY( ACT_WALK_AIM_AGITATED );
	REGISTER_SHARED_ACTIVITY( ACT_WALK_AIM_STEALTH );

	REGISTER_SHARED_ACTIVITY( ACT_RUN_AIM_RELAXED );
	REGISTER_SHARED_ACTIVITY( ACT_RUN_AIM_STIMULATED );
	REGISTER_SHARED_ACTIVITY( ACT_RUN_AIM_AGITATED );
	REGISTER_SHARED_ACTIVITY( ACT_RUN_AIM_STEALTH );

	REGISTER_SHARED_ACTIVITY( ACT_CROUCHIDLE_STIMULATED );
	REGISTER_SHARED_ACTIVITY( ACT_CROUCHIDLE_AIM_STIMULATED );
	REGISTER_SHARED_ACTIVITY( ACT_CROUCHIDLE_AGITATED );

	REGISTER_SHARED_ACTIVITY( ACT_WALK_HURT );
	REGISTER_SHARED_ACTIVITY( ACT_RUN_HURT );
	REGISTER_SHARED_ACTIVITY( ACT_SPECIAL_ATTACK1 );
	REGISTER_SHARED_ACTIVITY( ACT_SPECIAL_ATTACK2 );
	REGISTER_SHARED_ACTIVITY( ACT_COMBAT_IDLE );
	REGISTER_SHARED_ACTIVITY( ACT_WALK_SCARED );
	REGISTER_SHARED_ACTIVITY( ACT_RUN_SCARED );
	REGISTER_SHARED_ACTIVITY( ACT_VICTORY_DANCE );

	REGISTER_SHARED_ACTIVITY( ACT_DIE_HEADSHOT );
	REGISTER_SHARED_ACTIVITY( ACT_DIE_CHESTSHOT );
	REGISTER_SHARED_ACTIVITY( ACT_DIE_GUTSHOT );
	REGISTER_SHARED_ACTIVITY( ACT_DIE_BACKSHOT );

	REGISTER_SHARED_ACTIVITY( ACT_FLINCH_HEAD );
	REGISTER_SHARED_ACTIVITY( ACT_FLINCH_CHEST );
	REGISTER_SHARED_ACTIVITY( ACT_FLINCH_STOMACH );
	REGISTER_SHARED_ACTIVITY( ACT_FLINCH_LEFTARM );
	REGISTER_SHARED_ACTIVITY( ACT_FLINCH_RIGHTARM );
	REGISTER_SHARED_ACTIVITY( ACT_FLINCH_LEFTLEG );
	REGISTER_SHARED_ACTIVITY( ACT_FLINCH_RIGHTLEG );
	REGISTER_SHARED_ACTIVITY( ACT_FLINCH_PHYSICS );

	REGISTER_SHARED_ACTIVITY( ACT_FLINCH_HEAD_BACK );
	REGISTER_SHARED_ACTIVITY( ACT_FLINCH_CHEST_BACK );
	REGISTER_SHARED_ACTIVITY( ACT_FLINCH_STOMACH_BACK );
	REGISTER_SHARED_ACTIVITY( ACT_FLINCH_CROUCH_FRONT );
	REGISTER_SHARED_ACTIVITY( ACT_FLINCH_CROUCH_BACK );
	REGISTER_SHARED_ACTIVITY( ACT_FLINCH_CROUCH_LEFT );
	REGISTER_SHARED_ACTIVITY( ACT_FLINCH_CROUCH_RIGHT );

	REGISTER_SHARED_ACTIVITY( ACT_IDLE_ON_FIRE );
	REGISTER_SHARED_ACTIVITY( ACT_WALK_ON_FIRE );
	REGISTER_SHARED_ACTIVITY( ACT_RUN_ON_FIRE );

	REGISTER_SHARED_ACTIVITY( ACT_RAPPEL_LOOP );

	REGISTER_SHARED_ACTIVITY( ACT_180_LEFT );
	REGISTER_SHARED_ACTIVITY( ACT_180_RIGHT );
	REGISTER_SHARED_ACTIVITY( ACT_90_LEFT );
	REGISTER_SHARED_ACTIVITY( ACT_90_RIGHT );
	REGISTER_SHARED_ACTIVITY( ACT_STEP_LEFT );
	REGISTER_SHARED_ACTIVITY( ACT_STEP_RIGHT );
	REGISTER_SHARED_ACTIVITY( ACT_STEP_BACK );
	REGISTER_SHARED_ACTIVITY( ACT_STEP_FORE );

	REGISTER_SHARED_ACTIVITY( ACT_GESTURE_RANGE_ATTACK1 );
	REGISTER_SHARED_ACTIVITY( ACT_GESTURE_RANGE_ATTACK2 );
	REGISTER_SHARED_ACTIVITY( ACT_GESTURE_MELEE_ATTACK1 );
	REGISTER_SHARED_ACTIVITY( ACT_GESTURE_MELEE_ATTACK2 );
	REGISTER_SHARED_ACTIVITY( ACT_GESTURE_RANGE_ATTACK1_LOW );
	REGISTER_SHARED_ACTIVITY( ACT_GESTURE_RANGE_ATTACK2_LOW );
	REGISTER_SHARED_ACTIVITY( ACT_MELEE_ATTACK_SWING_GESTURE );

	REGISTER_SHARED_ACTIVITY( ACT_GESTURE_SMALL_FLINCH );
	REGISTER_SHARED_ACTIVITY( ACT_GESTURE_BIG_FLINCH );
	REGISTER_SHARED_ACTIVITY( ACT_GESTURE_FLINCH_BLAST );
	REGISTER_SHARED_ACTIVITY( ACT_GESTURE_FLINCH_BLAST_SHOTGUN );
	REGISTER_SHARED_ACTIVITY( ACT_GESTURE_FLINCH_BLAST_DAMAGED );
	REGISTER_SHARED_ACTIVITY( ACT_GESTURE_FLINCH_BLAST_DAMAGED_SHOTGUN );
	REGISTER_SHARED_ACTIVITY( ACT_GESTURE_FLINCH_HEAD );
	REGISTER_SHARED_ACTIVITY( ACT_GESTURE_FLINCH_CHEST );
	REGISTER_SHARED_ACTIVITY( ACT_GESTURE_FLINCH_STOMACH );
	REGISTER_SHARED_ACTIVITY( ACT_GESTURE_FLINCH_LEFTARM );
	REGISTER_SHARED_ACTIVITY( ACT_GESTURE_FLINCH_RIGHTARM );
	REGISTER_SHARED_ACTIVITY( ACT_GESTURE_FLINCH_LEFTLEG );
	REGISTER_SHARED_ACTIVITY( ACT_GESTURE_FLINCH_RIGHTLEG );

	REGISTER_SHARED_ACTIVITY( ACT_GESTURE_TURN_LEFT );
	REGISTER_SHARED_ACTIVITY( ACT_GESTURE_TURN_RIGHT );
	REGISTER_SHARED_ACTIVITY( ACT_GESTURE_TURN_LEFT45 );
	REGISTER_SHARED_ACTIVITY( ACT_GESTURE_TURN_RIGHT45 );
	REGISTER_SHARED_ACTIVITY( ACT_GESTURE_TURN_LEFT90 );
	REGISTER_SHARED_ACTIVITY( ACT_GESTURE_TURN_RIGHT90 );
	REGISTER_SHARED_ACTIVITY( ACT_GESTURE_TURN_LEFT45_FLAT );
	REGISTER_SHARED_ACTIVITY( ACT_GESTURE_TURN_RIGHT45_FLAT );
	REGISTER_SHARED_ACTIVITY( ACT_GESTURE_TURN_LEFT90_FLAT );
	REGISTER_SHARED_ACTIVITY( ACT_GESTURE_TURN_RIGHT90_FLAT );

	// registered for Half-Life HGRUNT compatability
	REGISTER_SHARED_ACTIVITY( ACT_BARNACLE_HIT );
	REGISTER_SHARED_ACTIVITY( ACT_BARNACLE_PULL );
	REGISTER_SHARED_ACTIVITY( ACT_BARNACLE_CHOMP );
	REGISTER_SHARED_ACTIVITY( ACT_BARNACLE_CHEW );

	REGISTER_SHARED_ACTIVITY( ACT_DO_NOT_DISTURB );
	REGISTER_SHARED_ACTIVITY( ACT_SPECIFIC_SEQUENCE );

	// Viewmodel activities may belong elsewhere, but since where is unclear right now,
	// they'll be placed here.
	REGISTER_SHARED_ACTIVITY( ACT_VM_DRAW );
	REGISTER_SHARED_ACTIVITY( ACT_VM_HOLSTER );
	REGISTER_SHARED_ACTIVITY( ACT_VM_IDLE );
	REGISTER_SHARED_ACTIVITY( ACT_VM_FIDGET );
	REGISTER_SHARED_ACTIVITY( ACT_VM_PULLBACK );
	REGISTER_SHARED_ACTIVITY( ACT_VM_PULLBACK_HIGH );
	REGISTER_SHARED_ACTIVITY( ACT_VM_PULLBACK_LOW );
	REGISTER_SHARED_ACTIVITY( ACT_VM_THROW );
	REGISTER_SHARED_ACTIVITY( ACT_VM_PULLPIN );
	REGISTER_SHARED_ACTIVITY( ACT_VM_PRIMARYATTACK );
	REGISTER_SHARED_ACTIVITY( ACT_VM_SECONDARYATTACK );
	REGISTER_SHARED_ACTIVITY( ACT_VM_RELOAD );
	REGISTER_SHARED_ACTIVITY( ACT_VM_DRYFIRE );
	REGISTER_SHARED_ACTIVITY( ACT_VM_HITLEFT );
	REGISTER_SHARED_ACTIVITY( ACT_VM_HITLEFT2 );
	REGISTER_SHARED_ACTIVITY( ACT_VM_HITRIGHT );
	REGISTER_SHARED_ACTIVITY( ACT_VM_HITRIGHT2 );
	REGISTER_SHARED_ACTIVITY( ACT_VM_HITCENTER );
	REGISTER_SHARED_ACTIVITY( ACT_VM_HITCENTER2 );
	REGISTER_SHARED_ACTIVITY( ACT_VM_MISSLEFT );
	REGISTER_SHARED_ACTIVITY( ACT_VM_MISSLEFT2 );
	REGISTER_SHARED_ACTIVITY( ACT_VM_MISSRIGHT );
	REGISTER_SHARED_ACTIVITY( ACT_VM_MISSRIGHT2 );
	REGISTER_SHARED_ACTIVITY( ACT_VM_MISSCENTER );
	REGISTER_SHARED_ACTIVITY( ACT_VM_MISSCENTER2 );
	REGISTER_SHARED_ACTIVITY( ACT_VM_HAULBACK );
	REGISTER_SHARED_ACTIVITY( ACT_VM_SWINGHARD );
	REGISTER_SHARED_ACTIVITY( ACT_VM_SWINGMISS );
	REGISTER_SHARED_ACTIVITY( ACT_VM_SWINGHIT );
	REGISTER_SHARED_ACTIVITY( ACT_VM_IDLE_TO_LOWERED );
	REGISTER_SHARED_ACTIVITY( ACT_VM_IDLE_LOWERED );
	REGISTER_SHARED_ACTIVITY( ACT_VM_LOWERED_TO_IDLE );
	REGISTER_SHARED_ACTIVITY( ACT_VM_RECOIL1 );
	REGISTER_SHARED_ACTIVITY( ACT_VM_RECOIL2 );
	REGISTER_SHARED_ACTIVITY( ACT_VM_RECOIL3 );
	REGISTER_SHARED_ACTIVITY( ACT_VM_PICKUP );
	REGISTER_SHARED_ACTIVITY( ACT_VM_RELEASE );

	REGISTER_SHARED_ACTIVITY ( ACT_VM_ATTACH_SILENCER );
	REGISTER_SHARED_ACTIVITY ( ACT_VM_DETACH_SILENCER );

//===========================
// HL2 Specific Activities
//===========================
	// SLAM Specialty Activites
	REGISTER_SHARED_ACTIVITY( ACT_SLAM_STICKWALL_IDLE);
	REGISTER_SHARED_ACTIVITY( ACT_SLAM_STICKWALL_ND_IDLE);
	REGISTER_SHARED_ACTIVITY( ACT_SLAM_STICKWALL_ATTACH);
	REGISTER_SHARED_ACTIVITY( ACT_SLAM_STICKWALL_ATTACH2);
	REGISTER_SHARED_ACTIVITY( ACT_SLAM_STICKWALL_ND_ATTACH);
	REGISTER_SHARED_ACTIVITY( ACT_SLAM_STICKWALL_ND_ATTACH2);
	REGISTER_SHARED_ACTIVITY( ACT_SLAM_STICKWALL_DETONATE);
	REGISTER_SHARED_ACTIVITY( ACT_SLAM_STICKWALL_DETONATOR_HOLSTER);
	REGISTER_SHARED_ACTIVITY( ACT_SLAM_STICKWALL_DRAW);
  	REGISTER_SHARED_ACTIVITY( ACT_SLAM_STICKWALL_ND_DRAW);
  	REGISTER_SHARED_ACTIVITY( ACT_SLAM_STICKWALL_TO_THROW);
  	REGISTER_SHARED_ACTIVITY( ACT_SLAM_STICKWALL_TO_THROW_ND);
	REGISTER_SHARED_ACTIVITY( ACT_SLAM_STICKWALL_TO_TRIPMINE_ND );
  	REGISTER_SHARED_ACTIVITY( ACT_SLAM_THROW_IDLE);
	REGISTER_SHARED_ACTIVITY( ACT_SLAM_THROW_ND_IDLE);
	REGISTER_SHARED_ACTIVITY( ACT_SLAM_THROW_THROW);
	REGISTER_SHARED_ACTIVITY( ACT_SLAM_THROW_THROW2);
	REGISTER_SHARED_ACTIVITY( ACT_SLAM_THROW_THROW_ND);
	REGISTER_SHARED_ACTIVITY( ACT_SLAM_THROW_THROW_ND2);
	REGISTER_SHARED_ACTIVITY( ACT_SLAM_THROW_DRAW);
  	REGISTER_SHARED_ACTIVITY( ACT_SLAM_THROW_ND_DRAW);
  	REGISTER_SHARED_ACTIVITY( ACT_SLAM_THROW_TO_STICKWALL);
  	REGISTER_SHARED_ACTIVITY( ACT_SLAM_THROW_TO_STICKWALL_ND);
	REGISTER_SHARED_ACTIVITY( ACT_SLAM_THROW_DETONATE);
	REGISTER_SHARED_ACTIVITY( ACT_SLAM_THROW_DETONATOR_HOLSTER);
	REGISTER_SHARED_ACTIVITY( ACT_SLAM_THROW_TO_TRIPMINE_ND );
  	REGISTER_SHARED_ACTIVITY( ACT_SLAM_TRIPMINE_IDLE);
  	REGISTER_SHARED_ACTIVITY( ACT_SLAM_TRIPMINE_DRAW);
  	REGISTER_SHARED_ACTIVITY( ACT_SLAM_TRIPMINE_ATTACH);
  	REGISTER_SHARED_ACTIVITY( ACT_SLAM_TRIPMINE_ATTACH2);
	REGISTER_SHARED_ACTIVITY( ACT_SLAM_TRIPMINE_TO_STICKWALL_ND );
	REGISTER_SHARED_ACTIVITY( ACT_SLAM_TRIPMINE_TO_THROW_ND );
  	REGISTER_SHARED_ACTIVITY( ACT_SLAM_DETONATOR_IDLE);
  	REGISTER_SHARED_ACTIVITY( ACT_SLAM_DETONATOR_DRAW);
  	REGISTER_SHARED_ACTIVITY( ACT_SLAM_DETONATOR_DETONATE);
  	REGISTER_SHARED_ACTIVITY( ACT_SLAM_DETONATOR_HOLSTER);
  	REGISTER_SHARED_ACTIVITY( ACT_SLAM_DETONATOR_STICKWALL_DRAW);
  	REGISTER_SHARED_ACTIVITY( ACT_SLAM_DETONATOR_THROW_DRAW);

	// SHOTGUN specialty activities
	REGISTER_SHARED_ACTIVITY( ACT_SHOTGUN_RELOAD_START);
	REGISTER_SHARED_ACTIVITY( ACT_SHOTGUN_RELOAD_FINISH);
	REGISTER_SHARED_ACTIVITY( ACT_SHOTGUN_PUMP);

	// SMG2 special activities
	REGISTER_SHARED_ACTIVITY( ACT_SMG2_IDLE2 );
	REGISTER_SHARED_ACTIVITY( ACT_SMG2_FIRE2 );
	REGISTER_SHARED_ACTIVITY( ACT_SMG2_DRAW2 );
	REGISTER_SHARED_ACTIVITY( ACT_SMG2_RELOAD2 );
	REGISTER_SHARED_ACTIVITY( ACT_SMG2_DRYFIRE2 );
	REGISTER_SHARED_ACTIVITY( ACT_SMG2_TOAUTO );
	REGISTER_SHARED_ACTIVITY( ACT_SMG2_TOBURST );

	// Physcannon special activities
	REGISTER_SHARED_ACTIVITY( ACT_PHYSCANNON_UPGRADE );

	// weapon override activities
	REGISTER_SHARED_ACTIVITY( ACT_RANGE_ATTACK_AR1 );
	REGISTER_SHARED_ACTIVITY( ACT_RANGE_ATTACK_AR2 );
	REGISTER_SHARED_ACTIVITY( ACT_RANGE_ATTACK_AR2_LOW );
	REGISTER_SHARED_ACTIVITY( ACT_RANGE_ATTACK_AR2_GRENADE );
	REGISTER_SHARED_ACTIVITY( ACT_RANGE_ATTACK_HMG1 );
	REGISTER_SHARED_ACTIVITY( ACT_RANGE_ATTACK_ML );
	REGISTER_SHARED_ACTIVITY( ACT_RANGE_ATTACK_SMG1 );
	REGISTER_SHARED_ACTIVITY( ACT_RANGE_ATTACK_SMG1_LOW );
	REGISTER_SHARED_ACTIVITY( ACT_RANGE_ATTACK_SMG2 );
	REGISTER_SHARED_ACTIVITY( ACT_RANGE_ATTACK_SHOTGUN );
	REGISTER_SHARED_ACTIVITY( ACT_RANGE_ATTACK_SHOTGUN_LOW );
	REGISTER_SHARED_ACTIVITY( ACT_RANGE_ATTACK_PISTOL );
	REGISTER_SHARED_ACTIVITY( ACT_RANGE_ATTACK_PISTOL_LOW );
	REGISTER_SHARED_ACTIVITY( ACT_RANGE_ATTACK_SLAM );
	REGISTER_SHARED_ACTIVITY( ACT_RANGE_ATTACK_TRIPWIRE );
	REGISTER_SHARED_ACTIVITY( ACT_RANGE_ATTACK_THROW );
	REGISTER_SHARED_ACTIVITY( ACT_RANGE_ATTACK_SNIPER_RIFLE );
	REGISTER_SHARED_ACTIVITY( ACT_RANGE_ATTACK_RPG );
	REGISTER_SHARED_ACTIVITY( ACT_MELEE_ATTACK_SWING );

	REGISTER_SHARED_ACTIVITY( ACT_RANGE_AIM_LOW );
	REGISTER_SHARED_ACTIVITY( ACT_RANGE_AIM_SMG1_LOW );
	REGISTER_SHARED_ACTIVITY( ACT_RANGE_AIM_PISTOL_LOW );
	REGISTER_SHARED_ACTIVITY( ACT_RANGE_AIM_AR2_LOW );

	REGISTER_SHARED_ACTIVITY( ACT_COVER_PISTOL_LOW );
	REGISTER_SHARED_ACTIVITY( ACT_COVER_SMG1_LOW );

	// weapon override activities
	REGISTER_SHARED_ACTIVITY( ACT_GESTURE_RANGE_ATTACK_AR1 );
	REGISTER_SHARED_ACTIVITY( ACT_GESTURE_RANGE_ATTACK_AR2 );
	REGISTER_SHARED_ACTIVITY( ACT_GESTURE_RANGE_ATTACK_AR2_GRENADE );
	REGISTER_SHARED_ACTIVITY( ACT_GESTURE_RANGE_ATTACK_HMG1 );
	REGISTER_SHARED_ACTIVITY( ACT_GESTURE_RANGE_ATTACK_ML );
	REGISTER_SHARED_ACTIVITY( ACT_GESTURE_RANGE_ATTACK_SMG1 );
	REGISTER_SHARED_ACTIVITY( ACT_GESTURE_RANGE_ATTACK_SMG1_LOW );
	REGISTER_SHARED_ACTIVITY( ACT_GESTURE_RANGE_ATTACK_SMG2 );
	REGISTER_SHARED_ACTIVITY( ACT_GESTURE_RANGE_ATTACK_SHOTGUN );
	REGISTER_SHARED_ACTIVITY( ACT_GESTURE_RANGE_ATTACK_PISTOL );
	REGISTER_SHARED_ACTIVITY( ACT_GESTURE_RANGE_ATTACK_PISTOL_LOW );
	REGISTER_SHARED_ACTIVITY( ACT_GESTURE_RANGE_ATTACK_SLAM );
	REGISTER_SHARED_ACTIVITY( ACT_GESTURE_RANGE_ATTACK_TRIPWIRE );
	REGISTER_SHARED_ACTIVITY( ACT_GESTURE_RANGE_ATTACK_THROW );
	REGISTER_SHARED_ACTIVITY( ACT_GESTURE_RANGE_ATTACK_SNIPER_RIFLE );
	REGISTER_SHARED_ACTIVITY( ACT_GESTURE_MELEE_ATTACK_SWING );

	REGISTER_SHARED_ACTIVITY( ACT_IDLE_RIFLE );
	REGISTER_SHARED_ACTIVITY( ACT_IDLE_SMG1 );
	REGISTER_SHARED_ACTIVITY( ACT_IDLE_ANGRY_SMG1 );
	REGISTER_SHARED_ACTIVITY( ACT_IDLE_PISTOL );
	REGISTER_SHARED_ACTIVITY( ACT_IDLE_ANGRY_PISTOL );
	REGISTER_SHARED_ACTIVITY( ACT_IDLE_ANGRY_SHOTGUN );
	REGISTER_SHARED_ACTIVITY( ACT_IDLE_STEALTH_PISTOL );

	REGISTER_SHARED_ACTIVITY( ACT_IDLE_PACKAGE );
	REGISTER_SHARED_ACTIVITY( ACT_WALK_PACKAGE );
	REGISTER_SHARED_ACTIVITY( ACT_IDLE_SUITCASE );
	REGISTER_SHARED_ACTIVITY( ACT_WALK_SUITCASE );

	REGISTER_SHARED_ACTIVITY( ACT_IDLE_SMG1_RELAXED );
	REGISTER_SHARED_ACTIVITY( ACT_IDLE_SMG1_STIMULATED );

	REGISTER_SHARED_ACTIVITY( ACT_WALK_RIFLE_RELAXED );
	REGISTER_SHARED_ACTIVITY( ACT_RUN_RIFLE_RELAXED );
	REGISTER_SHARED_ACTIVITY( ACT_WALK_RIFLE_STIMULATED );
	REGISTER_SHARED_ACTIVITY( ACT_RUN_RIFLE_STIMULATED );

	REGISTER_SHARED_ACTIVITY( ACT_IDLE_AIM_RIFLE_STIMULATED );
	REGISTER_SHARED_ACTIVITY( ACT_WALK_AIM_RIFLE_STIMULATED );
	REGISTER_SHARED_ACTIVITY( ACT_RUN_AIM_RIFLE_STIMULATED );

	REGISTER_SHARED_ACTIVITY( ACT_IDLE_SHOTGUN_RELAXED );
	REGISTER_SHARED_ACTIVITY( ACT_IDLE_SHOTGUN_STIMULATED );
	REGISTER_SHARED_ACTIVITY( ACT_IDLE_SHOTGUN_AGITATED );

	// Policing activities
	REGISTER_SHARED_ACTIVITY( ACT_WALK_ANGRY );
	REGISTER_SHARED_ACTIVITY( ACT_POLICE_HARASS1 );
	REGISTER_SHARED_ACTIVITY( ACT_POLICE_HARASS2 );

	// Manned guns
	REGISTER_SHARED_ACTIVITY( ACT_IDLE_MANNEDGUN );

	// Melee weapon activities
	REGISTER_SHARED_ACTIVITY( ACT_IDLE_MELEE );
	REGISTER_SHARED_ACTIVITY( ACT_IDLE_ANGRY_MELEE );

	// RPG activities
	REGISTER_SHARED_ACTIVITY( ACT_IDLE_RPG_RELAXED );
	REGISTER_SHARED_ACTIVITY( ACT_IDLE_RPG );
	REGISTER_SHARED_ACTIVITY( ACT_IDLE_ANGRY_RPG );
	REGISTER_SHARED_ACTIVITY( ACT_COVER_LOW_RPG );
	REGISTER_SHARED_ACTIVITY( ACT_WALK_RPG );
	REGISTER_SHARED_ACTIVITY( ACT_RUN_RPG );
	REGISTER_SHARED_ACTIVITY( ACT_WALK_CROUCH_RPG );
	REGISTER_SHARED_ACTIVITY( ACT_RUN_CROUCH_RPG );
	REGISTER_SHARED_ACTIVITY( ACT_WALK_RPG_RELAXED );
	REGISTER_SHARED_ACTIVITY( ACT_RUN_RPG_RELAXED );

	REGISTER_SHARED_ACTIVITY( ACT_WALK_RIFLE );
	REGISTER_SHARED_ACTIVITY( ACT_WALK_AIM_RIFLE );
	REGISTER_SHARED_ACTIVITY( ACT_WALK_CROUCH_RIFLE );
	REGISTER_SHARED_ACTIVITY( ACT_WALK_CROUCH_AIM_RIFLE );
	REGISTER_SHARED_ACTIVITY( ACT_RUN_RIFLE );
	REGISTER_SHARED_ACTIVITY( ACT_RUN_AIM_RIFLE );
	REGISTER_SHARED_ACTIVITY( ACT_RUN_CROUCH_RIFLE );
	REGISTER_SHARED_ACTIVITY( ACT_RUN_CROUCH_AIM_RIFLE );
	REGISTER_SHARED_ACTIVITY( ACT_RUN_STEALTH_PISTOL );

	REGISTER_SHARED_ACTIVITY( ACT_WALK_AIM_SHOTGUN );
	REGISTER_SHARED_ACTIVITY( ACT_RUN_AIM_SHOTGUN );

	REGISTER_SHARED_ACTIVITY( ACT_WALK_PISTOL );
	REGISTER_SHARED_ACTIVITY( ACT_RUN_PISTOL );
	REGISTER_SHARED_ACTIVITY( ACT_WALK_AIM_PISTOL );
	REGISTER_SHARED_ACTIVITY( ACT_RUN_AIM_PISTOL );
	REGISTER_SHARED_ACTIVITY( ACT_WALK_STEALTH_PISTOL );
	REGISTER_SHARED_ACTIVITY( ACT_WALK_AIM_STEALTH_PISTOL );
	REGISTER_SHARED_ACTIVITY( ACT_RUN_AIM_STEALTH_PISTOL );

	// Reloads
	REGISTER_SHARED_ACTIVITY( ACT_RELOAD_PISTOL );
	REGISTER_SHARED_ACTIVITY( ACT_RELOAD_PISTOL_LOW );
	REGISTER_SHARED_ACTIVITY( ACT_RELOAD_SMG1 );
	REGISTER_SHARED_ACTIVITY( ACT_RELOAD_SMG1_LOW );
	REGISTER_SHARED_ACTIVITY( ACT_RELOAD_SHOTGUN );
	REGISTER_SHARED_ACTIVITY( ACT_RELOAD_SHOTGUN_LOW );

	REGISTER_SHARED_ACTIVITY( ACT_GESTURE_RELOAD );
	REGISTER_SHARED_ACTIVITY( ACT_GESTURE_RELOAD_PISTOL );
	REGISTER_SHARED_ACTIVITY( ACT_GESTURE_RELOAD_SMG1 );
	REGISTER_SHARED_ACTIVITY( ACT_GESTURE_RELOAD_SHOTGUN );

	// Busy animations
	REGISTER_SHARED_ACTIVITY( ACT_BUSY_LEAN_LEFT );
	REGISTER_SHARED_ACTIVITY( ACT_BUSY_LEAN_LEFT_ENTRY );
	REGISTER_SHARED_ACTIVITY( ACT_BUSY_LEAN_LEFT_EXIT );
	REGISTER_SHARED_ACTIVITY( ACT_BUSY_LEAN_BACK );
	REGISTER_SHARED_ACTIVITY( ACT_BUSY_LEAN_BACK_ENTRY );
	REGISTER_SHARED_ACTIVITY( ACT_BUSY_LEAN_BACK_EXIT );
	REGISTER_SHARED_ACTIVITY( ACT_BUSY_SIT_GROUND );
	REGISTER_SHARED_ACTIVITY( ACT_BUSY_SIT_GROUND_ENTRY );
	REGISTER_SHARED_ACTIVITY( ACT_BUSY_SIT_GROUND_EXIT );
	REGISTER_SHARED_ACTIVITY( ACT_BUSY_SIT_CHAIR );
	REGISTER_SHARED_ACTIVITY( ACT_BUSY_SIT_CHAIR_ENTRY );
	REGISTER_SHARED_ACTIVITY( ACT_BUSY_SIT_CHAIR_EXIT );
	REGISTER_SHARED_ACTIVITY( ACT_BUSY_STAND );
	REGISTER_SHARED_ACTIVITY( ACT_BUSY_QUEUE );

	// Dodge animations
	REGISTER_SHARED_ACTIVITY( ACT_DUCK_DODGE );

	REGISTER_SHARED_ACTIVITY( ACT_DIE_BARNACLE_SWALLOW );
	REGISTER_SHARED_ACTIVITY( ACT_GESTURE_BARNACLE_STRANGLE );
	REGISTER_SHARED_ACTIVITY( ACT_PHYSCANNON_DETACH );
	REGISTER_SHARED_ACTIVITY( ACT_PHYSCANNON_ANIMATE );
	REGISTER_SHARED_ACTIVITY( ACT_PHYSCANNON_ANIMATE_PRE );
	REGISTER_SHARED_ACTIVITY( ACT_PHYSCANNON_ANIMATE_POST );

	REGISTER_SHARED_ACTIVITY( ACT_DIE_FRONTSIDE );
	REGISTER_SHARED_ACTIVITY( ACT_DIE_RIGHTSIDE );
	REGISTER_SHARED_ACTIVITY( ACT_DIE_BACKSIDE );
	REGISTER_SHARED_ACTIVITY( ACT_DIE_LEFTSIDE );

	REGISTER_SHARED_ACTIVITY( ACT_OPEN_DOOR );

	// Dynamic interactions
	REGISTER_SHARED_ACTIVITY( ACT_DI_ALYX_ZOMBIE_MELEE );
	REGISTER_SHARED_ACTIVITY( ACT_DI_ALYX_ZOMBIE_TORSO_MELEE );
	REGISTER_SHARED_ACTIVITY( ACT_DI_ALYX_HEADCRAB_MELEE );
	REGISTER_SHARED_ACTIVITY( ACT_DI_ALYX_ANTLION );
	REGISTER_SHARED_ACTIVITY( ACT_DI_ALYX_ZOMBIE_SHOTGUN64 );
	REGISTER_SHARED_ACTIVITY( ACT_DI_ALYX_ZOMBIE_SHOTGUN26 );

	//Readiness transitions
	REGISTER_SHARED_ACTIVITY( ACT_READINESS_RELAXED_TO_STIMULATED );
	REGISTER_SHARED_ACTIVITY( ACT_READINESS_RELAXED_TO_STIMULATED_WALK );
	REGISTER_SHARED_ACTIVITY( ACT_READINESS_AGITATED_TO_STIMULATED );
	REGISTER_SHARED_ACTIVITY( ACT_READINESS_STIMULATED_TO_RELAXED );

	REGISTER_SHARED_ACTIVITY( ACT_READINESS_PISTOL_RELAXED_TO_STIMULATED );
	REGISTER_SHARED_ACTIVITY( ACT_READINESS_PISTOL_RELAXED_TO_STIMULATED_WALK );
	REGISTER_SHARED_ACTIVITY( ACT_READINESS_PISTOL_AGITATED_TO_STIMULATED );
	REGISTER_SHARED_ACTIVITY( ACT_READINESS_PISTOL_STIMULATED_TO_RELAXED );

	REGISTER_SHARED_ACTIVITY( ACT_IDLE_CARRY );
	REGISTER_SHARED_ACTIVITY( ACT_WALK_CARRY );

//===========================
// TF2 Specific Activities
//===========================
	REGISTER_SHARED_ACTIVITY( ACT_STARTDYING );
	REGISTER_SHARED_ACTIVITY( ACT_DYINGLOOP );
	REGISTER_SHARED_ACTIVITY( ACT_DYINGTODEAD );
	REGISTER_SHARED_ACTIVITY( ACT_RIDE_MANNED_GUN );

	// All viewmodels
	REGISTER_SHARED_ACTIVITY( ACT_VM_SPRINT_ENTER );
	REGISTER_SHARED_ACTIVITY( ACT_VM_SPRINT_IDLE );
	REGISTER_SHARED_ACTIVITY( ACT_VM_SPRINT_LEAVE );

	// Looping weapon firing
	REGISTER_SHARED_ACTIVITY( ACT_FIRE_START );
	REGISTER_SHARED_ACTIVITY( ACT_FIRE_LOOP );
	REGISTER_SHARED_ACTIVITY( ACT_FIRE_END );

	// TF2
	REGISTER_SHARED_ACTIVITY( ACT_CROUCHING_GRENADEIDLE );
	REGISTER_SHARED_ACTIVITY( ACT_CROUCHING_GRENADEREADY );
	REGISTER_SHARED_ACTIVITY( ACT_CROUCHING_PRIMARYATTACK );
	REGISTER_SHARED_ACTIVITY( ACT_OVERLAY_GRENADEIDLE );
	REGISTER_SHARED_ACTIVITY( ACT_OVERLAY_GRENADEREADY );
	REGISTER_SHARED_ACTIVITY( ACT_OVERLAY_PRIMARYATTACK );
	REGISTER_SHARED_ACTIVITY( ACT_OVERLAY_SHIELD_UP );
	REGISTER_SHARED_ACTIVITY( ACT_OVERLAY_SHIELD_DOWN );
	REGISTER_SHARED_ACTIVITY( ACT_OVERLAY_SHIELD_UP_IDLE );
	REGISTER_SHARED_ACTIVITY( ACT_OVERLAY_SHIELD_ATTACK );
	REGISTER_SHARED_ACTIVITY( ACT_OVERLAY_SHIELD_KNOCKBACK );
	REGISTER_SHARED_ACTIVITY( ACT_SHIELD_UP );
	REGISTER_SHARED_ACTIVITY( ACT_SHIELD_DOWN );
	REGISTER_SHARED_ACTIVITY( ACT_SHIELD_UP_IDLE );
	REGISTER_SHARED_ACTIVITY( ACT_SHIELD_ATTACK );
	REGISTER_SHARED_ACTIVITY( ACT_SHIELD_KNOCKBACK );
	REGISTER_SHARED_ACTIVITY( ACT_CROUCHING_SHIELD_UP );
	REGISTER_SHARED_ACTIVITY( ACT_CROUCHING_SHIELD_DOWN );
	REGISTER_SHARED_ACTIVITY( ACT_CROUCHING_SHIELD_UP_IDLE );
	REGISTER_SHARED_ACTIVITY( ACT_CROUCHING_SHIELD_ATTACK );
	REGISTER_SHARED_ACTIVITY( ACT_CROUCHING_SHIELD_KNOCKBACK );

	REGISTER_SHARED_ACTIVITY( ACT_TURNRIGHT45 );
	REGISTER_SHARED_ACTIVITY( ACT_TURNLEFT45 );
	REGISTER_SHARED_ACTIVITY( ACT_TURN );

	REGISTER_SHARED_ACTIVITY( ACT_OBJ_ASSEMBLING );
	REGISTER_SHARED_ACTIVITY( ACT_OBJ_DISMANTLING );
	REGISTER_SHARED_ACTIVITY( ACT_OBJ_STARTUP );
	REGISTER_SHARED_ACTIVITY( ACT_OBJ_RUNNING );
	REGISTER_SHARED_ACTIVITY( ACT_OBJ_IDLE );
	REGISTER_SHARED_ACTIVITY( ACT_OBJ_PLACING );
	REGISTER_SHARED_ACTIVITY( ACT_OBJ_DETERIORATING );
	REGISTER_SHARED_ACTIVITY( ACT_OBJ_UPGRADING );

	// Deploy
	REGISTER_SHARED_ACTIVITY( ACT_DEPLOY );
	REGISTER_SHARED_ACTIVITY( ACT_DEPLOY_IDLE );
	REGISTER_SHARED_ACTIVITY( ACT_UNDEPLOY );

	// Crossbow
	REGISTER_SHARED_ACTIVITY( ACT_CROSSBOW_DRAW_UNLOADED );

	// Gauss
	REGISTER_SHARED_ACTIVITY( ACT_GAUSS_SPINUP );
	REGISTER_SHARED_ACTIVITY( ACT_GAUSS_SPINCYCLE );

//===========================
// CSPort Specific Activities
//===========================

	REGISTER_SHARED_ACTIVITY ( ACT_VM_PRIMARYATTACK_SILENCED );		// fire
	REGISTER_SHARED_ACTIVITY ( ACT_VM_RELOAD_SILENCED );
	REGISTER_SHARED_ACTIVITY ( ACT_VM_DRYFIRE_SILENCED );				// fire with no ammo loaded.
	REGISTER_SHARED_ACTIVITY ( ACT_VM_IDLE_SILENCED );
	REGISTER_SHARED_ACTIVITY ( ACT_VM_DRAW_SILENCED );

	REGISTER_SHARED_ACTIVITY ( ACT_VM_IDLE_EMPTY_LEFT );
	REGISTER_SHARED_ACTIVITY ( ACT_VM_DRYFIRE_LEFT );

	// new for CS2
	REGISTER_SHARED_ACTIVITY ( ACT_VM_IS_DRAW );
	REGISTER_SHARED_ACTIVITY ( ACT_VM_IS_HOLSTER );
	REGISTER_SHARED_ACTIVITY ( ACT_VM_IS_IDLE );
	REGISTER_SHARED_ACTIVITY ( ACT_VM_IS_PRIMARYATTACK );

	REGISTER_SHARED_ACTIVITY ( ACT_PLAYER_IDLE_FIRE );
	REGISTER_SHARED_ACTIVITY ( ACT_PLAYER_CROUCH_FIRE );
	REGISTER_SHARED_ACTIVITY ( ACT_PLAYER_CROUCH_WALK_FIRE );
	REGISTER_SHARED_ACTIVITY ( ACT_PLAYER_WALK_FIRE );
	REGISTER_SHARED_ACTIVITY ( ACT_PLAYER_RUN_FIRE );
	REGISTER_SHARED_ACTIVITY ( ACT_IDLETORUN );
	REGISTER_SHARED_ACTIVITY ( ACT_RUNTOIDLE );

	REGISTER_SHARED_ACTIVITY ( ACT_VM_DRAW_DEPLOYED );

	REGISTER_SHARED_ACTIVITY ( ACT_HL2MP_IDLE_MELEE );
	REGISTER_SHARED_ACTIVITY ( ACT_HL2MP_RUN_MELEE );
	REGISTER_SHARED_ACTIVITY ( ACT_HL2MP_IDLE_CROUCH_MELEE );
	REGISTER_SHARED_ACTIVITY ( ACT_HL2MP_WALK_CROUCH_MELEE );
	REGISTER_SHARED_ACTIVITY ( ACT_HL2MP_GESTURE_RANGE_ATTACK_MELEE );
	REGISTER_SHARED_ACTIVITY ( ACT_HL2MP_GESTURE_RELOAD_MELEE );
	REGISTER_SHARED_ACTIVITY ( ACT_HL2MP_JUMP_MELEE );

	// Portal
	REGISTER_SHARED_ACTIVITY ( ACT_VM_FIZZLE );

	// Multiplayer
	REGISTER_SHARED_ACTIVITY ( ACT_MP_STAND_IDLE );
	REGISTER_SHARED_ACTIVITY ( ACT_MP_CROUCH_IDLE );
	REGISTER_SHARED_ACTIVITY ( ACT_MP_CROUCH_DEPLOYED_IDLE );
	REGISTER_SHARED_ACTIVITY ( ACT_MP_CROUCH_DEPLOYED );
	REGISTER_SHARED_ACTIVITY ( ACT_MP_DEPLOYED_IDLE );
	REGISTER_SHARED_ACTIVITY ( ACT_MP_RUN );
	REGISTER_SHARED_ACTIVITY ( ACT_MP_WALK );
	REGISTER_SHARED_ACTIVITY ( ACT_MP_AIRWALK );
	REGISTER_SHARED_ACTIVITY ( ACT_MP_CROUCHWALK );
	REGISTER_SHARED_ACTIVITY ( ACT_MP_SPRINT );
	REGISTER_SHARED_ACTIVITY ( ACT_MP_JUMP );
	REGISTER_SHARED_ACTIVITY ( ACT_MP_JUMP_START );
	REGISTER_SHARED_ACTIVITY ( ACT_MP_JUMP_FLOAT );
	REGISTER_SHARED_ACTIVITY ( ACT_MP_JUMP_LAND );
	REGISTER_SHARED_ACTIVITY ( ACT_MP_DOUBLEJUMP );
	REGISTER_SHARED_ACTIVITY ( ACT_MP_SWIM );
	REGISTER_SHARED_ACTIVITY ( ACT_MP_DEPLOYED );
	REGISTER_SHARED_ACTIVITY ( ACT_MP_SWIM_DEPLOYED );
	REGISTER_SHARED_ACTIVITY ( ACT_MP_VCD );

	REGISTER_SHARED_ACTIVITY ( ACT_MP_ATTACK_STAND_PRIMARYFIRE );
	REGISTER_SHARED_ACTIVITY ( ACT_MP_ATTACK_STAND_PRIMARYFIRE_DEPLOYED );
	REGISTER_SHARED_ACTIVITY ( ACT_MP_ATTACK_STAND_SECONDARYFIRE );
	REGISTER_SHARED_ACTIVITY ( ACT_MP_ATTACK_STAND_GRENADE );
	REGISTER_SHARED_ACTIVITY ( ACT_MP_ATTACK_CROUCH_PRIMARYFIRE );
	REGISTER_SHARED_ACTIVITY ( ACT_MP_ATTACK_CROUCH_PRIMARYFIRE_DEPLOYED );
	REGISTER_SHARED_ACTIVITY ( ACT_MP_ATTACK_CROUCH_SECONDARYFIRE );
	REGISTER_SHARED_ACTIVITY ( ACT_MP_ATTACK_CROUCH_GRENADE );
	REGISTER_SHARED_ACTIVITY ( ACT_MP_ATTACK_SWIM_PRIMARYFIRE );
	REGISTER_SHARED_ACTIVITY ( ACT_MP_ATTACK_SWIM_SECONDARYFIRE );
	REGISTER_SHARED_ACTIVITY ( ACT_MP_ATTACK_SWIM_GRENADE );
	REGISTER_SHARED_ACTIVITY ( ACT_MP_ATTACK_AIRWALK_PRIMARYFIRE );
	REGISTER_SHARED_ACTIVITY ( ACT_MP_ATTACK_AIRWALK_SECONDARYFIRE );
	REGISTER_SHARED_ACTIVITY ( ACT_MP_ATTACK_AIRWALK_GRENADE );
	REGISTER_SHARED_ACTIVITY ( ACT_MP_RELOAD_STAND );
	REGISTER_SHARED_ACTIVITY ( ACT_MP_RELOAD_STAND_LOOP );
	REGISTER_SHARED_ACTIVITY ( ACT_MP_RELOAD_STAND_END );
	REGISTER_SHARED_ACTIVITY ( ACT_MP_RELOAD_CROUCH );
	REGISTER_SHARED_ACTIVITY ( ACT_MP_RELOAD_CROUCH_LOOP );
	REGISTER_SHARED_ACTIVITY ( ACT_MP_RELOAD_CROUCH_END );
	REGISTER_SHARED_ACTIVITY ( ACT_MP_RELOAD_SWIM );
	REGISTER_SHARED_ACTIVITY ( ACT_MP_RELOAD_SWIM_LOOP );
	REGISTER_SHARED_ACTIVITY ( ACT_MP_RELOAD_SWIM_END );
	REGISTER_SHARED_ACTIVITY ( ACT_MP_RELOAD_AIRWALK );
	REGISTER_SHARED_ACTIVITY ( ACT_MP_RELOAD_AIRWALK_LOOP );
	REGISTER_SHARED_ACTIVITY ( ACT_MP_RELOAD_AIRWALK_END );
	REGISTER_SHARED_ACTIVITY ( ACT_MP_ATTACK_STAND_PREFIRE );
	REGISTER_SHARED_ACTIVITY ( ACT_MP_ATTACK_STAND_POSTFIRE );
	REGISTER_SHARED_ACTIVITY ( ACT_MP_ATTACK_STAND_STARTFIRE );
	REGISTER_SHARED_ACTIVITY ( ACT_MP_ATTACK_CROUCH_PREFIRE );
	REGISTER_SHARED_ACTIVITY ( ACT_MP_ATTACK_CROUCH_POSTFIRE );
	REGISTER_SHARED_ACTIVITY ( ACT_MP_ATTACK_SWIM_PREFIRE );
	REGISTER_SHARED_ACTIVITY ( ACT_MP_ATTACK_SWIM_POSTFIRE );

	// Multiplayer - Primary
	REGISTER_SHARED_ACTIVITY ( ACT_MP_STAND_PRIMARY );
	REGISTER_SHARED_ACTIVITY ( ACT_MP_CROUCH_PRIMARY );
	REGISTER_SHARED_ACTIVITY ( ACT_MP_RUN_PRIMARY );
	REGISTER_SHARED_ACTIVITY ( ACT_MP_WALK_PRIMARY );
	REGISTER_SHARED_ACTIVITY ( ACT_MP_AIRWALK_PRIMARY );
	REGISTER_SHARED_ACTIVITY ( ACT_MP_CROUCHWALK_PRIMARY );
	REGISTER_SHARED_ACTIVITY ( ACT_MP_JUMP_PRIMARY );
	REGISTER_SHARED_ACTIVITY ( ACT_MP_JUMP_START_PRIMARY );
	REGISTER_SHARED_ACTIVITY ( ACT_MP_JUMP_FLOAT_PRIMARY );
	REGISTER_SHARED_ACTIVITY ( ACT_MP_JUMP_LAND_PRIMARY );
	REGISTER_SHARED_ACTIVITY ( ACT_MP_SWIM_PRIMARY );
	REGISTER_SHARED_ACTIVITY ( ACT_MP_DEPLOYED_PRIMARY );
	REGISTER_SHARED_ACTIVITY ( ACT_MP_SWIM_DEPLOYED_PRIMARY );

	REGISTER_SHARED_ACTIVITY ( ACT_MP_ATTACK_STAND_PRIMARY );
	REGISTER_SHARED_ACTIVITY ( ACT_MP_ATTACK_STAND_PRIMARY_DEPLOYED );
	REGISTER_SHARED_ACTIVITY ( ACT_MP_ATTACK_CROUCH_PRIMARY );
	REGISTER_SHARED_ACTIVITY ( ACT_MP_ATTACK_CROUCH_PRIMARY_DEPLOYED );
	REGISTER_SHARED_ACTIVITY ( ACT_MP_ATTACK_SWIM_PRIMARY );
	REGISTER_SHARED_ACTIVITY ( ACT_MP_ATTACK_AIRWALK_PRIMARY );

	REGISTER_SHARED_ACTIVITY ( ACT_MP_RELOAD_STAND_PRIMARY );
	REGISTER_SHARED_ACTIVITY ( ACT_MP_RELOAD_STAND_PRIMARY_LOOP );
	REGISTER_SHARED_ACTIVITY ( ACT_MP_RELOAD_STAND_PRIMARY_END );
	REGISTER_SHARED_ACTIVITY ( ACT_MP_RELOAD_CROUCH_PRIMARY );
	REGISTER_SHARED_ACTIVITY ( ACT_MP_RELOAD_CROUCH_PRIMARY_LOOP );
	REGISTER_SHARED_ACTIVITY ( ACT_MP_RELOAD_CROUCH_PRIMARY_END );
	REGISTER_SHARED_ACTIVITY ( ACT_MP_RELOAD_SWIM_PRIMARY );
	REGISTER_SHARED_ACTIVITY ( ACT_MP_RELOAD_SWIM_PRIMARY_LOOP );
	REGISTER_SHARED_ACTIVITY ( ACT_MP_RELOAD_SWIM_PRIMARY_END );
	REGISTER_SHARED_ACTIVITY ( ACT_MP_RELOAD_AIRWALK_PRIMARY );
	REGISTER_SHARED_ACTIVITY ( ACT_MP_RELOAD_AIRWALK_PRIMARY_LOOP );
	REGISTER_SHARED_ACTIVITY ( ACT_MP_RELOAD_AIRWALK_PRIMARY_END );

	REGISTER_SHARED_ACTIVITY ( ACT_MP_ATTACK_STAND_GRENADE_PRIMARY );
	REGISTER_SHARED_ACTIVITY ( ACT_MP_ATTACK_CROUCH_GRENADE_PRIMARY );
	REGISTER_SHARED_ACTIVITY ( ACT_MP_ATTACK_SWIM_GRENADE_PRIMARY );
	REGISTER_SHARED_ACTIVITY ( ACT_MP_ATTACK_AIRWALK_GRENADE_PRIMARY );

	// Secondary
	REGISTER_SHARED_ACTIVITY ( ACT_MP_STAND_SECONDARY );
	REGISTER_SHARED_ACTIVITY ( ACT_MP_CROUCH_SECONDARY );
	REGISTER_SHARED_ACTIVITY ( ACT_MP_RUN_SECONDARY );
	REGISTER_SHARED_ACTIVITY ( ACT_MP_WALK_SECONDARY );
	REGISTER_SHARED_ACTIVITY ( ACT_MP_AIRWALK_SECONDARY );
	REGISTER_SHARED_ACTIVITY ( ACT_MP_CROUCHWALK_SECONDARY );
	REGISTER_SHARED_ACTIVITY ( ACT_MP_JUMP_SECONDARY );
	REGISTER_SHARED_ACTIVITY ( ACT_MP_JUMP_START_SECONDARY );
	REGISTER_SHARED_ACTIVITY ( ACT_MP_JUMP_FLOAT_SECONDARY );
	REGISTER_SHARED_ACTIVITY ( ACT_MP_JUMP_LAND_SECONDARY );
	REGISTER_SHARED_ACTIVITY ( ACT_MP_SWIM_SECONDARY );

	REGISTER_SHARED_ACTIVITY ( ACT_MP_ATTACK_STAND_SECONDARY );
	REGISTER_SHARED_ACTIVITY ( ACT_MP_ATTACK_CROUCH_SECONDARY );
	REGISTER_SHARED_ACTIVITY ( ACT_MP_ATTACK_SWIM_SECONDARY );
	REGISTER_SHARED_ACTIVITY ( ACT_MP_ATTACK_AIRWALK_SECONDARY );

	REGISTER_SHARED_ACTIVITY ( ACT_MP_RELOAD_STAND_SECONDARY );
	REGISTER_SHARED_ACTIVITY ( ACT_MP_RELOAD_STAND_SECONDARY_LOOP );
	REGISTER_SHARED_ACTIVITY ( ACT_MP_RELOAD_STAND_SECONDARY_END );
	REGISTER_SHARED_ACTIVITY ( ACT_MP_RELOAD_CROUCH_SECONDARY );
	REGISTER_SHARED_ACTIVITY ( ACT_MP_RELOAD_CROUCH_SECONDARY_LOOP );
	REGISTER_SHARED_ACTIVITY ( ACT_MP_RELOAD_CROUCH_SECONDARY_END );
	REGISTER_SHARED_ACTIVITY ( ACT_MP_RELOAD_SWIM_SECONDARY );
	REGISTER_SHARED_ACTIVITY ( ACT_MP_RELOAD_SWIM_SECONDARY_LOOP );
	REGISTER_SHARED_ACTIVITY ( ACT_MP_RELOAD_SWIM_SECONDARY_END );
	REGISTER_SHARED_ACTIVITY ( ACT_MP_RELOAD_AIRWALK_SECONDARY );
	REGISTER_SHARED_ACTIVITY ( ACT_MP_RELOAD_AIRWALK_SECONDARY_LOOP );
	REGISTER_SHARED_ACTIVITY ( ACT_MP_RELOAD_AIRWALK_SECONDARY_END );

	REGISTER_SHARED_ACTIVITY ( ACT_MP_ATTACK_STAND_GRENADE_SECONDARY );
	REGISTER_SHARED_ACTIVITY ( ACT_MP_ATTACK_CROUCH_GRENADE_SECONDARY );
	REGISTER_SHARED_ACTIVITY ( ACT_MP_ATTACK_SWIM_GRENADE_SECONDARY );
	REGISTER_SHARED_ACTIVITY ( ACT_MP_ATTACK_AIRWALK_GRENADE_SECONDARY );

	// Melee
	REGISTER_SHARED_ACTIVITY ( ACT_MP_STAND_MELEE );
	REGISTER_SHARED_ACTIVITY ( ACT_MP_CROUCH_MELEE );
	REGISTER_SHARED_ACTIVITY ( ACT_MP_RUN_MELEE );
	REGISTER_SHARED_ACTIVITY ( ACT_MP_WALK_MELEE );
	REGISTER_SHARED_ACTIVITY ( ACT_MP_AIRWALK_MELEE );
	REGISTER_SHARED_ACTIVITY ( ACT_MP_CROUCHWALK_MELEE );
	REGISTER_SHARED_ACTIVITY ( ACT_MP_JUMP_MELEE );
	REGISTER_SHARED_ACTIVITY ( ACT_MP_JUMP_START_MELEE );
	REGISTER_SHARED_ACTIVITY ( ACT_MP_JUMP_FLOAT_MELEE );
	REGISTER_SHARED_ACTIVITY ( ACT_MP_JUMP_LAND_MELEE );
	REGISTER_SHARED_ACTIVITY ( ACT_MP_SWIM_MELEE );

	REGISTER_SHARED_ACTIVITY ( ACT_MP_ATTACK_STAND_MELEE );
	REGISTER_SHARED_ACTIVITY ( ACT_MP_ATTACK_STAND_MELEE_SECONDARY );
	REGISTER_SHARED_ACTIVITY ( ACT_MP_ATTACK_CROUCH_MELEE );
	REGISTER_SHARED_ACTIVITY ( ACT_MP_ATTACK_CROUCH_MELEE_SECONDARY );
	REGISTER_SHARED_ACTIVITY ( ACT_MP_ATTACK_SWIM_MELEE );
	REGISTER_SHARED_ACTIVITY ( ACT_MP_ATTACK_AIRWALK_MELEE );

	REGISTER_SHARED_ACTIVITY ( ACT_MP_ATTACK_STAND_GRENADE_MELEE );
	REGISTER_SHARED_ACTIVITY ( ACT_MP_ATTACK_CROUCH_GRENADE_MELEE );
	REGISTER_SHARED_ACTIVITY ( ACT_MP_ATTACK_SWIM_GRENADE_MELEE );
	REGISTER_SHARED_ACTIVITY ( ACT_MP_ATTACK_AIRWALK_GRENADE_MELEE );

	// Item1
	REGISTER_SHARED_ACTIVITY( ACT_MP_STAND_ITEM1 );
	REGISTER_SHARED_ACTIVITY( ACT_MP_CROUCH_ITEM1 );
	REGISTER_SHARED_ACTIVITY( ACT_MP_RUN_ITEM1 );
	REGISTER_SHARED_ACTIVITY( ACT_MP_WALK_ITEM1 );
	REGISTER_SHARED_ACTIVITY( ACT_MP_AIRWALK_ITEM1 );
	REGISTER_SHARED_ACTIVITY( ACT_MP_CROUCHWALK_ITEM1 );
	REGISTER_SHARED_ACTIVITY( ACT_MP_JUMP_ITEM1 );
	REGISTER_SHARED_ACTIVITY( ACT_MP_JUMP_START_ITEM1 );
	REGISTER_SHARED_ACTIVITY( ACT_MP_JUMP_FLOAT_ITEM1 );
	REGISTER_SHARED_ACTIVITY( ACT_MP_JUMP_LAND_ITEM1 );
	REGISTER_SHARED_ACTIVITY( ACT_MP_SWIM_ITEM1 );

	REGISTER_SHARED_ACTIVITY( ACT_MP_ATTACK_STAND_ITEM1 );
	REGISTER_SHARED_ACTIVITY( ACT_MP_ATTACK_STAND_ITEM1_SECONDARY );
	REGISTER_SHARED_ACTIVITY( ACT_MP_ATTACK_CROUCH_ITEM1 );
	REGISTER_SHARED_ACTIVITY( ACT_MP_ATTACK_CROUCH_ITEM1_SECONDARY );
	REGISTER_SHARED_ACTIVITY( ACT_MP_ATTACK_SWIM_ITEM1 );
	REGISTER_SHARED_ACTIVITY( ACT_MP_ATTACK_AIRWALK_ITEM1 );

	// Item2
	REGISTER_SHARED_ACTIVITY( ACT_MP_STAND_ITEM2 );
	REGISTER_SHARED_ACTIVITY( ACT_MP_CROUCH_ITEM2 );
	REGISTER_SHARED_ACTIVITY( ACT_MP_RUN_ITEM2 );
	REGISTER_SHARED_ACTIVITY( ACT_MP_WALK_ITEM2 );
	REGISTER_SHARED_ACTIVITY( ACT_MP_AIRWALK_ITEM2 );
	REGISTER_SHARED_ACTIVITY( ACT_MP_CROUCHWALK_ITEM2 );
	REGISTER_SHARED_ACTIVITY( ACT_MP_JUMP_ITEM2 );
	REGISTER_SHARED_ACTIVITY( ACT_MP_JUMP_START_ITEM2 );
	REGISTER_SHARED_ACTIVITY( ACT_MP_JUMP_FLOAT_ITEM2 );
	REGISTER_SHARED_ACTIVITY( ACT_MP_JUMP_LAND_ITEM2 );
	REGISTER_SHARED_ACTIVITY( ACT_MP_SWIM_ITEM2 );

	REGISTER_SHARED_ACTIVITY( ACT_MP_ATTACK_STAND_ITEM2 );
	REGISTER_SHARED_ACTIVITY( ACT_MP_ATTACK_STAND_ITEM2_SECONDARY );
	REGISTER_SHARED_ACTIVITY( ACT_MP_ATTACK_CROUCH_ITEM2 );
	REGISTER_SHARED_ACTIVITY( ACT_MP_ATTACK_CROUCH_ITEM2_SECONDARY );
	REGISTER_SHARED_ACTIVITY( ACT_MP_ATTACK_SWIM_ITEM2 );
	REGISTER_SHARED_ACTIVITY( ACT_MP_ATTACK_AIRWALK_ITEM2 );

	// Flinches
	REGISTER_SHARED_ACTIVITY( ACT_MP_GESTURE_FLINCH );
	REGISTER_SHARED_ACTIVITY( ACT_MP_GESTURE_FLINCH_PRIMARY );
	REGISTER_SHARED_ACTIVITY( ACT_MP_GESTURE_FLINCH_SECONDARY );
	REGISTER_SHARED_ACTIVITY( ACT_MP_GESTURE_FLINCH_MELEE );
	REGISTER_SHARED_ACTIVITY( ACT_MP_GESTURE_FLINCH_ITEM1 );
	REGISTER_SHARED_ACTIVITY( ACT_MP_GESTURE_FLINCH_ITEM2 );

	REGISTER_SHARED_ACTIVITY( ACT_MP_GESTURE_FLINCH_HEAD );
	REGISTER_SHARED_ACTIVITY( ACT_MP_GESTURE_FLINCH_CHEST );
	REGISTER_SHARED_ACTIVITY( ACT_MP_GESTURE_FLINCH_STOMACH );
	REGISTER_SHARED_ACTIVITY( ACT_MP_GESTURE_FLINCH_LEFTARM );
	REGISTER_SHARED_ACTIVITY( ACT_MP_GESTURE_FLINCH_RIGHTARM );
	REGISTER_SHARED_ACTIVITY( ACT_MP_GESTURE_FLINCH_LEFTLEG );
	REGISTER_SHARED_ACTIVITY( ACT_MP_GESTURE_FLINCH_RIGHTLEG );

	// TF Specific
	REGISTER_SHARED_ACTIVITY ( ACT_MP_GRENADE1_DRAW );
	REGISTER_SHARED_ACTIVITY ( ACT_MP_GRENADE1_IDLE );
	REGISTER_SHARED_ACTIVITY ( ACT_MP_GRENADE1_ATTACK );
	REGISTER_SHARED_ACTIVITY ( ACT_MP_GRENADE2_DRAW );
	REGISTER_SHARED_ACTIVITY ( ACT_MP_GRENADE2_IDLE );
	REGISTER_SHARED_ACTIVITY ( ACT_MP_GRENADE2_ATTACK );

	REGISTER_SHARED_ACTIVITY ( ACT_MP_PRIMARY_GRENADE1_DRAW );
	REGISTER_SHARED_ACTIVITY ( ACT_MP_PRIMARY_GRENADE1_IDLE );
	REGISTER_SHARED_ACTIVITY ( ACT_MP_PRIMARY_GRENADE1_ATTACK );
	REGISTER_SHARED_ACTIVITY ( ACT_MP_PRIMARY_GRENADE2_DRAW );
	REGISTER_SHARED_ACTIVITY ( ACT_MP_PRIMARY_GRENADE2_IDLE );
	REGISTER_SHARED_ACTIVITY ( ACT_MP_PRIMARY_GRENADE2_ATTACK );

	REGISTER_SHARED_ACTIVITY ( ACT_MP_SECONDARY_GRENADE1_DRAW );
	REGISTER_SHARED_ACTIVITY ( ACT_MP_SECONDARY_GRENADE1_IDLE );
	REGISTER_SHARED_ACTIVITY ( ACT_MP_SECONDARY_GRENADE1_ATTACK );
	REGISTER_SHARED_ACTIVITY ( ACT_MP_SECONDARY_GRENADE2_DRAW );
	REGISTER_SHARED_ACTIVITY ( ACT_MP_SECONDARY_GRENADE2_IDLE );
	REGISTER_SHARED_ACTIVITY ( ACT_MP_SECONDARY_GRENADE2_ATTACK );

	REGISTER_SHARED_ACTIVITY ( ACT_MP_MELEE_GRENADE1_DRAW );
	REGISTER_SHARED_ACTIVITY ( ACT_MP_MELEE_GRENADE1_IDLE );
	REGISTER_SHARED_ACTIVITY ( ACT_MP_MELEE_GRENADE1_ATTACK );
	REGISTER_SHARED_ACTIVITY ( ACT_MP_MELEE_GRENADE2_DRAW );
	REGISTER_SHARED_ACTIVITY ( ACT_MP_MELEE_GRENADE2_IDLE );
	REGISTER_SHARED_ACTIVITY ( ACT_MP_MELEE_GRENADE2_ATTACK );

	REGISTER_SHARED_ACTIVITY ( ACT_MP_ITEM1_GRENADE1_DRAW );
	REGISTER_SHARED_ACTIVITY ( ACT_MP_ITEM1_GRENADE1_IDLE );
	REGISTER_SHARED_ACTIVITY ( ACT_MP_ITEM1_GRENADE1_ATTACK );
	REGISTER_SHARED_ACTIVITY ( ACT_MP_ITEM1_GRENADE2_DRAW );
	REGISTER_SHARED_ACTIVITY ( ACT_MP_ITEM1_GRENADE2_IDLE );
	REGISTER_SHARED_ACTIVITY ( ACT_MP_ITEM1_GRENADE2_ATTACK );

	REGISTER_SHARED_ACTIVITY ( ACT_MP_ITEM2_GRENADE1_DRAW );
	REGISTER_SHARED_ACTIVITY ( ACT_MP_ITEM2_GRENADE1_IDLE );
	REGISTER_SHARED_ACTIVITY ( ACT_MP_ITEM2_GRENADE1_ATTACK );
	REGISTER_SHARED_ACTIVITY ( ACT_MP_ITEM2_GRENADE2_DRAW );
	REGISTER_SHARED_ACTIVITY ( ACT_MP_ITEM2_GRENADE2_IDLE );
	REGISTER_SHARED_ACTIVITY ( ACT_MP_ITEM2_GRENADE2_ATTACK );

	// Building
	REGISTER_SHARED_ACTIVITY ( ACT_MP_STAND_BUILDING );
	REGISTER_SHARED_ACTIVITY ( ACT_MP_CROUCH_BUILDING );
	REGISTER_SHARED_ACTIVITY ( ACT_MP_RUN_BUILDING );
	REGISTER_SHARED_ACTIVITY ( ACT_MP_WALK_BUILDING );
	REGISTER_SHARED_ACTIVITY ( ACT_MP_AIRWALK_BUILDING );
	REGISTER_SHARED_ACTIVITY ( ACT_MP_CROUCHWALK_BUILDING );
	REGISTER_SHARED_ACTIVITY ( ACT_MP_JUMP_BUILDING );
	REGISTER_SHARED_ACTIVITY ( ACT_MP_JUMP_START_BUILDING );
	REGISTER_SHARED_ACTIVITY ( ACT_MP_JUMP_FLOAT_BUILDING );
	REGISTER_SHARED_ACTIVITY ( ACT_MP_JUMP_LAND_BUILDING );
	REGISTER_SHARED_ACTIVITY ( ACT_MP_SWIM_BUILDING );

	REGISTER_SHARED_ACTIVITY ( ACT_MP_ATTACK_STAND_BUILDING );
	REGISTER_SHARED_ACTIVITY ( ACT_MP_ATTACK_CROUCH_BUILDING );
	REGISTER_SHARED_ACTIVITY ( ACT_MP_ATTACK_SWIM_BUILDING );
	REGISTER_SHARED_ACTIVITY ( ACT_MP_ATTACK_AIRWALK_BUILDING );

	REGISTER_SHARED_ACTIVITY ( ACT_MP_ATTACK_STAND_GRENADE_BUILDING );
	REGISTER_SHARED_ACTIVITY ( ACT_MP_ATTACK_CROUCH_GRENADE_BUILDING );
	REGISTER_SHARED_ACTIVITY ( ACT_MP_ATTACK_SWIM_GRENADE_BUILDING );
	REGISTER_SHARED_ACTIVITY ( ACT_MP_ATTACK_AIRWALK_GRENADE_BUILDING );

	// PDA
	REGISTER_SHARED_ACTIVITY ( ACT_MP_STAND_PDA );
	REGISTER_SHARED_ACTIVITY ( ACT_MP_CROUCH_PDA );
	REGISTER_SHARED_ACTIVITY ( ACT_MP_RUN_PDA );
	REGISTER_SHARED_ACTIVITY ( ACT_MP_WALK_PDA );
	REGISTER_SHARED_ACTIVITY ( ACT_MP_AIRWALK_PDA );
	REGISTER_SHARED_ACTIVITY ( ACT_MP_CROUCHWALK_PDA );
	REGISTER_SHARED_ACTIVITY ( ACT_MP_JUMP_PDA );
	REGISTER_SHARED_ACTIVITY ( ACT_MP_JUMP_START_PDA );
	REGISTER_SHARED_ACTIVITY ( ACT_MP_JUMP_FLOAT_PDA );
	REGISTER_SHARED_ACTIVITY ( ACT_MP_JUMP_LAND_PDA );
	REGISTER_SHARED_ACTIVITY ( ACT_MP_SWIM_PDA );

	REGISTER_SHARED_ACTIVITY ( ACT_MP_ATTACK_STAND_PDA );
	REGISTER_SHARED_ACTIVITY ( ACT_MP_ATTACK_SWIM_PDA );

	REGISTER_SHARED_ACTIVITY( ACT_MP_GESTURE_VC_HANDMOUTH );
	REGISTER_SHARED_ACTIVITY( ACT_MP_GESTURE_VC_FINGERPOINT );
	REGISTER_SHARED_ACTIVITY( ACT_MP_GESTURE_VC_FISTPUMP );
	REGISTER_SHARED_ACTIVITY( ACT_MP_GESTURE_VC_THUMBSUP );
	REGISTER_SHARED_ACTIVITY( ACT_MP_GESTURE_VC_NODYES );
	REGISTER_SHARED_ACTIVITY( ACT_MP_GESTURE_VC_NODNO );

	REGISTER_SHARED_ACTIVITY( ACT_MP_GESTURE_VC_HANDMOUTH_PRIMARY );
	REGISTER_SHARED_ACTIVITY( ACT_MP_GESTURE_VC_FINGERPOINT_PRIMARY );
	REGISTER_SHARED_ACTIVITY( ACT_MP_GESTURE_VC_FISTPUMP_PRIMARY );
	REGISTER_SHARED_ACTIVITY( ACT_MP_GESTURE_VC_THUMBSUP_PRIMARY );
	REGISTER_SHARED_ACTIVITY( ACT_MP_GESTURE_VC_NODYES_PRIMARY );
	REGISTER_SHARED_ACTIVITY( ACT_MP_GESTURE_VC_NODNO_PRIMARY );

	REGISTER_SHARED_ACTIVITY( ACT_MP_GESTURE_VC_HANDMOUTH_SECONDARY );
	REGISTER_SHARED_ACTIVITY( ACT_MP_GESTURE_VC_FINGERPOINT_SECONDARY );
	REGISTER_SHARED_ACTIVITY( ACT_MP_GESTURE_VC_FISTPUMP_SECONDARY );
	REGISTER_SHARED_ACTIVITY( ACT_MP_GESTURE_VC_THUMBSUP_SECONDARY );
	REGISTER_SHARED_ACTIVITY( ACT_MP_GESTURE_VC_NODYES_SECONDARY );
	REGISTER_SHARED_ACTIVITY( ACT_MP_GESTURE_VC_NODNO_SECONDARY );

	REGISTER_SHARED_ACTIVITY( ACT_MP_GESTURE_VC_HANDMOUTH_MELEE );
	REGISTER_SHARED_ACTIVITY( ACT_MP_GESTURE_VC_FINGERPOINT_MELEE );
	REGISTER_SHARED_ACTIVITY( ACT_MP_GESTURE_VC_FISTPUMP_MELEE );
	REGISTER_SHARED_ACTIVITY( ACT_MP_GESTURE_VC_THUMBSUP_MELEE );
	REGISTER_SHARED_ACTIVITY( ACT_MP_GESTURE_VC_NODYES_MELEE );
	REGISTER_SHARED_ACTIVITY( ACT_MP_GESTURE_VC_NODNO_MELEE );

	REGISTER_SHARED_ACTIVITY( ACT_MP_GESTURE_VC_HANDMOUTH_ITEM1 );
	REGISTER_SHARED_ACTIVITY( ACT_MP_GESTURE_VC_FINGERPOINT_ITEM1 );
	REGISTER_SHARED_ACTIVITY( ACT_MP_GESTURE_VC_FISTPUMP_ITEM1 );
	REGISTER_SHARED_ACTIVITY( ACT_MP_GESTURE_VC_THUMBSUP_ITEM1 );
	REGISTER_SHARED_ACTIVITY( ACT_MP_GESTURE_VC_NODYES_ITEM1 );
	REGISTER_SHARED_ACTIVITY( ACT_MP_GESTURE_VC_NODNO_ITEM1 );

	REGISTER_SHARED_ACTIVITY( ACT_MP_GESTURE_VC_HANDMOUTH_ITEM2 );
	REGISTER_SHARED_ACTIVITY( ACT_MP_GESTURE_VC_FINGERPOINT_ITEM2 );
	REGISTER_SHARED_ACTIVITY( ACT_MP_GESTURE_VC_FISTPUMP_ITEM2 );
	REGISTER_SHARED_ACTIVITY( ACT_MP_GESTURE_VC_THUMBSUP_ITEM2 );
	REGISTER_SHARED_ACTIVITY( ACT_MP_GESTURE_VC_NODYES_ITEM2 );
	REGISTER_SHARED_ACTIVITY( ACT_MP_GESTURE_VC_NODNO_ITEM2 );

	REGISTER_SHARED_ACTIVITY( ACT_MP_GESTURE_VC_HANDMOUTH_BUILDING );
	REGISTER_SHARED_ACTIVITY( ACT_MP_GESTURE_VC_FINGERPOINT_BUILDING );
	REGISTER_SHARED_ACTIVITY( ACT_MP_GESTURE_VC_FISTPUMP_BUILDING );
	REGISTER_SHARED_ACTIVITY( ACT_MP_GESTURE_VC_THUMBSUP_BUILDING );
	REGISTER_SHARED_ACTIVITY( ACT_MP_GESTURE_VC_NODYES_BUILDING );
	REGISTER_SHARED_ACTIVITY( ACT_MP_GESTURE_VC_NODNO_BUILDING );

	REGISTER_SHARED_ACTIVITY( ACT_MP_GESTURE_VC_HANDMOUTH_PDA );
	REGISTER_SHARED_ACTIVITY( ACT_MP_GESTURE_VC_FINGERPOINT_PDA );
	REGISTER_SHARED_ACTIVITY( ACT_MP_GESTURE_VC_FISTPUMP_PDA );
	REGISTER_SHARED_ACTIVITY( ACT_MP_GESTURE_VC_THUMBSUP_PDA );
	REGISTER_SHARED_ACTIVITY( ACT_MP_GESTURE_VC_NODYES_PDA );
	REGISTER_SHARED_ACTIVITY( ACT_MP_GESTURE_VC_NODNO_PDA );

	REGISTER_SHARED_ACTIVITY ( ACT_VM_UNUSABLE );
	REGISTER_SHARED_ACTIVITY ( ACT_VM_UNUSABLE_TO_USABLE );
	REGISTER_SHARED_ACTIVITY ( ACT_VM_USABLE_TO_UNUSABLE );

	REGISTER_SHARED_ACTIVITY( ACT_PRIMARY_VM_DRAW );
	REGISTER_SHARED_ACTIVITY( ACT_PRIMARY_VM_HOLSTER );
	REGISTER_SHARED_ACTIVITY( ACT_PRIMARY_VM_IDLE );
	REGISTER_SHARED_ACTIVITY( ACT_PRIMARY_VM_PULLBACK );
	REGISTER_SHARED_ACTIVITY( ACT_PRIMARY_VM_PRIMARYATTACK );
	REGISTER_SHARED_ACTIVITY( ACT_PRIMARY_VM_SECONDARYATTACK );
	REGISTER_SHARED_ACTIVITY( ACT_PRIMARY_VM_RELOAD );
	REGISTER_SHARED_ACTIVITY( ACT_PRIMARY_VM_DRYFIRE );
	REGISTER_SHARED_ACTIVITY( ACT_PRIMARY_VM_IDLE_TO_LOWERED );
	REGISTER_SHARED_ACTIVITY( ACT_PRIMARY_VM_IDLE_LOWERED );
	REGISTER_SHARED_ACTIVITY( ACT_PRIMARY_VM_LOWERED_TO_IDLE );

	REGISTER_SHARED_ACTIVITY( ACT_SECONDARY_VM_DRAW );
	REGISTER_SHARED_ACTIVITY( ACT_SECONDARY_VM_HOLSTER );
	REGISTER_SHARED_ACTIVITY( ACT_SECONDARY_VM_IDLE );
	REGISTER_SHARED_ACTIVITY( ACT_SECONDARY_VM_PULLBACK );
	REGISTER_SHARED_ACTIVITY( ACT_SECONDARY_VM_PRIMARYATTACK );
	REGISTER_SHARED_ACTIVITY( ACT_SECONDARY_VM_SECONDARYATTACK );
	REGISTER_SHARED_ACTIVITY( ACT_SECONDARY_VM_RELOAD );
	REGISTER_SHARED_ACTIVITY( ACT_SECONDARY_VM_DRYFIRE );
	REGISTER_SHARED_ACTIVITY( ACT_SECONDARY_VM_IDLE_TO_LOWERED );
	REGISTER_SHARED_ACTIVITY( ACT_SECONDARY_VM_IDLE_LOWERED );
	REGISTER_SHARED_ACTIVITY( ACT_SECONDARY_VM_LOWERED_TO_IDLE );

	REGISTER_SHARED_ACTIVITY( ACT_MELEE_VM_DRAW );
	REGISTER_SHARED_ACTIVITY( ACT_MELEE_VM_HOLSTER );
	REGISTER_SHARED_ACTIVITY( ACT_MELEE_VM_IDLE );
	REGISTER_SHARED_ACTIVITY( ACT_MELEE_VM_PULLBACK );
	REGISTER_SHARED_ACTIVITY( ACT_MELEE_VM_PRIMARYATTACK );
	REGISTER_SHARED_ACTIVITY( ACT_MELEE_VM_SECONDARYATTACK );
	REGISTER_SHARED_ACTIVITY( ACT_MELEE_VM_RELOAD );
	REGISTER_SHARED_ACTIVITY( ACT_MELEE_VM_DRYFIRE );
	REGISTER_SHARED_ACTIVITY( ACT_MELEE_VM_IDLE_TO_LOWERED );
	REGISTER_SHARED_ACTIVITY( ACT_MELEE_VM_IDLE_LOWERED );
	REGISTER_SHARED_ACTIVITY( ACT_MELEE_VM_LOWERED_TO_IDLE );

	REGISTER_SHARED_ACTIVITY( ACT_PDA_VM_DRAW );
	REGISTER_SHARED_ACTIVITY( ACT_PDA_VM_HOLSTER );
	REGISTER_SHARED_ACTIVITY( ACT_PDA_VM_IDLE );
	REGISTER_SHARED_ACTIVITY( ACT_PDA_VM_PULLBACK );
	REGISTER_SHARED_ACTIVITY( ACT_PDA_VM_PRIMARYATTACK );
	REGISTER_SHARED_ACTIVITY( ACT_PDA_VM_SECONDARYATTACK );
	REGISTER_SHARED_ACTIVITY( ACT_PDA_VM_RELOAD );
	REGISTER_SHARED_ACTIVITY( ACT_PDA_VM_DRYFIRE );
	REGISTER_SHARED_ACTIVITY( ACT_PDA_VM_IDLE_TO_LOWERED );
	REGISTER_SHARED_ACTIVITY( ACT_PDA_VM_IDLE_LOWERED );
	REGISTER_SHARED_ACTIVITY( ACT_PDA_VM_LOWERED_TO_IDLE );

	REGISTER_SHARED_ACTIVITY( ACT_ITEM1_VM_DRAW );
	REGISTER_SHARED_ACTIVITY( ACT_ITEM1_VM_HOLSTER );
	REGISTER_SHARED_ACTIVITY( ACT_ITEM1_VM_IDLE );
	REGISTER_SHARED_ACTIVITY( ACT_ITEM1_VM_PULLBACK );
	REGISTER_SHARED_ACTIVITY( ACT_ITEM1_VM_PRIMARYATTACK );
	REGISTER_SHARED_ACTIVITY( ACT_ITEM1_VM_SECONDARYATTACK );
	REGISTER_SHARED_ACTIVITY( ACT_ITEM1_VM_RELOAD );
	REGISTER_SHARED_ACTIVITY( ACT_ITEM1_VM_DRYFIRE );
	REGISTER_SHARED_ACTIVITY( ACT_ITEM1_VM_IDLE_TO_LOWERED );
	REGISTER_SHARED_ACTIVITY( ACT_ITEM1_VM_IDLE_LOWERED );
	REGISTER_SHARED_ACTIVITY( ACT_ITEM1_VM_LOWERED_TO_IDLE );

	REGISTER_SHARED_ACTIVITY( ACT_ITEM2_VM_DRAW );
	REGISTER_SHARED_ACTIVITY( ACT_ITEM2_VM_HOLSTER );
	REGISTER_SHARED_ACTIVITY( ACT_ITEM2_VM_IDLE );
	REGISTER_SHARED_ACTIVITY( ACT_ITEM2_VM_PULLBACK );
	REGISTER_SHARED_ACTIVITY( ACT_ITEM2_VM_PRIMARYATTACK );
	REGISTER_SHARED_ACTIVITY( ACT_ITEM2_VM_SECONDARYATTACK );
	REGISTER_SHARED_ACTIVITY( ACT_ITEM2_VM_RELOAD );
	REGISTER_SHARED_ACTIVITY( ACT_ITEM2_VM_DRYFIRE );
	REGISTER_SHARED_ACTIVITY( ACT_ITEM2_VM_IDLE_TO_LOWERED );
	REGISTER_SHARED_ACTIVITY( ACT_ITEM2_VM_IDLE_LOWERED );
	REGISTER_SHARED_ACTIVITY( ACT_ITEM2_VM_LOWERED_TO_IDLE );

	// infested
	REGISTER_SHARED_ACTIVITY( ACT_RELOAD_SUCCEED );
	REGISTER_SHARED_ACTIVITY( ACT_RELOAD_FAIL );
	REGISTER_SHARED_ACTIVITY( ACT_WALK_AIM_AUTOGUN );
	REGISTER_SHARED_ACTIVITY( ACT_RUN_AIM_AUTOGUN );
	REGISTER_SHARED_ACTIVITY( ACT_IDLE_AUTOGUN );
	REGISTER_SHARED_ACTIVITY( ACT_IDLE_AIM_AUTOGUN );
	REGISTER_SHARED_ACTIVITY( ACT_RELOAD_AUTOGUN );
	REGISTER_SHARED_ACTIVITY( ACT_CROUCH_IDLE_AUTOGUN );
	REGISTER_SHARED_ACTIVITY( ACT_RANGE_ATTACK_AUTOGUN );
	REGISTER_SHARED_ACTIVITY( ACT_JUMP_AUTOGUN );
	REGISTER_SHARED_ACTIVITY( ACT_IDLE_AIM_PISTOL );
	REGISTER_SHARED_ACTIVITY( ACT_WALK_AIM_DUAL );
	REGISTER_SHARED_ACTIVITY( ACT_RUN_AIM_DUAL );
	REGISTER_SHARED_ACTIVITY( ACT_IDLE_DUAL );
	REGISTER_SHARED_ACTIVITY( ACT_IDLE_AIM_DUAL );
	REGISTER_SHARED_ACTIVITY( ACT_RELOAD_DUAL );
	REGISTER_SHARED_ACTIVITY( ACT_CROUCH_IDLE_DUAL );
	REGISTER_SHARED_ACTIVITY( ACT_RANGE_ATTACK_DUAL );
	REGISTER_SHARED_ACTIVITY( ACT_JUMP_DUAL );
	REGISTER_SHARED_ACTIVITY( ACT_IDLE_SHOTGUN );
	REGISTER_SHARED_ACTIVITY( ACT_IDLE_AIM_SHOTGUN );
	REGISTER_SHARED_ACTIVITY( ACT_CROUCH_IDLE_SHOTGUN );
	REGISTER_SHARED_ACTIVITY( ACT_JUMP_SHOTGUN );
	REGISTER_SHARED_ACTIVITY( ACT_IDLE_AIM_RIFLE );
	REGISTER_SHARED_ACTIVITY( ACT_RELOAD_RIFLE );
	REGISTER_SHARED_ACTIVITY( ACT_CROUCH_IDLE_RIFLE );
	REGISTER_SHARED_ACTIVITY( ACT_RANGE_ATTACK_RIFLE );
	REGISTER_SHARED_ACTIVITY( ACT_JUMP_RIFLE );
	// Infested General AI
	REGISTER_SHARED_ACTIVITY( ACT_SLEEP );
	REGISTER_SHARED_ACTIVITY( ACT_WAKE );
	// Shield Bug
	REGISTER_SHARED_ACTIVITY( ACT_FLICK_LEFT );
	REGISTER_SHARED_ACTIVITY( ACT_FLICK_LEFT_MIDDLE );
	REGISTER_SHARED_ACTIVITY( ACT_FLICK_RIGHT_MIDDLE );
	REGISTER_SHARED_ACTIVITY( ACT_FLICK_RIGHT );
	REGISTER_SHARED_ACTIVITY( ACT_SPINAROUND );
	// Mortar Bug
	REGISTER_SHARED_ACTIVITY( ACT_PREP_TO_FIRE );
	REGISTER_SHARED_ACTIVITY( ACT_FIRE );
	REGISTER_SHARED_ACTIVITY( ACT_FIRE_RECOVER );
	// Shaman
	REGISTER_SHARED_ACTIVITY( ACT_SPRAY );
	// Boomer
	REGISTER_SHARED_ACTIVITY( ACT_PREP_EXPLODE );
	REGISTER_SHARED_ACTIVITY( ACT_EXPLODE );

	AssertMsg( g_HighestActivity == LAST_SHARED_ACTIVITY - 1, "Not all activities from ai_activity.h registered in activitylist.cpp" );
}

// HACKHACK: Keep backwards compatibility on broken activities temporarily
#define ACTIVITY_FILE_TAG 0x80800000

class CActivityDataOps : public CDefSaveRestoreOps
{
public:
	// save data type interface
	virtual void Save( const SaveRestoreFieldInfo_t &fieldInfo, ISave *pSave )
	{
		int activityIndex = *((int *)fieldInfo.pField);
		const char *pActivityName = ActivityList_NameForIndex( activityIndex );
		if ( !pActivityName )
		{
			AssertOnce( activityIndex == -1 ); // FIXME: whatever activity this was, it's now being saved out as ACT_RESET
			pActivityName = ActivityList_NameForIndex( 0 );
		}
		int len = strlen(pActivityName) + 1;

		// Use the high 16-bits of this int to signify this file format
		// this makes this backwards compatible.
		// UNDONE: Remove after playtest save files are no longer needed
		len |= ACTIVITY_FILE_TAG;
		pSave->WriteInt( &len );
		pSave->WriteString( pActivityName );
	}

	virtual void Restore( const SaveRestoreFieldInfo_t &fieldInfo, IRestore *pRestore )
	{
		char nameBuf[1024];

		int *pActivityIndex = (int *)fieldInfo.pField;

		int nameLen = pRestore->ReadInt();
		if ( (nameLen & 0xFFFF0000) != ACTIVITY_FILE_TAG )
		{
			// old save file, this is an index, not a name
			*pActivityIndex = nameLen;
			return;
		}
		nameLen &= 0xFFFF;
		pRestore->ReadString( nameBuf, sizeof(nameBuf), nameLen );
		*pActivityIndex = ActivityList_IndexForName( nameBuf );
		if ( *pActivityIndex < 0 )
		{
			*pActivityIndex = 0;
		}
	}

	virtual bool IsEmpty( const SaveRestoreFieldInfo_t &fieldInfo )
	{
		int *pActivityIndex = (int *)fieldInfo.pField;
		return (*pActivityIndex == 0);
	}

	virtual void MakeEmpty( const SaveRestoreFieldInfo_t &fieldInfo )
	{
		int *pActivityIndex = (int *)fieldInfo.pField;
		*pActivityIndex = 0;
	}
};

static CActivityDataOps g_ActivityDataOps;

ISaveRestoreOps* ActivityDataOps()
{
	return &g_ActivityDataOps;
}

void UTIL_LoadActivityRemapFile( const char *filename, const char *section, CUtlVector <CActivityRemap> &entries )
{
	int iIndex = m_ActivityRemapDatabase.Find( filename );

	if ( iIndex != m_ActivityRemapDatabase.InvalidIndex() )
	{
		CActivityRemapCache *actRemap = &m_ActivityRemapDatabase[iIndex];
		entries.AddVectorToTail( actRemap->m_cachedActivityRemaps );
		return;
	}

	KeyValues *pkvFile = new KeyValues( section );

	if ( pkvFile->LoadFromFile( filesystem, filename, NULL ) )
	{
		KeyValues *pTestKey = pkvFile->GetFirstSubKey();

		CActivityRemapCache actRemap;

		while ( pTestKey )
		{
			Activity ActBase = (Activity)ActivityList_IndexForName( pTestKey->GetName() );

			if ( ActBase != ACT_INVALID )
			{
				KeyValues *pRemapKey = pTestKey->GetFirstSubKey();

				CActivityRemap actMap;
				actMap.activity = ActBase;

				while ( pRemapKey )
				{
					const char *pKeyName = pRemapKey->GetName();
					const char *pKeyValue = pRemapKey->GetString();

					if ( !stricmp( pKeyName, "remapactivity" ) )
					{
						Activity Act = (Activity)ActivityList_IndexForName( pKeyValue );

						if ( Act == ACT_INVALID )
						{
							actMap.mappedActivity = ActivityList_RegisterPrivateActivity( pKeyValue );
						}
						else
						{
							actMap.mappedActivity = Act;
						}
					}
					else if ( !stricmp( pKeyName, "extra" ) )
					{
						actMap.SetExtraKeyValueBlock( pRemapKey->MakeCopy() );
					}

					pRemapKey = pRemapKey->GetNextKey();
				}

				entries.AddToTail( actMap );
			}

			pTestKey = pTestKey->GetNextKey();
		}

		actRemap.m_cachedActivityRemaps.AddVectorToTail( entries );
		m_ActivityRemapDatabase.Insert( filename, actRemap );
	}
}

int ActivityList_HighestIndex()
{
	return g_HighestActivity;
}


text:
<?php
/**
 * Message translations.
 *
 * This file is automatically generated by 'yii message/extract' command.
 * It contains the localizable messages extracted from source code.
 * You may modify this file by translating the extracted messages.
 *
 * Each array element represents the translation (value) of a message (key).
 * If the value is empty, the message is considered as not translated.
 * Messages that no longer need translation will have their translations
 * enclosed between a pair of '@@' marks.
 *
 * Message string can be used with plural forms format. Check i18n section
 * of the guide for details.
 *
 * NOTE: this file must be saved in UTF-8 encoding.
 */
return [
    '- Лайфхак - расскажи секреты жизни в своем городе и стране;
' => '',
    '- Приключение - есть история приключений? Поделись!;
' => '',
    '- Природные - все природные чудеса и интересности вносить сюда;
' => '',
    '
Инструкция по получению постинг ключа:
' => '',
    'Activation email' => '',
    'If you living in that place, just not touch it. It will show to everybody, that this is your permanent place. ' => '',
    'Just mark language which you can speak. It helps to other travelers find people who can speak their native language.' => '',
    'Library' => '',
    'Now all homestays is free for community members. If you not agree with it, please, not fill that form.' => '',
    'Phone? Facebook? Telegram? Email? Any..' => '',
    'Posting Key, begins with 5..' => '',
    'Saved' => '',
    'Select a city, which will next level your branch' => '',
    'Select a country, which will head branch of tree' => '',
    'Tell about your place or about yourself. All what you want to say.' => '',
    'Tell about yourself, about your traveler expirience. All what you want to say.' => '',
    'This email has already been taken.' => '',
    'Voters' => '',
    'Votes' => '',
    'Write the name of your homestay or just title' => '',
    'You can mark the place around youself. Or not mark.. It is up to you.' => '',
    'Your account has been successfully activated.' => '',
    'Your account has been successfully created. Check your email for further instructions.' => '',
    'Your activation link: {url}' => '',
    'Базовая инструкция MarkDown:' => '',
    'Важно!' => '',
    'Вы можете использовать логин и пароль от аккаунта Steem/Golos для получения приватного постинг-ключа, или можете самостоятельно взять его ' => '',
    'Выбери тип контента для публикации в BlockChain:' => '',
    'Город будет являться вложенной папкой в дереве тегов' => '',
    'Жилье путешественника' => '',
    'Отметь место на карте, если это уместно, или ничего не отмечай, если нет.' => '',
    'Очень тяжело найти особенное без без точных координат. Помоги другим путешественникам, укажи координаты точно.' => '',
    'Поделись полезными знаниями и туристическими секретами' => '',
    'Получить приватный ключ из пароля' => '',
    'Пополнить базу' => '',
    'Попутчики' => '',
    'Постарайся уложиться в 100 символов, кратко и емко рассказав Главное' => '',
    'Постарайся уложиться в 100 символов, кратко и емко рассказав о сути знания' => '',
    'Расскажи историю своего приключения' => '',
    'Расскажи о интересных местах, которые стоит посетить' => '',
    'События' => '',
    'Сохраняйте пароль НАДЕЖНО. Мы не можем его восстановить' => '',
    'Ссылка: [название ссылки](адрес)
' => '',
    'Страна будет размещена в "голове" дерева тегов' => '',
    'Account Settings' => 'Настройки аккаунта',
    'Articles' => 'Статьи',
    'Attachments' => 'Приложения',
    'Base' => 'База',
    'Blogs' => 'Блоги',
    'Body' => 'Сообщение',
    'Category' => 'Категория',
    'Check your email for further instructions.' => 'Проверьте ваш e-mail.',
    'City' => 'Город',
    'Confirm Password' => 'Подтвердите пароль',
    'Contacts' => 'Контакты',
    'Coordinates' => 'Координаты',
    'Cost, USD' => 'Цена, USD',
    'Country' => 'Страна',
    'Date until leave' => 'Дата отъезда',
    'Discuss' => 'Обсуждаемое',
    'E-mail' => 'E-mail',
    'Edit' => 'Редактировать',
    'Email' => 'Email',
    'Enter the title or your name' => 'Введите заголовок или ваше имя',
    'Error while oauth process.' => 'Ошибка в процессе OAuth авторизации.',
    'Female' => 'Женский',
    'Free' => 'Бесплатно',
    'Golos private posting key' => 'Приватный постинг ключ для ГОЛОС',
    'Homestay' => 'Жилье',
    'Im not in the travel now and this is my permanent place' => 'Я не в путешествии сейчас, я тут живу',
    'Incorrect username or password.' => 'Неправильный логин или пароль.',
    'Introduce yourself, please (title)' => 'Представьтесь, пожалуйста (заголовок)',
    'Key STEEM' => 'Ключ GOLOS',
    'Knowledge' => 'Знания',
    'Language' => 'Язык',
    'Languages' => 'Языки',
    'Login' => 'Вход',
    'Logout' => 'Выход',
    'Male' => 'Мужской',
    'Must pay' => 'Платно',
    'My blog' => 'Мой блог',
    'Name' => 'Имя',
    'New' => 'Новое',
    'New password was saved.' => 'Новый пароль был сохранен',
    'Page not found' => 'Страница не найдена',
    'Password' => 'Пароль',
    'Password reset for {name}' => 'Сброс пароля для {name}',
    'People' => 'Люди',
    'Places' => 'Места',
    'Profile settings' => 'Настройки профиля',
    'Remember Me' => 'Запомнить меня',
    'Request password reset' => 'Запрос сброса пароля',
    'Reset password' => 'Сброс пароля',
    'Save' => 'Сохранить',
    'Settings' => 'Настройки',
    'Signup' => 'Регистрация',
    'Sorry, we are unable to reset password for email provided.' => 'Извините, мы не можем сбросить пароль для этого e-mail.',
    'Steem private posting key' => 'Приватный постинг ключ для Steem',
    'Subject' => 'Тема',
    'Submit' => 'Отправить',
    'This email address has already been taken.' => 'Этот e-mail уже занят',
    'This username has already been taken.' => 'Это имя пользователя уже занято',
    'Title' => 'Заголовок',
    'Trending' => 'Горячее',
    'Update' => 'Редактировать',
    'Add Post' => 'Добавить пост',
    'Watch' => 'Просмотреть',
    'User Settings' => 'Настройки пользователя',
    'Username' => 'Имя пользователя',
    'Username or email' => 'Имя пользователя или e-mail',
    'Verification Code' => 'Проверочный код',
    'We already have a user with email {email}' => 'Пользователь с email {email} уже зарегистрирован.',
    'Welcome to {app-name}. Email with your login information was sent to your email.' => 'Добро пожаловать в {app-name}. E-mail с информацией о пользователе был отправлен на вашу почту.',
    'Your account has been successfully saved' => 'Ваш аккаунт был успешно сохранен',
    '{app-name} | Your login information' => '{app-name} | Информация о пользователе',
    'News' => 'Новости',
    'Unsorted' => 'Вне_Города',
    'Travel' => 'Путешествия',
    'Location' => 'Локация (город, остров, ...)',
    'Articles' => 'Статьи',
    'You can use Markdown syntax' => 'Вы можете использовать синтаксис MarkDown',
    'Username' => 'Никнейм',
    'Date, Time' => 'Дата, Время',
    'Amount, BTC' => 'Сумма, BTC',
    'Bonuse' => 'Бонус',
    'Tokens' => 'Токены',
    'Personal Bitcoin Address' => 'Персональный BTC-адрес',
    'Your investments, BTC' => 'Ваши инвестиции, BTC',
    'Your Tokens' => 'Ваши токены',
    'All investments, BTC' => 'Все инвестиции, BTC',
    'All distributed tokens' => 'Все распределенные токены',
    'Distribution' => 'Распределение',
    'Currency' => 'Валюта',
    'Bonuse, %' => 'Бонус, %',
    'Week stake, %'=> 'Доля за неделю, %',
    'Weekly income' => 'Поступления за неделю',
    'Personal information' => 'Персональная информация',
    'Total information' => 'Общая информация',
    'GBG account' => 'GBG аккаунт',
    'Tokens for distribution: 810000' => 'Токены на распределение: 810000',
    'INSTRUCTION' => 'ИНСТРУКЦИЯ',
    'Tokens' => 'Токены',
    'All investments - ' => 'Все инвестиции - ',
    'All distributed tokens - ' => 'Все распределенные токены - ',
    'History' => 'История',
    'BONUS TODAY:' => 'БОНУС СЕГОДНЯ:',
    'Bonuses:' => 'Бонусы:',
    'Current rate:' => 'Текущий курс:',
    'author:' => 'автор:',
    'install STEEM posting private key' => 'укажите приватный ключ от аккаунта GOLOS',

];


text:
$(document).ready(function(){
    console.log("coucou");

        /* navigation bar color change */
        var changeColor = function() {

            console.log('scroll')
                var scroll_start = 0;
                var startchange = $('#start');
                var offset = startchange.offset();
                if (startchange.length){
                    $(document).scroll(function() {
                        scroll_start = $(this).scrollTop();
                        if(scroll_start > offset.top) {
                            $(".navbar").addClass('bg-cloud')

                        } else {
                            $(".navbar").removeClass('bg-light')
                            $(".navbar").removeClass('bg-cloud')
                            $(".navbar").removeClass('text-dark');

                        }
                });
            }
        }  ;

        /* page scroll on click */
        var scroll = function() {
            $('.page-scroll a').bind('click', function(event) {
                var $anchor = $(this);
                $('html, body').stop().animate({
                    scrollTop: $($anchor.attr('href')).offset().top
                }, 1000, 'easeInOutExpo');
                event.preventDefault();
            });
        } ;

        changeColor();
        scroll()

        });

(function ($) {
    $('p.round').wrap('<div class="round"/>').each(function () {
        var $p = $(this);
        var $div = $p.parent();
        var min = 0;
        var max = 100;
        var textBrut =  $p.data('percentage');
        var ratio = (textBrut - min) / (max - min);
        //console.log(textBrut);

        var $circle = $('<canvas width="200px" height="200px"/>');

        $div.append($circle);

        var ctx = $circle[0].getContext('2d');

        ctx.beginPath();

        ctx.arc(100,100,70,-1/2 * Math.PI,ratio*2*Math.PI -1/2 *Math.PI) ;
        ctx.lineWidth = 10;
        ctx.strokeStyle = "#212529";
        ctx.shadowOffsetX = 2;
        ctx.shadowBlur = 5;
        ctx.shadowColor = "#0d1012";

        ctx.stroke();
    })
})(jQuery);

$('#pagination').easyPaginate({
    paginateElement: 'img',
    elementsPerPage: 1,
    effect: 'climb'
});


text:
module EasyType
  #
  # The Integer munger, munges a specified value to an Integer.
  #
  module Mungers

    [Integer, String, Array, Float].each do| klass|
      module_eval(<<-END_RUBY, __FILE__, __LINE__)
        # @nodoc
        # @private
        module #{klass}
          def unsafe_munge(value)
            #{klass}(value)
          end
        end
      END_RUBY
    end
    #
    # The Size munger, munges a specified value to an Integer.
    #
    module Size
      # @private
      def unsafe_munge(size)
        return size if size.is_a?(Numeric)
        case size
        when /^\d+(K|k)$/ then size.chop.to_i * 1024
        when /^\d+(M|m)$/ then size.chop.to_i * 1024 * 1024
        when /^\d+(G|g)$/ then size.chop.to_i * 1024 * 1024 * 1024
        when /^\d+$/ then size.to_i
        else
          fail('invalid size')
        end
      end
    end

    #
    # The Upcase and downcase munger, munges a specified value to an specified String
    # If the value is an array, all entries in the array will be managed
    # If the value doesn't support the method, a debug message is send and the original value
    # is returned.
    #
    [:downcase, :upcase].each do| method|
      klass = method.to_s.capitalize
      module_eval(<<-END_RUBY, __FILE__, __LINE__)
        # @nodoc
        # @private
        module #{klass}
          def unsafe_munge(entry)
            if entry.is_a?(::Array)
              entry.collect{|e| #{method}_if_defined(e)}
            else
              #{method}_if_defined(entry)
            end
          end

          private

          def #{method}_if_defined(value)
            if value.respond_to?(:#{method})
              value.#{method}
            else
              Puppet.debug "Found an unsupported #{method} munge."
              value
            end
          end
        end
      END_RUBY
    end
  end
end