text:
CREATE TABLE `guacamole_connection_group` (

  `connection_group_id`   int(11)      NOT NULL AUTO_INCREMENT,
  `parent_id`             int(11),
  `connection_group_name` varchar(128) NOT NULL,
  `type`                  enum('ORGANIZATIONAL',
                               'BALANCING') NOT NULL DEFAULT 'ORGANIZATIONAL',

  -- Concurrency limits
  `max_connections`          int(11),
  `max_connections_per_user` int(11),
  `enable_session_affinity`  boolean NOT NULL DEFAULT 0,

  PRIMARY KEY (`connection_group_id`),
  UNIQUE KEY `connection_group_name_parent` (`connection_group_name`, `parent_id`),

  CONSTRAINT `guacamole_connection_group_ibfk_1`
    FOREIGN KEY (`parent_id`)
    REFERENCES `guacamole_connection_group` (`connection_group_id`) ON DELETE CASCADE

) ENGINE=InnoDB DEFAULT CHARSET=utf8;

--
-- Table of connections. Each connection has a name, protocol, and
-- associated set of parameters.
-- A connection may belong to a connection group.
--

CREATE TABLE `guacamole_connection` (

  `connection_id`       int(11)      NOT NULL AUTO_INCREMENT,
  `connection_name`     varchar(128) NOT NULL,
  `parent_id`           int(11),
  `protocol`            varchar(32)  NOT NULL,

  -- Guacamole proxy (guacd) overrides
  `proxy_port`              integer,
  `proxy_hostname`          varchar(512),
  `proxy_encryption_method` enum('NONE', 'SSL'),

  -- Concurrency limits
  `max_connections`          int(11),
  `max_connections_per_user` int(11),

  -- Connection weight
  `connection_weight`        int(11),

  PRIMARY KEY (`connection_id`),
  UNIQUE KEY `connection_name_parent` (`connection_name`, `parent_id`),

  CONSTRAINT `guacamole_connection_ibfk_1`
    FOREIGN KEY (`parent_id`)
    REFERENCES `guacamole_connection_group` (`connection_group_id`) ON DELETE CASCADE

) ENGINE=InnoDB DEFAULT CHARSET=utf8;

--
-- Table of users. Each user has a unique username and a hashed password
-- with corresponding salt. Although the authentication system will always set
-- salted passwords, other systems may set unsalted passwords by simply not
-- providing the salt.
--

CREATE TABLE `guacamole_user` (

  `user_id`       int(11)      NOT NULL AUTO_INCREMENT,

  -- Username and optionally-salted password
  `username`      varchar(128) NOT NULL,
  `password_hash` binary(32)   NOT NULL,
  `password_salt` binary(32),
  `password_date` datetime     NOT NULL,

  -- Account disabled/expired status
  `disabled`      boolean      NOT NULL DEFAULT 0,
  `expired`       boolean      NOT NULL DEFAULT 0,

  -- Time-based access restriction
  `access_window_start`    TIME,
  `access_window_end`      TIME,

  -- Date-based access restriction
  `valid_from`  DATE,
  `valid_until` DATE,

  -- Timezone used for all date/time comparisons and interpretation
  `timezone` VARCHAR(64),

  -- Profile information
  `full_name`           VARCHAR(256),
  `email_address`       VARCHAR(256),
  `organization`        VARCHAR(256),
  `organizational_role` VARCHAR(256),

  PRIMARY KEY (`user_id`),
  UNIQUE KEY `username` (`username`)

) ENGINE=InnoDB DEFAULT CHARSET=utf8;

--
-- Table of sharing profiles. Each sharing profile has a name, associated set
-- of parameters, and a primary connection. The primary connection is the
-- connection that the sharing profile shares, and the parameters dictate the
-- restrictions/features which apply to the user joining the connection via the
-- sharing profile.
--

CREATE TABLE guacamole_sharing_profile (

  `sharing_profile_id`    int(11)      NOT NULL AUTO_INCREMENT,
  `sharing_profile_name`  varchar(128) NOT NULL,
  `primary_connection_id` int(11)      NOT NULL,

  PRIMARY KEY (`sharing_profile_id`),
  UNIQUE KEY `sharing_profile_name_primary` (sharing_profile_name, primary_connection_id),

  CONSTRAINT `guacamole_sharing_profile_ibfk_1`
    FOREIGN KEY (`primary_connection_id`)
    REFERENCES `guacamole_connection` (`connection_id`)
    ON DELETE CASCADE

) ENGINE=InnoDB DEFAULT CHARSET=utf8;

--
-- Table of connection parameters. Each parameter is simply a name/value pair
-- associated with a connection.
--

CREATE TABLE `guacamole_connection_parameter` (

  `connection_id`   int(11)       NOT NULL,
  `parameter_name`  varchar(128)  NOT NULL,
  `parameter_value` varchar(4096) NOT NULL,

  PRIMARY KEY (`connection_id`,`parameter_name`),

  CONSTRAINT `guacamole_connection_parameter_ibfk_1`
    FOREIGN KEY (`connection_id`)
    REFERENCES `guacamole_connection` (`connection_id`) ON DELETE CASCADE

) ENGINE=InnoDB DEFAULT CHARSET=utf8;

--
-- Table of sharing profile parameters. Each parameter is simply
-- name/value pair associated with a sharing profile. These parameters dictate
-- the restrictions/features which apply to the user joining the associated
-- connection via the sharing profile.
--

CREATE TABLE guacamole_sharing_profile_parameter (

  `sharing_profile_id` integer       NOT NULL,
  `parameter_name`     varchar(128)  NOT NULL,
  `parameter_value`    varchar(4096) NOT NULL,

  PRIMARY KEY (`sharing_profile_id`, `parameter_name`),

  CONSTRAINT `guacamole_sharing_profile_parameter_ibfk_1`
    FOREIGN KEY (`sharing_profile_id`)
    REFERENCES `guacamole_sharing_profile` (`sharing_profile_id`) ON DELETE CASCADE

) ENGINE=InnoDB DEFAULT CHARSET=utf8;

--
-- Table of connection permissions. Each connection permission grants a user
-- specific access to a connection.
--

CREATE TABLE `guacamole_connection_permission` (

  `user_id`       int(11) NOT NULL,
  `connection_id` int(11) NOT NULL,
  `permission`    enum('READ',
                       'UPDATE',
                       'DELETE',
                       'ADMINISTER') NOT NULL,

  PRIMARY KEY (`user_id`,`connection_id`,`permission`),

  CONSTRAINT `guacamole_connection_permission_ibfk_1`
    FOREIGN KEY (`connection_id`)
    REFERENCES `guacamole_connection` (`connection_id`) ON DELETE CASCADE,

  CONSTRAINT `guacamole_connection_permission_ibfk_2`
    FOREIGN KEY (`user_id`)
    REFERENCES `guacamole_user` (`user_id`) ON DELETE CASCADE

) ENGINE=InnoDB DEFAULT CHARSET=utf8;

--
-- Table of connection group permissions. Each group permission grants a user
-- specific access to a connection group.
--

CREATE TABLE `guacamole_connection_group_permission` (

  `user_id`             int(11) NOT NULL,
  `connection_group_id` int(11) NOT NULL,
  `permission`          enum('READ',
                             'UPDATE',
                             'DELETE',
                             'ADMINISTER') NOT NULL,

  PRIMARY KEY (`user_id`,`connection_group_id`,`permission`),

  CONSTRAINT `guacamole_connection_group_permission_ibfk_1`
    FOREIGN KEY (`connection_group_id`)
    REFERENCES `guacamole_connection_group` (`connection_group_id`) ON DELETE CASCADE,

  CONSTRAINT `guacamole_connection_group_permission_ibfk_2`
    FOREIGN KEY (`user_id`)
    REFERENCES `guacamole_user` (`user_id`) ON DELETE CASCADE

) ENGINE=InnoDB DEFAULT CHARSET=utf8;

--
-- Table of sharing profile permissions. Each sharing profile permission grants
-- a user specific access to a sharing profile.
--

CREATE TABLE guacamole_sharing_profile_permission (

  `user_id`            integer NOT NULL,
  `sharing_profile_id` integer NOT NULL,
  `permission`         enum('READ',
                            'UPDATE',
                            'DELETE',
                            'ADMINISTER') NOT NULL,

  PRIMARY KEY (`user_id`, `sharing_profile_id`, `permission`),

  CONSTRAINT `guacamole_sharing_profile_permission_ibfk_1`
    FOREIGN KEY (`sharing_profile_id`)
    REFERENCES `guacamole_sharing_profile` (`sharing_profile_id`) ON DELETE CASCADE,

  CONSTRAINT `guacamole_sharing_profile_permission_ibfk_2`
    FOREIGN KEY (`user_id`)
    REFERENCES `guacamole_user` (`user_id`) ON DELETE CASCADE

) ENGINE=InnoDB DEFAULT CHARSET=utf8;

--
-- Table of system permissions. Each system permission grants a user a
-- system-level privilege of some kind.
--

CREATE TABLE `guacamole_system_permission` (

  `user_id`    int(11) NOT NULL,
  `permission` enum('CREATE_CONNECTION',
                    'CREATE_CONNECTION_GROUP',
                    'CREATE_SHARING_PROFILE',
                    'CREATE_USER',
                    'ADMINISTER') NOT NULL,

  PRIMARY KEY (`user_id`,`permission`),

  CONSTRAINT `guacamole_system_permission_ibfk_1`
    FOREIGN KEY (`user_id`)
    REFERENCES `guacamole_user` (`user_id`) ON DELETE CASCADE

) ENGINE=InnoDB DEFAULT CHARSET=utf8;

--
-- Table of user permissions. Each user permission grants a user access to
-- another user (the "affected" user) for a specific type of operation.
--

CREATE TABLE `guacamole_user_permission` (

  `user_id`          int(11) NOT NULL,
  `affected_user_id` int(11) NOT NULL,
  `permission`       enum('READ',
                          'UPDATE',
                          'DELETE',
                          'ADMINISTER') NOT NULL,

  PRIMARY KEY (`user_id`,`affected_user_id`,`permission`),

  CONSTRAINT `guacamole_user_permission_ibfk_1`
    FOREIGN KEY (`affected_user_id`)
    REFERENCES `guacamole_user` (`user_id`) ON DELETE CASCADE,

  CONSTRAINT `guacamole_user_permission_ibfk_2`
    FOREIGN KEY (`user_id`)
    REFERENCES `guacamole_user` (`user_id`) ON DELETE CASCADE

) ENGINE=InnoDB DEFAULT CHARSET=utf8;

--
-- Table of connection history records. Each record defines a specific user's
-- session, including the connection used, the start time, and the end time
-- (if any).
--

CREATE TABLE `guacamole_connection_history` (

  `history_id`           int(11)      NOT NULL AUTO_INCREMENT,
  `user_id`              int(11)      DEFAULT NULL,
  `username`             varchar(128) NOT NULL,
  `connection_id`        int(11)      DEFAULT NULL,
  `connection_name`      varchar(128) NOT NULL,
  `sharing_profile_id`   int(11)      DEFAULT NULL,
  `sharing_profile_name` varchar(128) DEFAULT NULL,
  `start_date`           datetime     NOT NULL,
  `end_date`             datetime     DEFAULT NULL,

  PRIMARY KEY (`history_id`),
  KEY `user_id` (`user_id`),
  KEY `connection_id` (`connection_id`),
  KEY `sharing_profile_id` (`sharing_profile_id`),
  KEY `start_date` (`start_date`),
  KEY `end_date` (`end_date`),

  CONSTRAINT `guacamole_connection_history_ibfk_1`
    FOREIGN KEY (`user_id`)
    REFERENCES `guacamole_user` (`user_id`) ON DELETE SET NULL,

  CONSTRAINT `guacamole_connection_history_ibfk_2`
    FOREIGN KEY (`connection_id`)
    REFERENCES `guacamole_connection` (`connection_id`) ON DELETE SET NULL,

  CONSTRAINT `guacamole_connection_history_ibfk_3`
    FOREIGN KEY (`sharing_profile_id`)
    REFERENCES `guacamole_sharing_profile` (`sharing_profile_id`) ON DELETE SET NULL

) ENGINE=InnoDB DEFAULT CHARSET=utf8;

--
-- User password history
--

CREATE TABLE guacamole_user_password_history (

  `password_history_id` int(11) NOT NULL AUTO_INCREMENT,
  `user_id`             int(11) NOT NULL,

  -- Salted password
  `password_hash` binary(32) NOT NULL,
  `password_salt` binary(32),
  `password_date` datetime   NOT NULL,

  PRIMARY KEY (`password_history_id`),
  KEY `user_id` (`user_id`),

  CONSTRAINT `guacamole_user_password_history_ibfk_1`
    FOREIGN KEY (`user_id`)
    REFERENCES `guacamole_user` (`user_id`) ON DELETE CASCADE

) ENGINE=InnoDB DEFAULT CHARSET=utf8;


text:
package learningspringboot;

import java.time.LocalDateTime;
import java.util.Random;

import org.springframework.jms.core.JmsTemplate;
import org.springframework.scheduling.annotation.Scheduled;

public class NetworkEventSimulator {

	final private JmsTemplate jmsTemplate;
	final private String destination;

	public NetworkEventSimulator(JmsTemplate jmsTemplate, String dest) {
		this.jmsTemplate = jmsTemplate;
		this.destination = dest;
	}

	@Scheduled(fixedRate = 1000L)
	public void simulateActivity() {

		Random random = new Random();

		String hostname;
		switch (random.nextInt(3)) {
			case 0: hostname = "router101"; break;
			case 1: hostname = "multiplex205"; break;
			default: hostname = "switch1143"; break;
		}

		Severity severity;
		switch (random.nextInt(4)) {
			case 0: severity = Severity.UP; break;
			case 1: severity = Severity.DEGRADED; break;
			case 2: severity = Severity.JEOPARDY; break;
			default: severity = Severity.DOWN; break;
		}
		Alarm event = new Alarm(hostname, LocalDateTime.now(),
				severity);
		jmsTemplate.convertAndSend(destination, event);
	}

}

redpajama_set_name: RedPajamaGithub


text:
@class AGSPoint;

@interface TianDiTuWMTSLayerInfo : NSObject
{
    @private
    NSString __unsafe_unretained *_url;
    NSString __unsafe_unretained *_layerName;
    int _minZoomLevel;
    int _maxZoomLevel;
    double _xMin;
    double _yMin;
    double _xMax;
    double _yMax;
    int _tileWidth;
    int _tileHeight;
    NSMutableArray __unsafe_unretained *_lods;
    int _dpi;
    int _srid;
    AGSPoint __unsafe_unretained *_origin;
    NSString __unsafe_unretained *_tileMatrixSet;
}
@property (nonatomic,assign) NSString *url;
@property (nonatomic,assign) NSString *layerName;
@property (nonatomic,assign) int minZoomLevel;
@property (nonatomic,assign) int maxZoomLevel;
@property (nonatomic,assign) double xMin;
@property (nonatomic,assign) double yMin;
@property (nonatomic,assign) double xMax;
@property (nonatomic,assign) double yMax;
@property (nonatomic,assign) int tileWidth;
@property (nonatomic,assign) int tileHeight;
@property (nonatomic,assign) NSMutableArray *lods;
@property (nonatomic,assign) int dpi;
@property (nonatomic,assign) int srid;
@property (nonatomic,assign) AGSPoint *origin;
@property (nonatomic,assign) NSString *tileMatrixSet;

@end


text:
extern crate mpirs;
extern crate rustc_serialize;
extern crate libc;
extern crate stopwatch;

use std::fmt;

use stopwatch::Stopwatch;

use mpirs::{comm_rank, init, finalize, bcast};
use mpirs::mpi_comm::MPI_COMM_WORLD;

#[derive(Debug, Clone, RustcDecodable, RustcEncodable)]
struct Token {
    pub val: u64,
}

impl fmt::Display for Token {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        write!(f, "{}", self.val)
    }
}

fn main() {
    unsafe {
        libc::usleep(32000);
    }

    let rank = comm_rank::mpi_comm_rank();
    let mut token = Token { val: 65 };

    bcast::mpi_bcast(&mut token, 1, MPI_COMM_WORLD);

    println!("Process {} has token {}", rank, token);
    finalize::mpi_finalize();
}


text:
namespace MusicianHelper.WinForms
{
    partial class AudioEditWindow
    {
        /// <summary>
        /// Required designer variable.
        /// </summary>
        private System.ComponentModel.IContainer components = null;

        /// <summary>
        /// Clean up any resources being used.
        /// </summary>
        /// <param name="disposing">true if managed resources should be disposed; otherwise, false.</param>
        protected override void Dispose(bool disposing)
        {
            if (disposing && (components != null))
            {
                components.Dispose();
            }
            base.Dispose(disposing);
        }

        #region Windows Form Designer generated code

        /// <summary>
        /// Required method for Designer support - do not modify
        /// the contents of this method with the code editor.
        /// </summary>
        private void InitializeComponent()
        {
            this.label1 = new System.Windows.Forms.Label();
            this.TitleTextBox = new System.Windows.Forms.TextBox();
            this.label2 = new System.Windows.Forms.Label();
            this.label3 = new System.Windows.Forms.Label();
            this.DescriptionTextBox = new System.Windows.Forms.TextBox();
            this.TagsTextBox = new System.Windows.Forms.TextBox();
            this.NextButton = new System.Windows.Forms.Button();
            this.DoneButton = new System.Windows.Forms.Button();
            this.PreviousButton = new System.Windows.Forms.Button();
            this.SocialMediaMessageTextBox = new System.Windows.Forms.TextBox();
            this.label4 = new System.Windows.Forms.Label();
            this.SuspendLayout();
            //
            // label1
            //
            this.label1.AutoSize = true;
            this.label1.Location = new System.Drawing.Point(322, 40);
            this.label1.Name = "label1";
            this.label1.Size = new System.Drawing.Size(27, 13);
            this.label1.TabIndex = 0;
            this.label1.Text = "Title";
            //
            // TitleTextBox
            //
            this.TitleTextBox.Location = new System.Drawing.Point(154, 71);
            this.TitleTextBox.Name = "TitleTextBox";
            this.TitleTextBox.Size = new System.Drawing.Size(368, 20);
            this.TitleTextBox.TabIndex = 1;
            //
            // label2
            //
            this.label2.AutoSize = true;
            this.label2.Location = new System.Drawing.Point(307, 127);
            this.label2.Name = "label2";
            this.label2.Size = new System.Drawing.Size(60, 13);
            this.label2.TabIndex = 2;
            this.label2.Text = "Description";
            //
            // label3
            //
            this.label3.AutoSize = true;
            this.label3.Location = new System.Drawing.Point(279, 220);
            this.label3.Name = "label3";
            this.label3.Size = new System.Drawing.Size(124, 13);
            this.label3.TabIndex = 3;
            this.label3.Text = "Tags (comma seperated)";
            //
            // DescriptionTextBox
            //
            this.DescriptionTextBox.Location = new System.Drawing.Point(154, 167);
            this.DescriptionTextBox.Name = "DescriptionTextBox";
            this.DescriptionTextBox.Size = new System.Drawing.Size(368, 20);
            this.DescriptionTextBox.TabIndex = 4;
            //
            // TagsTextBox
            //
            this.TagsTextBox.Location = new System.Drawing.Point(154, 262);
            this.TagsTextBox.Name = "TagsTextBox";
            this.TagsTextBox.Size = new System.Drawing.Size(368, 20);
            this.TagsTextBox.TabIndex = 5;
            //
            // NextButton
            //
            this.NextButton.Location = new System.Drawing.Point(572, 546);
            this.NextButton.Name = "NextButton";
            this.NextButton.Size = new System.Drawing.Size(75, 23);
            this.NextButton.TabIndex = 6;
            this.NextButton.Text = "Next";
            this.NextButton.UseVisualStyleBackColor = true;
            this.NextButton.Click += new System.EventHandler(this.NextButton_Click);
            //
            // DoneButton
            //
            this.DoneButton.Location = new System.Drawing.Point(310, 546);
            this.DoneButton.Name = "DoneButton";
            this.DoneButton.Size = new System.Drawing.Size(75, 23);
            this.DoneButton.TabIndex = 7;
            this.DoneButton.Text = "Done";
            this.DoneButton.UseVisualStyleBackColor = true;
            this.DoneButton.Click += new System.EventHandler(this.DoneButton_Click);
            //
            // PreviousButton
            //
            this.PreviousButton.Location = new System.Drawing.Point(44, 546);
            this.PreviousButton.Name = "PreviousButton";
            this.PreviousButton.Size = new System.Drawing.Size(75, 23);
            this.PreviousButton.TabIndex = 8;
            this.PreviousButton.Text = "Previous";
            this.PreviousButton.UseVisualStyleBackColor = true;
            this.PreviousButton.Click += new System.EventHandler(this.PreviousButton_Click);
            //
            // SocialMediaMessageTextBox
            //
            this.SocialMediaMessageTextBox.Location = new System.Drawing.Point(154, 344);
            this.SocialMediaMessageTextBox.Name = "SocialMediaMessageTextBox";
            this.SocialMediaMessageTextBox.Size = new System.Drawing.Size(368, 20);
            this.SocialMediaMessageTextBox.TabIndex = 9;
            //
            // label4
            //
            this.label4.AutoSize = true;
            this.label4.Location = new System.Drawing.Point(279, 308);
            this.label4.Name = "label4";
            this.label4.Size = new System.Drawing.Size(114, 13);
            this.label4.TabIndex = 10;
            this.label4.Text = "Social Media Message";
            //
            // AudioEditWindow
            //
            this.AutoScaleDimensions = new System.Drawing.SizeF(6F, 13F);
            this.AutoScaleMode = System.Windows.Forms.AutoScaleMode.Font;
            this.ClientSize = new System.Drawing.Size(680, 604);
            this.Controls.Add(this.label4);
            this.Controls.Add(this.SocialMediaMessageTextBox);
            this.Controls.Add(this.PreviousButton);
            this.Controls.Add(this.DoneButton);
            this.Controls.Add(this.NextButton);
            this.Controls.Add(this.TagsTextBox);
            this.Controls.Add(this.DescriptionTextBox);
            this.Controls.Add(this.label3);
            this.Controls.Add(this.label2);
            this.Controls.Add(this.TitleTextBox);
            this.Controls.Add(this.label1);
            this.Name = "AudioEditWindow";
            this.Text = "AudioEditWindow";
            this.ResumeLayout(false);
            this.PerformLayout();

        }

        #endregion

        private System.Windows.Forms.Label label1;
        private System.Windows.Forms.TextBox TitleTextBox;
        private System.Windows.Forms.Label label2;
        private System.Windows.Forms.Label label3;
        private System.Windows.Forms.TextBox DescriptionTextBox;
        private System.Windows.Forms.TextBox TagsTextBox;
        private System.Windows.Forms.Button NextButton;
        private System.Windows.Forms.Button DoneButton;
        private System.Windows.Forms.Button PreviousButton;
        private System.Windows.Forms.TextBox SocialMediaMessageTextBox;
        private System.Windows.Forms.Label label4;
    }
}


text:
<component name="ProjectCodeStyleConfiguration">
  <code_scheme name="Project" version="173">
    <option name="FORMATTER_TAGS_ENABLED" value="true" />
    <AndroidXmlCodeStyleSettings>
      <option name="LAYOUT_SETTINGS">
        <value>
          <option name="INSERT_LINE_BREAK_BEFORE_NAMESPACE_DECLARATION" value="true" />
        </value>
      </option>
      <option name="MANIFEST_SETTINGS">
        <value>
          <option name="INSERT_LINE_BREAK_BEFORE_NAMESPACE_DECLARATION" value="true" />
        </value>
      </option>
      <option name="OTHER_SETTINGS">
        <value>
          <option name="INSERT_LINE_BREAK_BEFORE_NAMESPACE_DECLARATION" value="true" />
        </value>
      </option>
    </AndroidXmlCodeStyleSettings>
    <JavaCodeStyleSettings>
      <option name="CLASS_COUNT_TO_USE_IMPORT_ON_DEMAND" value="5" />
      <option name="NAMES_COUNT_TO_USE_IMPORT_ON_DEMAND" value="3" />
      <option name="PACKAGES_TO_USE_IMPORT_ON_DEMAND">
        <value>
          <package name="java.awt" withSubpackages="false" static="false" />
          <package name="javax.swing" withSubpackages="false" static="false" />
        </value>
      </option>
      <option name="IMPORT_LAYOUT_TABLE">
        <value>
          <package name="" withSubpackages="true" static="false" />
          <emptyLine />
          <package name="javax" withSubpackages="true" static="false" />
          <package name="java" withSubpackages="true" static="false" />
          <emptyLine />
          <package name="" withSubpackages="true" static="true" />
        </value>
      </option>
    </JavaCodeStyleSettings>
    <codeStyleSettings language="XML">
      <arrangement>
        <rules>

            <rule>
              <match>
                <AND>
                  <NAME>xmlns:android</NAME>
                  <XML_ATTRIBUTE />
                  <XML_NAMESPACE>^$</XML_NAMESPACE>
                </AND>
              </match>
            </rule>

            <rule>
              <match>
                <AND>
                  <NAME>xmlns:.*</NAME>
                  <XML_ATTRIBUTE />
                  <XML_NAMESPACE>^$</XML_NAMESPACE>
                </AND>
              </match>
              <order>BY_NAME</order>
            </rule>

            <rule>
              <match>
                <AND>
                  <NAME>.*:id</NAME>
                  <XML_ATTRIBUTE />
                  <XML_NAMESPACE>http://schemas.android.com/apk/res/android</XML_NAMESPACE>
                </AND>
              </match>
            </rule>

            <rule>
              <match>
                <AND>
                  <NAME>.*:name</NAME>
                  <XML_ATTRIBUTE />
                  <XML_NAMESPACE>http://schemas.android.com/apk/res/android</XML_NAMESPACE>
                </AND>
              </match>
            </rule>

            <rule>
              <match>
                <AND>
                  <NAME>name</NAME>
                  <XML_ATTRIBUTE />
                  <XML_NAMESPACE>^$</XML_NAMESPACE>
                </AND>
              </match>
            </rule>

            <rule>
              <match>
                <AND>
                  <NAME>style</NAME>
                  <XML_ATTRIBUTE />
                  <XML_NAMESPACE>^$</XML_NAMESPACE>
                </AND>
              </match>
            </rule>

            <rule>
              <match>
                <AND>
                  <NAME>.*</NAME>
                  <XML_ATTRIBUTE />
                  <XML_NAMESPACE>^$</XML_NAMESPACE>
                </AND>
              </match>
              <order>BY_NAME</order>
            </rule>

            <rule>
              <match>
                <AND>
                  <NAME>.*</NAME>
                  <XML_ATTRIBUTE />
                  <XML_NAMESPACE>http://schemas.android.com/apk/res/android</XML_NAMESPACE>
                </AND>
              </match>
              <order>ANDROID_ATTRIBUTE_ORDER</order>
            </rule>

            <rule>
              <match>
                <AND>
                  <NAME>.*</NAME>
                  <XML_ATTRIBUTE />
                  <XML_NAMESPACE>.*</XML_NAMESPACE>
                </AND>
              </match>
              <order>BY_NAME</order>
            </rule>

        </rules>
      </arrangement>
    </codeStyleSettings>
    <codeStyleSettings language="kotlin">
      <option name="ALIGN_MULTILINE_PARAMETERS_IN_CALLS" value="true" />
      <option name="ALIGN_MULTILINE_BINARY_OPERATION" value="true" />
      <option name="ALIGN_MULTILINE_EXTENDS_LIST" value="true" />
      <option name="ALIGN_MULTILINE_METHOD_BRACKETS" value="true" />
    </codeStyleSettings>
  </code_scheme>
</component>


text:
from __future__ import division, print_function, absolute_import

import functools
import operator
import sys
import warnings
import numbers
from collections import namedtuple
from multiprocessing import Pool
import inspect

import numpy as np

def _valarray(shape, value=np.nan, typecode=None):
    """Return an array of all values.
    """

    out = np.ones(shape, dtype=bool) * value
    if typecode is not None:
        out = out.astype(typecode)
    if not isinstance(out, np.ndarray):
        out = np.asarray(out)
    return out

def _lazywhere(cond, arrays, f, fillvalue=None, f2=None):
    """
    np.where(cond, x, fillvalue) always evaluates x even where cond is False.
    This one only evaluates f(arr1[cond], arr2[cond], ...).
    For example,
    >>> a, b = np.array([1, 2, 3, 4]), np.array([5, 6, 7, 8])
    >>> def f(a, b):
        return a*b
    >>> _lazywhere(a > 2, (a, b), f, np.nan)
    array([ nan,  nan,  21.,  32.])

    Notice, it assumes that all `arrays` are of the same shape, or can be
    broadcasted together.

    """
    if fillvalue is None:
        if f2 is None:
            raise ValueError("One of (fillvalue, f2) must be given.")
        else:
            fillvalue = np.nan
    else:
        if f2 is not None:
            raise ValueError("Only one of (fillvalue, f2) can be given.")

    arrays = np.broadcast_arrays(*arrays)
    temp = tuple(np.extract(cond, arr) for arr in arrays)
    tcode = np.mintypecode([a.dtype.char for a in arrays])
    out = _valarray(np.shape(arrays[0]), value=fillvalue, typecode=tcode)
    np.place(out, cond, f(*temp))
    if f2 is not None:
        temp = tuple(np.extract(~cond, arr) for arr in arrays)
        np.place(out, ~cond, f2(*temp))

    return out

def _lazyselect(condlist, choicelist, arrays, default=0):
    """
    Mimic `np.select(condlist, choicelist)`.

    Notice, it assumes that all `arrays` are of the same shape or can be
    broadcasted together.

    All functions in `choicelist` must accept array arguments in the order
    given in `arrays` and must return an array of the same shape as broadcasted
    `arrays`.

    Examples
    --------
    >>> x = np.arange(6)
    >>> np.select([x <3, x > 3], [x**2, x**3], default=0)
    array([  0,   1,   4,   0,  64, 125])

    >>> _lazyselect([x < 3, x > 3], [lambda x: x**2, lambda x: x**3], (x,))
    array([   0.,    1.,    4.,   0.,   64.,  125.])

    >>> a = -np.ones_like(x)
    >>> _lazyselect([x < 3, x > 3],
    ...             [lambda x, a: x**2, lambda x, a: a * x**3],
    ...             (x, a), default=np.nan)
    array([   0.,    1.,    4.,   nan,  -64., -125.])

    """
    arrays = np.broadcast_arrays(*arrays)
    tcode = np.mintypecode([a.dtype.char for a in arrays])
    out = _valarray(np.shape(arrays[0]), value=default, typecode=tcode)
    for index in range(len(condlist)):
        func, cond = choicelist[index], condlist[index]
        if np.all(cond is False):
            continue
        cond, _ = np.broadcast_arrays(cond, arrays[0])
        temp = tuple(np.extract(cond, arr) for arr in arrays)
        np.place(out, cond, func(*temp))
    return out

def _aligned_zeros(shape, dtype=float, order="C", align=None):
    """Allocate a new ndarray with aligned memory.

    Primary use case for this currently is working around a f2py issue
    in NumPy 1.9.1, where dtype.alignment is such that np.zeros() does
    not necessarily create arrays aligned up to it.

    """
    dtype = np.dtype(dtype)
    if align is None:
        align = dtype.alignment
    if not hasattr(shape, '__len__'):
        shape = (shape,)
    size = functools.reduce(operator.mul, shape) * dtype.itemsize
    buf = np.empty(size + align + 1, np.uint8)
    offset = buf.__array_interface__['data'][0] % align
    if offset != 0:
        offset = align - offset
    # Note: slices producing 0-size arrays do not necessarily change
    # data pointer --- so we use and allocate size+1
    buf = buf[offset:offset+size+1][:-1]
    data = np.ndarray(shape, dtype, buf, order=order)
    data.fill(0)
    return data

def _prune_array(array):
    """Return an array equivalent to the input array. If the input
    array is a view of a much larger array, copy its contents to a
    newly allocated array. Otherwise, return the input unchanged.
    """
    if array.base is not None and array.size < array.base.size // 2:
        return array.copy()
    return array

class DeprecatedImport(object):
    """
    Deprecated import with redirection and warning.

    Examples
    --------
    Suppose you previously had in some module::

        from foo import spam

    If this has to be deprecated, do::

        spam = DeprecatedImport("foo.spam", "baz")

    to redirect users to use "baz" module instead.

    """

    def __init__(self, old_module_name, new_module_name):
        self._old_name = old_module_name
        self._new_name = new_module_name
        __import__(self._new_name)
        self._mod = sys.modules[self._new_name]

    def __dir__(self):
        return dir(self._mod)

    def __getattr__(self, name):
        warnings.warn("Module %s is deprecated, use %s instead"
                      % (self._old_name, self._new_name),
                      DeprecationWarning)
        return getattr(self._mod, name)

# copy-pasted from scikit-learn utils/validation.py
def check_random_state(seed):
    """Turn seed into a np.random.RandomState instance

    If seed is None (or np.random), return the RandomState singleton used
    by np.random.
    If seed is an int, return a new RandomState instance seeded with seed.
    If seed is already a RandomState instance, return it.
    If seed is a new-style np.random.Generator, return it.
    Otherwise, raise ValueError.
    """
    if seed is None or seed is np.random:
        return np.random.mtrand._rand
    if isinstance(seed, (numbers.Integral, np.integer)):
        return np.random.RandomState(seed)
    if isinstance(seed, np.random.RandomState):
        return seed
    try:
        # Generator is only available in numpy >= 1.17
        if isinstance(seed, np.random.Generator):
            return seed
    except AttributeError:
        pass
    raise ValueError('%r cannot be used to seed a numpy.random.RandomState'
                     ' instance' % seed)

def _asarray_validated(a, check_finite=True,
                       sparse_ok=False, objects_ok=False, mask_ok=False,
                       as_inexact=False):
    """
    Helper function for SciPy argument validation.

    Many SciPy linear algebra functions do support arbitrary array-like
    input arguments. Examples of commonly unsupported inputs include
    matrices containing inf/nan, sparse matrix representations, and
    matrices with complicated elements.

    Parameters
    ----------
    a : array_like
        The array-like input.
    check_finite : bool, optional
        Whether to check that the input matrices contain only finite numbers.
        Disabling may give a performance gain, but may result in problems
        (crashes, non-termination) if the inputs do contain infinities or NaNs.
        Default: True
    sparse_ok : bool, optional
        True if scipy sparse matrices are allowed.
    objects_ok : bool, optional
        True if arrays with dype('O') are allowed.
    mask_ok : bool, optional
        True if masked arrays are allowed.
    as_inexact : bool, optional
        True to convert the input array to a np.inexact dtype.

    Returns
    -------
    ret : ndarray
        The converted validated array.

    """
    if not sparse_ok:
        import scipy.sparse
        if scipy.sparse.issparse(a):
            msg = ('Sparse matrices are not supported by this function. '
                   'Perhaps one of the scipy.sparse.linalg functions '
                   'would work instead.')
            raise ValueError(msg)
    if not mask_ok:
        if np.ma.isMaskedArray(a):
            raise ValueError('masked arrays are not supported')
    toarray = np.asarray_chkfinite if check_finite else np.asarray
    a = toarray(a)
    if not objects_ok:
        if a.dtype is np.dtype('O'):
            raise ValueError('object arrays are not supported')
    if as_inexact:
        if not np.issubdtype(a.dtype, np.inexact):
            a = toarray(a, dtype=np.float_)
    return a

# Add a replacement for inspect.getfullargspec()/
# The version below is borrowed from Django,
# https://github.com/django/django/pull/4846.

# Note an inconsistency between inspect.getfullargspec(func) and
# inspect.signature(func). If `func` is a bound method, the latter does *not*
# list `self` as a first argument, while the former *does*.
# Hence, cook up a common ground replacement: `getfullargspec_no_self` which
# mimics `inspect.getfullargspec` but does not list `self`.
#
# This way, the caller code does not need to know whether it uses a legacy
# .getfullargspec or a bright and shiny .signature.

FullArgSpec = namedtuple('FullArgSpec',
                         ['args', 'varargs', 'varkw', 'defaults',
                          'kwonlyargs', 'kwonlydefaults', 'annotations'])

def getfullargspec_no_self(func):
    """inspect.getfullargspec replacement using inspect.signature.

    If func is a bound method, do not list the 'self' parameter.

    Parameters
    ----------
    func : callable
        A callable to inspect

    Returns
    -------
    fullargspec : FullArgSpec(args, varargs, varkw, defaults, kwonlyargs,
                              kwonlydefaults, annotations)

        NOTE: if the first argument of `func` is self, it is *not*, I repeat
        *not*, included in fullargspec.args.
        This is done for consistency between inspect.getargspec() under
        Python 2.x, and inspect.signature() under Python 3.x.

    """
    sig = inspect.signature(func)
    args = [
        p.name for p in sig.parameters.values()
        if p.kind in [inspect.Parameter.POSITIONAL_OR_KEYWORD,
                      inspect.Parameter.POSITIONAL_ONLY]
    ]
    varargs = [
        p.name for p in sig.parameters.values()
        if p.kind == inspect.Parameter.VAR_POSITIONAL
    ]
    varargs = varargs[0] if varargs else None
    varkw = [
        p.name for p in sig.parameters.values()
        if p.kind == inspect.Parameter.VAR_KEYWORD
    ]
    varkw = varkw[0] if varkw else None
    defaults = tuple(
        p.default for p in sig.parameters.values()
        if (p.kind == inspect.Parameter.POSITIONAL_OR_KEYWORD and
           p.default is not p.empty)
    ) or None
    kwonlyargs = [
        p.name for p in sig.parameters.values()
        if p.kind == inspect.Parameter.KEYWORD_ONLY
    ]
    kwdefaults = {p.name: p.default for p in sig.parameters.values()
                  if p.kind == inspect.Parameter.KEYWORD_ONLY and
                  p.default is not p.empty}
    annotations = {p.name: p.annotation for p in sig.parameters.values()
                   if p.annotation is not p.empty}
    return FullArgSpec(args, varargs, varkw, defaults, kwonlyargs,
                       kwdefaults or None, annotations)

class MapWrapper(object):
    """
    Parallelisation wrapper for working with map-like callables, such as
    `multiprocessing.Pool.map`.

    Parameters
    ----------
    pool : int or map-like callable
        If `pool` is an integer, then it specifies the number of threads to
        use for parallelization. If ``int(pool) == 1``, then no parallel
        processing is used and the map builtin is used.
        If ``pool == -1``, then the pool will utilize all available CPUs.
        If `pool` is a map-like callable that follows the same
        calling sequence as the built-in map function, then this callable is
        used for parallelization.
    """
    def __init__(self, pool=1):
        self.pool = None
        self._mapfunc = map
        self._own_pool = False

        if callable(pool):
            self.pool = pool
            self._mapfunc = self.pool
        else:
            # user supplies a number
            if int(pool) == -1:
                # use as many processors as possible
                self.pool = Pool()
                self._mapfunc = self.pool.map
                self._own_pool = True
            elif int(pool) == 1:
                pass
            elif int(pool) > 1:
                # use the number of processors requested
                self.pool = Pool(processes=int(pool))
                self._mapfunc = self.pool.map
                self._own_pool = True
            else:
                raise RuntimeError("Number of workers specified must be -1,"
                                   " an int >= 1, or an object with a 'map' method")

    def __enter__(self):
        return self

    def __del__(self):
        self.close()
        self.terminate()

    def terminate(self):
        if self._own_pool:
            self.pool.terminate()

    def join(self):
        if self._own_pool:
            self.pool.join()

    def close(self):
        if self._own_pool:
            self.pool.close()

    def __exit__(self, exc_type, exc_value, traceback):
        if self._own_pool:
            self.pool.close()
            self.pool.terminate()

    def __call__(self, func, iterable):
        # only accept one iterable because that's all Pool.map accepts
        try:
            return self._mapfunc(func, iterable)
        except TypeError:
            # wrong number of arguments
            raise TypeError("The map-like callable must be of the"
                            " form f(func, iterable)")


text:
package dyvil.collection.impl;

import dyvil.annotation.internal.NonNull;
import dyvil.annotation.internal.Nullable;
import dyvil.array.ObjectArray;
import dyvil.collection.*;
import dyvil.math.MathUtils;
import dyvil.ref.InvalidReferenceException;
import dyvil.ref.ObjectRef;
import dyvil.util.Option;
import dyvil.util.Some;

import java.io.IOException;
import java.util.Iterator;
import java.util.NoSuchElementException;
import java.util.Objects;
import java.util.function.BiConsumer;
import java.util.function.Consumer;

public abstract class AbstractHashMap<K, V> implements Map<K, V>
{
	protected static final class HashEntry<K, V> implements Entry<K, V>, ObjectRef<V>
	{
		private static final long serialVersionUID = 6421167357975687099L;

		@Nullable
		public transient K               key;
		@Nullable
		public transient V               value;
		public transient int             hash;
		@Nullable
		public transient HashEntry<K, V> next;

		public HashEntry(K key, V value, int hash)
		{
			this.key = key;
			this.value = value;
			this.hash = hash;
		}

		public HashEntry(K key, V value, int hash, HashEntry<K, V> next)
		{
			this.key = key;
			this.value = value;
			this.hash = hash;
			this.next = next;
		}

		@Nullable
		@Override
		public V get()
		{
			this.validateReference();
			return this.value;
		}

		@Override
		public void set(V value)
		{
			this.validateReference();
			this.value = value;
		}

		private void validateReference()
		{
			if (this.isInvalid())
			{
				throw new InvalidReferenceException("Entry was removed from Map");
			}
		}

		@Nullable
		@Override
		public K getKey()
		{
			return this.key;
		}

		@Nullable
		@Override
		public V getValue()
		{
			return this.value;
		}

		public void invalidate()
		{
			this.key = null;
			this.value = null;
			this.hash = -1;
			this.next = null;
		}

		private boolean isInvalid()
		{
			return this.hash == -1 && this.key == null;
		}

		@Nullable
		@Override
		public String toString()
		{
			return this.key + " -> " + this.value;
		}

		@Override
		public boolean equals(Object obj)
		{
			return Entry.entryEquals(this, obj);
		}

		@Override
		public int hashCode()
		{
			return Entry.entryHashCode(this);
		}

		private void writeObject(java.io.@NonNull ObjectOutputStream out) throws IOException
		{
			out.defaultWriteObject();

			out.writeObject(this.key);
			out.writeObject(this.value);
			out.writeObject(this.next);
		}

		private void readObject(java.io.@NonNull ObjectInputStream in) throws IOException, ClassNotFoundException
		{
			in.defaultReadObject();

			this.key = (K) in.readObject();
			this.value = (V) in.readObject();
			this.next = (HashEntry<K, V>) in.readObject();
			this.hash = hash(this.key);
		}
	}

	protected abstract class EntryIterator<E> implements Iterator<E>
	{
		@Nullable HashEntry<K, V> next;        // next entry to return
		@Nullable HashEntry<K, V> current;    // current entry
		int index;        // current slot

		EntryIterator()
		{
			HashEntry<K, V>[] t = AbstractHashMap.this.entries;
			this.current = this.next = null;
			this.index = 0;
			// advance to first entry
			if (t != null && AbstractHashMap.this.size > 0)
			{
				this.advance(t);
			}
		}

		private void advance(HashEntry<K, V> @NonNull [] t)
		{
			while (true)
			{
				if (!(this.index < t.length && (this.next = t[this.index++]) == null))
				{
					break;
				}
			}
		}

		@Override
		public final boolean hasNext()
		{
			return this.next != null;
		}

		@Nullable
		final HashEntry<K, V> nextEntry()
		{
			HashEntry<K, V>[] t;
			HashEntry<K, V> e = this.next;
			if (e == null)
			{
				throw new NoSuchElementException();
			}
			if ((this.next = (this.current = e).next) == null && (t = AbstractHashMap.this.entries) != null)
			{
				this.advance(t);
			}
			return e;
		}

		@Override
		public final void remove()
		{
			HashEntry<K, V> e = this.current;
			if (e == null)
			{
				throw new IllegalStateException();
			}

			AbstractHashMap.this.removeEntry(e);
			this.current = null;
		}
	}

	private static final long serialVersionUID = 408161126967974108L;

	public static final float GROWTH_FACTOR       = 1.125F;
	public static final int   DEFAULT_CAPACITY    = 16;
	public static final float DEFAULT_LOAD_FACTOR = 0.75F;
	public static final int   MAX_ARRAY_SIZE      = Integer.MAX_VALUE - 8;

	protected transient int               size;
	protected transient HashEntry<K, V>[] entries;

	// Constructors

	public AbstractHashMap()
	{
		this.entries = (HashEntry<K, V>[]) new HashEntry[DEFAULT_CAPACITY];
	}

	public AbstractHashMap(int capacity)
	{
		if (capacity < 0)
		{
			throw new IllegalArgumentException("Invalid Capacity: " + capacity);
		}
		this.entries = (HashEntry<K, V>[]) new HashEntry[MathUtils.nextPowerOf2(grow(capacity))];
	}

	public AbstractHashMap(Entry<? extends K, ? extends V> @NonNull [] entries)
	{
		this(entries.length);
		this.putAllInternal(ObjectArray.asIterable(entries));
	}

	public AbstractHashMap(@NonNull Iterable<? extends @NonNull Entry<? extends K, ? extends V>> iterable)
	{
		this();
		this.putAllInternal(iterable);
	}

	public AbstractHashMap(@NonNull SizedIterable<? extends @NonNull Entry<? extends K, ? extends V>> iterable)
	{
		this(iterable.size());
		// Call the putAllInternal(Iterable) method to avoid redundant ensureCapacity call
		this.putAllInternal((Iterable<? extends @NonNull Entry<? extends K, ? extends V>>) iterable);
	}

	public AbstractHashMap(@NonNull Set<? extends @NonNull Entry<? extends K, ? extends V>> set)
	{
		this(set.size());
		this.loadDistinct(set);
	}

	public AbstractHashMap(@NonNull Map<? extends K, ? extends V> map)
	{
		this(map.size());
		this.loadDistinct(map);
	}

	public AbstractHashMap(@NonNull AbstractHashMap<? extends K, ? extends V> map)
	{
		this(map.size);
		this.size = map.size;

		final HashEntry<K, V>[] hashEntries = this.entries;
		final int length = hashEntries.length;

		for (HashEntry<? extends K, ? extends V> hashEntry : map.entries)
		{
			for (; hashEntry != null; hashEntry = hashEntry.next)
			{
				final int hash = hashEntry.hash;
				final int index = index(hash, length);
				hashEntries[index] = new HashEntry<>(hashEntry.key, hashEntry.value, hash, hashEntries[index]);
			}
		}
	}

	// Implementation Methods

	public static int hash(@Nullable Object key)
	{
		int h = key == null ? 0 : key.hashCode();
		h ^= h >>> 20 ^ h >>> 12;
		return h ^ h >>> 7 ^ h >>> 4;
	}

	public static int index(int h, int length)
	{
		return h & length - 1;
	}

	public static int grow(int size)
	{
		return (int) ((size + 1) * GROWTH_FACTOR);
	}

	protected void flatten()
	{
		this.ensureCapacityInternal(this.entries.length << 1);
	}

	public void ensureCapacity(int newCapacity)
	{
		if (newCapacity > this.entries.length)
		{
			this.ensureCapacityInternal(MathUtils.nextPowerOf2(newCapacity));
		}
	}

	protected void ensureCapacityInternal(int newCapacity)
	{
		HashEntry[] oldMap = this.entries;
		int oldCapacity = oldMap.length;

		// overflow-conscious code
		if (newCapacity - MAX_ARRAY_SIZE > 0)
		{
			if (oldCapacity == MAX_ARRAY_SIZE)
			{
				// Keep running with MAX_ARRAY_SIZE buckets
				return;
			}
			newCapacity = MAX_ARRAY_SIZE;
		}

		HashEntry[] newMap = this.entries = (HashEntry<K, V>[]) new HashEntry[newCapacity];
		for (int i = oldCapacity; i-- > 0; )
		{
			HashEntry e = oldMap[i];
			while (e != null)
			{
				int index = index(e.hash, newCapacity);
				HashEntry next = e.next;
				e.next = newMap[index];
				newMap[index] = e;
				e = next;
			}
		}

		this.updateThreshold(newCapacity);
	}

	protected void updateThreshold(int newCapacity)
	{
	}

	protected void putInternal(@Nullable K key, V value)
	{
		int hash = hash(key);
		int i = index(hash, this.entries.length);
		for (HashEntry<K, V> e = this.entries[i]; e != null; e = e.next)
		{
			Object k;
			if (e.hash == hash && ((k = e.key) == key || key != null && key.equals(k)))
			{
				e.value = value;
				return;
			}
		}

		this.addEntry(hash, key, value, i);
	}

	protected abstract void addEntry(int hash, K key, V value, int index);

	private void putAllInternal(@NonNull Iterable<? extends @NonNull Entry<? extends K, ? extends V>> iterable)
	{
		for (Entry<? extends K, ? extends V> entry : iterable)
		{
			this.putInternal(entry.getKey(), entry.getValue());
		}
	}

	protected void putAllInternal(@NonNull SizedIterable<? extends @NonNull Entry<? extends K, ? extends V>> map)
	{
		this.ensureCapacity(this.size + map.size());
		this.putAllInternal((Iterable<? extends @NonNull Entry<? extends K, ? extends V>>) map);
	}

	private void loadDistinct(@NonNull Iterable<? extends @NonNull Entry<? extends K, ? extends V>> iterable)
	{
		final HashEntry<K, V>[] entries = this.entries;
		final int length = this.entries.length;
		int size = 0;

		for (Entry<? extends K, ? extends V> entry : iterable)
		{
			final K key = entry.getKey();
			final int hash = hash(key);
			final int i = index(hash, length);

			entries[i] = new HashEntry<>(key, entry.getValue(), hash, entries[i]);
			size++;
		}
		this.size = size;
	}

	protected void removeEntry(@NonNull HashEntry<K, V> entry)
	{
		AbstractHashMap.this.size--;
		int index = index(entry.hash, AbstractHashMap.this.entries.length);
		HashEntry<K, V> e = AbstractHashMap.this.entries[index];

		if (e == entry)
		{
			AbstractHashMap.this.entries[index] = entry.next;
		}
		else
		{
			HashEntry<K, V> prev;
			do
			{
				prev = e;
				e = e.next;
			}
			while (e != entry);

			prev.next = entry.next;
		}

		entry.invalidate();
	}

	@Override
	public int size()
	{
		return this.size;
	}

	@Override
	public boolean isEmpty()
	{
		return this.size == 0;
	}

	@NonNull
	@Override
	public Iterator<Entry<K, V>> iterator()
	{
		return new EntryIterator<Entry<K, V>>()
		{
			@Nullable
			@Override
			public HashEntry<K, V> next()
			{
				return this.nextEntry();
			}

			@NonNull
			@Override
			public String toString()
			{
				return "EntryIterator(" + AbstractHashMap.this + ")";
			}
		};
	}

	@NonNull
	@Override
	public Iterator<K> keyIterator()
	{
		return new EntryIterator<K>()
		{
			@Nullable
			@Override
			public K next()
			{
				return this.nextEntry().key;
			}

			@NonNull
			@Override
			public String toString()
			{
				return "KeyIterator(" + AbstractHashMap.this + ")";
			}
		};
	}

	@NonNull
	@Override
	public Iterator<V> valueIterator()
	{
		return new EntryIterator<V>()
		{
			@Nullable
			@Override
			public V next()
			{
				return this.nextEntry().value;
			}

			@NonNull
			@Override
			public String toString()
			{
				return "ValueIterator(" + AbstractHashMap.this + ")";
			}
		};
	}

	@Override
	public void forEach(@NonNull Consumer<? super Entry<K, V>> action)
	{
		for (HashEntry<K, V> e : this.entries)
		{
			while (e != null)
			{
				action.accept(e);
				e = e.next;
			}
		}
	}

	@Override
	public void forEach(@NonNull BiConsumer<? super K, ? super V> action)
	{
		for (HashEntry<K, V> e : this.entries)
		{
			while (e != null)
			{
				action.accept(e.key, e.value);
				e = e.next;
			}
		}
	}

	@Override
	public boolean containsKey(Object key)
	{
		return this.get(key) != null;
	}

	@Override
	public boolean containsValue(Object value)
	{
		for (HashEntry<K, V> e : this.entries)
		{
			while (e != null)
			{
				if (e.value.equals(value))
				{
					return true;
				}
				e = e.next;
			}
		}
		return false;
	}

	@Override
	public boolean contains(Object key, Object value)
	{
		HashEntry<K, V> entry = this.getEntryInternal(key);
		return entry != null && Objects.equals(entry.value, value);
	}

	@Override
	public @Nullable V get(Object key)
	{
		HashEntry<K, V> entry = this.getEntryInternal(key);
		return entry == null ? null : entry.value;
	}

	@Nullable
	@Override
	public Entry<K, V> getEntry(Object key)
	{
		return this.getEntryInternal(key);
	}

	@Nullable
	protected HashEntry<K, V> getEntryInternal(@Nullable Object key)
	{
		if (key == null)
		{
			for (HashEntry<K, V> e = this.entries[0]; e != null; e = e.next)
			{
				if (e.key == null)
				{
					return e;
				}
			}
			return null;
		}

		int hash = hash(key);
		for (HashEntry<K, V> e = this.entries[index(hash, this.entries.length)]; e != null; e = e.next)
		{
			Object k;
			if (e.hash == hash && ((k = e.key) == key || key.equals(k)))
			{
				return e;
			}
		}
		return null;
	}

	@NonNull
	@Override
	public Option<V> getOption(Object key)
	{
		HashEntry<K, V> entry = this.getEntryInternal(key);
		return entry == null ? Option.apply() : new Some<>(entry.value);
	}

	@NonNull
	@Override
	public <RK, RV> MutableMap<RK, RV> emptyCopy()
	{
		return new dyvil.collection.mutable.HashMap<>();
	}

	@NonNull
	@Override
	public <RK, RV> MutableMap<RK, RV> emptyCopy(int capacity)
	{
		return new dyvil.collection.mutable.HashMap<>(capacity);
	}

	@NonNull
	@Override
	public MutableMap<K, V> mutableCopy()
	{
		return new dyvil.collection.mutable.HashMap<>(this);
	}

	@NonNull
	@Override
	public ImmutableMap<K, V> immutableCopy()
	{
		return new dyvil.collection.immutable.HashMap<>(this);
	}

	@Override
	public <RK, RV> ImmutableMap.Builder<RK, RV> immutableBuilder()
	{
		return dyvil.collection.immutable.HashMap.builder();
	}

	@Override
	public <RK, RV> ImmutableMap.Builder<RK, RV> immutableBuilder(int capacity)
	{
		return dyvil.collection.immutable.HashMap.builder(capacity);
	}

	@Override
	public java.util.Map<K, V> toJava()
	{
		java.util.HashMap<K, V> map = new java.util.HashMap<>(this.size);
		for (Entry<K, V> entry : this)
		{
			map.put(entry.getKey(), entry.getValue());
		}
		return map;
	}

	@Override
	public String toString()
	{
		if (this.size == 0)
		{
			return Map.EMPTY_STRING;
		}

		final StringBuilder builder = new StringBuilder(Map.START_STRING);

		for (HashEntry<K, V> entry : this.entries)
		{
			for (; entry != null; entry = entry.next)
			{
				builder.append(entry.key).append(Map.KEY_VALUE_SEPARATOR_STRING).append(entry.value)
				       .append(Map.ENTRY_SEPARATOR_STRING);
			}
		}

		final int len = builder.length();
		return builder.replace(len - Map.ENTRY_SEPARATOR_STRING.length(), len, Map.END_STRING).toString();
	}

	@Override
	public boolean equals(Object obj)
	{
		return Map.mapEquals(this, obj);
	}

	@Override
	public int hashCode()
	{
		return Map.mapHashCode(this);
	}

	private void writeObject(java.io.@NonNull ObjectOutputStream out) throws IOException
	{
		out.defaultWriteObject();

		int len = this.entries.length;

		out.writeInt(this.size);
		out.writeInt(len);

		// Write key-value pairs, sequentially
		for (HashEntry<K, V> entry : this.entries)
		{
			for (HashEntry<K, V> subEntry = entry; subEntry != null; subEntry = subEntry.next)
			{
				out.writeObject(subEntry.key);
				out.writeObject(subEntry.value);
			}
		}
	}

	private void readObject(java.io.@NonNull ObjectInputStream in) throws IOException, ClassNotFoundException
	{
		in.defaultReadObject();

		this.size = in.readInt();
		int len = in.readInt();

		this.entries = (HashEntry<K, V>[]) new HashEntry[len];
		for (int i = 0; i < len; i++)
		{
			this.putInternal((K) in.readObject(), (V) in.readObject());
		}
	}
}


text:
namespace arangodb {
class WorkMonitorHandler : public arangodb::RestBaseHandler {
 public:
  explicit WorkMonitorHandler(GeneralRequest*, GeneralResponse*);

 public:
  bool isDirect() const override;
  status execute() override;
};
}

#endif


text:
package com.app.nfsclient.cloud;

public class AndroidBackupServiceAgent {

}


text:
"use strict";

var thrift = require('thrift');
var Thrift = thrift.Thrift;
var Q = thrift.Q;

var ttypes = module.exports = {};
ttypes.ImageType = {
  'JPEG' : 1,
  'PNG' : 2
};
ttypes.Industry = {
  'BANKING' : 1,
  'ECOMMERCE' : 2,
  'EDUCATION' : 3,
  'ENTERTAINMENT' : 4,
  'GOVERMENT' : 5,
  'MARKETING' : 6,
  'RETAIL' : 7,
  'TECH' : 8,
  'AEROSPACE' : 9,
  'ROBOTICS' : 10
};
ttypes.Tier = {
  'FREE' : 1,
  'PAID' : 2
};
ttypes.TimeUnit = {
  'MILLIS' : 1,
  'SECONDS' : 2,
  'MINUTES' : 3,
  'HOURS' : 4,
  'DAYS' : 5,
  'WEEKS' : 6
};
ttypes.ProgrammingLanguage = {
  'JAVA' : 1,
  'CPP' : 2,
  'C_SHARP' : 3,
  'C' : 4,
  'OBJECTIVE_C' : 5,
  'SWIFT' : 6,
  'DOT_NET' : 7,
  'RUBY' : 8,
  'GROOVY' : 9,
  'PYTHON' : 10,
  'PHP' : 11,
  'NODE' : 12,
  'DART' : 13,
  'OTHER' : 14
};
ttypes.Role = {
  'DEVELOPER' : 1,
  'OPERATIONS' : 2,
  'MANAGER' : 3,
  'PRODUCT' : 4,
  'QA' : 5,
  'FAN' : 6
};
ttypes.Urgency = {
  'LOW' : 1,
  'MEDIUM' : 2,
  'HIGH' : 3
};
var LengthOfTime = module.exports.LengthOfTime = function(args) {
  this.unit = null;
  this.value = null;
  if (args) {
    if (args.unit !== undefined && args.unit !== null) {
      this.unit = args.unit;
    } else {
      throw new Thrift.TProtocolException(Thrift.TProtocolExceptionType.UNKNOWN, 'Required field unit is unset!');
    }
    if (args.value !== undefined && args.value !== null) {
      this.value = args.value;
    } else {
      throw new Thrift.TProtocolException(Thrift.TProtocolExceptionType.UNKNOWN, 'Required field value is unset!');
    }
  }
};
LengthOfTime.prototype = {};
LengthOfTime.prototype.read = function(input) {
  input.readStructBegin();
  while (true)
  {
    var ret = input.readFieldBegin();
    var fname = ret.fname;
    var ftype = ret.ftype;
    var fid = ret.fid;
    if (ftype == Thrift.Type.STOP) {
      break;
    }
    switch (fid)
    {
      case 1:
      if (ftype == Thrift.Type.I32) {
        this.unit = input.readI32();
      } else {
        input.skip(ftype);
      }
      break;
      case 2:
      if (ftype == Thrift.Type.I64) {
        this.value = input.readI64();
      } else {
        input.skip(ftype);
      }
      break;
      default:
        input.skip(ftype);
    }
    input.readFieldEnd();
  }
  input.readStructEnd();
  return;
};

LengthOfTime.prototype.write = function(output) {
  output.writeStructBegin('LengthOfTime');
  if (this.unit !== null && this.unit !== undefined) {
    output.writeFieldBegin('unit', Thrift.Type.I32, 1);
    output.writeI32(this.unit);
    output.writeFieldEnd();
  }
  if (this.value !== null && this.value !== undefined) {
    output.writeFieldBegin('value', Thrift.Type.I64, 2);
    output.writeI64(this.value);
    output.writeFieldEnd();
  }
  output.writeFieldStop();
  output.writeStructEnd();
  return;
};

var Dimension = module.exports.Dimension = function(args) {
  this.width = null;
  this.height = null;
  if (args) {
    if (args.width !== undefined && args.width !== null) {
      this.width = args.width;
    } else {
      throw new Thrift.TProtocolException(Thrift.TProtocolExceptionType.UNKNOWN, 'Required field width is unset!');
    }
    if (args.height !== undefined && args.height !== null) {
      this.height = args.height;
    } else {
      throw new Thrift.TProtocolException(Thrift.TProtocolExceptionType.UNKNOWN, 'Required field height is unset!');
    }
  }
};
Dimension.prototype = {};
Dimension.prototype.read = function(input) {
  input.readStructBegin();
  while (true)
  {
    var ret = input.readFieldBegin();
    var fname = ret.fname;
    var ftype = ret.ftype;
    var fid = ret.fid;
    if (ftype == Thrift.Type.STOP) {
      break;
    }
    switch (fid)
    {
      case 1:
      if (ftype == Thrift.Type.I32) {
        this.width = input.readI32();
      } else {
        input.skip(ftype);
      }
      break;
      case 2:
      if (ftype == Thrift.Type.I32) {
        this.height = input.readI32();
      } else {
        input.skip(ftype);
      }
      break;
      default:
        input.skip(ftype);
    }
    input.readFieldEnd();
  }
  input.readStructEnd();
  return;
};

Dimension.prototype.write = function(output) {
  output.writeStructBegin('Dimension');
  if (this.width !== null && this.width !== undefined) {
    output.writeFieldBegin('width', Thrift.Type.I32, 1);
    output.writeI32(this.width);
    output.writeFieldEnd();
  }
  if (this.height !== null && this.height !== undefined) {
    output.writeFieldBegin('height', Thrift.Type.I32, 2);
    output.writeI32(this.height);
    output.writeFieldEnd();
  }
  output.writeFieldStop();
  output.writeStructEnd();
  return;
};

var Image = module.exports.Image = function(args) {
  this.imageType = null;
  this.data = null;
  this.dimension = null;
  if (args) {
    if (args.imageType !== undefined && args.imageType !== null) {
      this.imageType = args.imageType;
    }
    if (args.data !== undefined && args.data !== null) {
      this.data = args.data;
    }
    if (args.dimension !== undefined && args.dimension !== null) {
      this.dimension = new ttypes.Dimension(args.dimension);
    }
  }
};
Image.prototype = {};
Image.prototype.read = function(input) {
  input.readStructBegin();
  while (true)
  {
    var ret = input.readFieldBegin();
    var fname = ret.fname;
    var ftype = ret.ftype;
    var fid = ret.fid;
    if (ftype == Thrift.Type.STOP) {
      break;
    }
    switch (fid)
    {
      case 1:
      if (ftype == Thrift.Type.I32) {
        this.imageType = input.readI32();
      } else {
        input.skip(ftype);
      }
      break;
      case 2:
      if (ftype == Thrift.Type.STRING) {
        this.data = input.readBinary();
      } else {
        input.skip(ftype);
      }
      break;
      case 3:
      if (ftype == Thrift.Type.STRUCT) {
        this.dimension = new ttypes.Dimension();
        this.dimension.read(input);
      } else {
        input.skip(ftype);
      }
      break;
      default:
        input.skip(ftype);
    }
    input.readFieldEnd();
  }
  input.readStructEnd();
  return;
};

Image.prototype.write = function(output) {
  output.writeStructBegin('Image');
  if (this.imageType !== null && this.imageType !== undefined) {
    output.writeFieldBegin('imageType', Thrift.Type.I32, 1);
    output.writeI32(this.imageType);
    output.writeFieldEnd();
  }
  if (this.data !== null && this.data !== undefined) {
    output.writeFieldBegin('data', Thrift.Type.STRING, 2);
    output.writeBinary(this.data);
    output.writeFieldEnd();
  }
  if (this.dimension !== null && this.dimension !== undefined) {
    output.writeFieldBegin('dimension', Thrift.Type.STRUCT, 3);
    this.dimension.write(output);
    output.writeFieldEnd();
  }
  output.writeFieldStop();
  output.writeStructEnd();
  return;
};

var Message = module.exports.Message = function(args) {
  this.messageId = null;
  this.body = null;
  this.urgency = 1;
  this.timeOfCreation = null;
  this.timeMessageReceived = null;
  this.applicationName = null;
  this.hostname = null;
  this.macAddress = null;
  this.isTruncated = false;
  this.title = null;
  this.applicationId = null;
  this.deviceName = null;
  if (args) {
    if (args.messageId !== undefined && args.messageId !== null) {
      this.messageId = args.messageId;
    }
    if (args.body !== undefined && args.body !== null) {
      this.body = args.body;
    }
    if (args.urgency !== undefined && args.urgency !== null) {
      this.urgency = args.urgency;
    }
    if (args.timeOfCreation !== undefined && args.timeOfCreation !== null) {
      this.timeOfCreation = args.timeOfCreation;
    }
    if (args.timeMessageReceived !== undefined && args.timeMessageReceived !== null) {
      this.timeMessageReceived = args.timeMessageReceived;
    }
    if (args.applicationName !== undefined && args.applicationName !== null) {
      this.applicationName = args.applicationName;
    }
    if (args.hostname !== undefined && args.hostname !== null) {
      this.hostname = args.hostname;
    }
    if (args.macAddress !== undefined && args.macAddress !== null) {
      this.macAddress = args.macAddress;
    }
    if (args.isTruncated !== undefined && args.isTruncated !== null) {
      this.isTruncated = args.isTruncated;
    }
    if (args.title !== undefined && args.title !== null) {
      this.title = args.title;
    }
    if (args.applicationId !== undefined && args.applicationId !== null) {
      this.applicationId = args.applicationId;
    }
    if (args.deviceName !== undefined && args.deviceName !== null) {
      this.deviceName = args.deviceName;
    }
  }
};
Message.prototype = {};
Message.prototype.read = function(input) {
  input.readStructBegin();
  while (true)
  {
    var ret = input.readFieldBegin();
    var fname = ret.fname;
    var ftype = ret.ftype;
    var fid = ret.fid;
    if (ftype == Thrift.Type.STOP) {
      break;
    }
    switch (fid)
    {
      case 1:
      if (ftype == Thrift.Type.STRING) {
        this.messageId = input.readString();
      } else {
        input.skip(ftype);
      }
      break;
      case 2:
      if (ftype == Thrift.Type.STRING) {
        this.body = input.readString();
      } else {
        input.skip(ftype);
      }
      break;
      case 3:
      if (ftype == Thrift.Type.I32) {
        this.urgency = input.readI32();
      } else {
        input.skip(ftype);
      }
      break;
      case 4:
      if (ftype == Thrift.Type.I64) {
        this.timeOfCreation = input.readI64();
      } else {
        input.skip(ftype);
      }
      break;
      case 5:
      if (ftype == Thrift.Type.I64) {
        this.timeMessageReceived = input.readI64();
      } else {
        input.skip(ftype);
      }
      break;
      case 6:
      if (ftype == Thrift.Type.STRING) {
        this.applicationName = input.readString();
      } else {
        input.skip(ftype);
      }
      break;
      case 7:
      if (ftype == Thrift.Type.STRING) {
        this.hostname = input.readString();
      } else {
        input.skip(ftype);
      }
      break;
      case 8:
      if (ftype == Thrift.Type.STRING) {
        this.macAddress = input.readString();
      } else {
        input.skip(ftype);
      }
      break;
      case 9:
      if (ftype == Thrift.Type.BOOL) {
        this.isTruncated = input.readBool();
      } else {
        input.skip(ftype);
      }
      break;
      case 10:
      if (ftype == Thrift.Type.STRING) {
        this.title = input.readString();
      } else {
        input.skip(ftype);
      }
      break;
      case 11:
      if (ftype == Thrift.Type.STRING) {
        this.applicationId = input.readString();
      } else {
        input.skip(ftype);
      }
      break;
      case 12:
      if (ftype == Thrift.Type.STRING) {
        this.deviceName = input.readString();
      } else {
        input.skip(ftype);
      }
      break;
      default:
        input.skip(ftype);
    }
    input.readFieldEnd();
  }
  input.readStructEnd();
  return;
};

Message.prototype.write = function(output) {
  output.writeStructBegin('Message');
  if (this.messageId !== null && this.messageId !== undefined) {
    output.writeFieldBegin('messageId', Thrift.Type.STRING, 1);
    output.writeString(this.messageId);
    output.writeFieldEnd();
  }
  if (this.body !== null && this.body !== undefined) {
    output.writeFieldBegin('body', Thrift.Type.STRING, 2);
    output.writeString(this.body);
    output.writeFieldEnd();
  }
  if (this.urgency !== null && this.urgency !== undefined) {
    output.writeFieldBegin('urgency', Thrift.Type.I32, 3);
    output.writeI32(this.urgency);
    output.writeFieldEnd();
  }
  if (this.timeOfCreation !== null && this.timeOfCreation !== undefined) {
    output.writeFieldBegin('timeOfCreation', Thrift.Type.I64, 4);
    output.writeI64(this.timeOfCreation);
    output.writeFieldEnd();
  }
  if (this.timeMessageReceived !== null && this.timeMessageReceived !== undefined) {
    output.writeFieldBegin('timeMessageReceived', Thrift.Type.I64, 5);
    output.writeI64(this.timeMessageReceived);
    output.writeFieldEnd();
  }
  if (this.applicationName !== null && this.applicationName !== undefined) {
    output.writeFieldBegin('applicationName', Thrift.Type.STRING, 6);
    output.writeString(this.applicationName);
    output.writeFieldEnd();
  }
  if (this.hostname !== null && this.hostname !== undefined) {
    output.writeFieldBegin('hostname', Thrift.Type.STRING, 7);
    output.writeString(this.hostname);
    output.writeFieldEnd();
  }
  if (this.macAddress !== null && this.macAddress !== undefined) {
    output.writeFieldBegin('macAddress', Thrift.Type.STRING, 8);
    output.writeString(this.macAddress);
    output.writeFieldEnd();
  }
  if (this.isTruncated !== null && this.isTruncated !== undefined) {
    output.writeFieldBegin('isTruncated', Thrift.Type.BOOL, 9);
    output.writeBool(this.isTruncated);
    output.writeFieldEnd();
  }
  if (this.title !== null && this.title !== undefined) {
    output.writeFieldBegin('title', Thrift.Type.STRING, 10);
    output.writeString(this.title);
    output.writeFieldEnd();
  }
  if (this.applicationId !== null && this.applicationId !== undefined) {
    output.writeFieldBegin('applicationId', Thrift.Type.STRING, 11);
    output.writeString(this.applicationId);
    output.writeFieldEnd();
  }
  if (this.deviceName !== null && this.deviceName !== undefined) {
    output.writeFieldBegin('deviceName', Thrift.Type.STRING, 12);
    output.writeString(this.deviceName);
    output.writeFieldEnd();
  }
  output.writeFieldStop();
  output.writeStructEnd();
  return;
};

var Organization = module.exports.Organization = function(args) {
  this.organizationId = null;
  this.organizationName = null;
  this.website = null;
  this.logo = null;
  this.techStack = null;
  this.owners = null;
  this.organizationEmail = null;
  this.stockMarketSymbol = null;
  this.logoLink = null;
  this.industry = null;
  this.tier = 1;
  this.organizationDescription = null;
  this.githubProfile = null;
  if (args) {
    if (args.organizationId !== undefined && args.organizationId !== null) {
      this.organizationId = args.organizationId;
    }
    if (args.organizationName !== undefined && args.organizationName !== null) {
      this.organizationName = args.organizationName;
    }
    if (args.website !== undefined && args.website !== null) {
      this.website = args.website;
    }
    if (args.logo !== undefined && args.logo !== null) {
      this.logo = new ttypes.Image(args.logo);
    }
    if (args.techStack !== undefined && args.techStack !== null) {
      this.techStack = args.techStack;
    }
    if (args.owners !== undefined && args.owners !== null) {
      this.owners = Thrift.copyList(args.owners, [null]);
    }
    if (args.organizationEmail !== undefined && args.organizationEmail !== null) {
      this.organizationEmail = args.organizationEmail;
    }
    if (args.stockMarketSymbol !== undefined && args.stockMarketSymbol !== null) {
      this.stockMarketSymbol = args.stockMarketSymbol;
    }
    if (args.logoLink !== undefined && args.logoLink !== null) {
      this.logoLink = args.logoLink;
    }
    if (args.industry !== undefined && args.industry !== null) {
      this.industry = args.industry;
    }
    if (args.tier !== undefined && args.tier !== null) {
      this.tier = args.tier;
    }
    if (args.organizationDescription !== undefined && args.organizationDescription !== null) {
      this.organizationDescription = args.organizationDescription;
    }
    if (args.githubProfile !== undefined && args.githubProfile !== null) {
      this.githubProfile = args.githubProfile;
    }
  }
};
Organization.prototype = {};
Organization.prototype.read = function(input) {
  input.readStructBegin();
  while (true)
  {
    var ret = input.readFieldBegin();
    var fname = ret.fname;
    var ftype = ret.ftype;
    var fid = ret.fid;
    if (ftype == Thrift.Type.STOP) {
      break;
    }
    switch (fid)
    {
      case 1:
      if (ftype == Thrift.Type.STRING) {
        this.organizationId = input.readString();
      } else {
        input.skip(ftype);
      }
      break;
      case 2:
      if (ftype == Thrift.Type.STRING) {
        this.organizationName = input.readString();
      } else {
        input.skip(ftype);
      }
      break;
      case 3:
      if (ftype == Thrift.Type.STRING) {
        this.website = input.readString();
      } else {
        input.skip(ftype);
      }
      break;
      case 4:
      if (ftype == Thrift.Type.STRUCT) {
        this.logo = new ttypes.Image();
        this.logo.read(input);
      } else {
        input.skip(ftype);
      }
      break;
      case 5:
      if (ftype == Thrift.Type.STRING) {
        this.techStack = input.readString();
      } else {
        input.skip(ftype);
      }
      break;
      case 6:
      if (ftype == Thrift.Type.LIST) {
        var _size0 = 0;
        var _rtmp34;
        this.owners = [];
        var _etype3 = 0;
        _rtmp34 = input.readListBegin();
        _etype3 = _rtmp34.etype;
        _size0 = _rtmp34.size;
        for (var _i5 = 0; _i5 < _size0; ++_i5)
        {
          var elem6 = null;
          elem6 = input.readString();
          this.owners.push(elem6);
        }
        input.readListEnd();
      } else {
        input.skip(ftype);
      }
      break;
      case 7:
      if (ftype == Thrift.Type.STRING) {
        this.organizationEmail = input.readString();
      } else {
        input.skip(ftype);
      }
      break;
      case 8:
      if (ftype == Thrift.Type.STRING) {
        this.stockMarketSymbol = input.readString();
      } else {
        input.skip(ftype);
      }
      break;
      case 9:
      if (ftype == Thrift.Type.STRING) {
        this.logoLink = input.readString();
      } else {
        input.skip(ftype);
      }
      break;
      case 10:
      if (ftype == Thrift.Type.I32) {
        this.industry = input.readI32();
      } else {
        input.skip(ftype);
      }
      break;
      case 11:
      if (ftype == Thrift.Type.I32) {
        this.tier = input.readI32();
      } else {
        input.skip(ftype);
      }
      break;
      case 12:
      if (ftype == Thrift.Type.STRING) {
        this.organizationDescription = input.readString();
      } else {
        input.skip(ftype);
      }
      break;
      case 13:
      if (ftype == Thrift.Type.STRING) {
        this.githubProfile = input.readString();
      } else {
        input.skip(ftype);
      }
      break;
      default:
        input.skip(ftype);
    }
    input.readFieldEnd();
  }
  input.readStructEnd();
  return;
};

Organization.prototype.write = function(output) {
  output.writeStructBegin('Organization');
  if (this.organizationId !== null && this.organizationId !== undefined) {
    output.writeFieldBegin('organizationId', Thrift.Type.STRING, 1);
    output.writeString(this.organizationId);
    output.writeFieldEnd();
  }
  if (this.organizationName !== null && this.organizationName !== undefined) {
    output.writeFieldBegin('organizationName', Thrift.Type.STRING, 2);
    output.writeString(this.organizationName);
    output.writeFieldEnd();
  }
  if (this.website !== null && this.website !== undefined) {
    output.writeFieldBegin('website', Thrift.Type.STRING, 3);
    output.writeString(this.website);
    output.writeFieldEnd();
  }
  if (this.logo !== null && this.logo !== undefined) {
    output.writeFieldBegin('logo', Thrift.Type.STRUCT, 4);
    this.logo.write(output);
    output.writeFieldEnd();
  }
  if (this.techStack !== null && this.techStack !== undefined) {
    output.writeFieldBegin('techStack', Thrift.Type.STRING, 5);
    output.writeString(this.techStack);
    output.writeFieldEnd();
  }
  if (this.owners !== null && this.owners !== undefined) {
    output.writeFieldBegin('owners', Thrift.Type.LIST, 6);
    output.writeListBegin(Thrift.Type.STRING, this.owners.length);
    for (var iter7 in this.owners)
    {
      if (this.owners.hasOwnProperty(iter7))
      {
        iter7 = this.owners[iter7];
        output.writeString(iter7);
      }
    }
    output.writeListEnd();
    output.writeFieldEnd();
  }
  if (this.organizationEmail !== null && this.organizationEmail !== undefined) {
    output.writeFieldBegin('organizationEmail', Thrift.Type.STRING, 7);
    output.writeString(this.organizationEmail);
    output.writeFieldEnd();
  }
  if (this.stockMarketSymbol !== null && this.stockMarketSymbol !== undefined) {
    output.writeFieldBegin('stockMarketSymbol', Thrift.Type.STRING, 8);
    output.writeString(this.stockMarketSymbol);
    output.writeFieldEnd();
  }
  if (this.logoLink !== null && this.logoLink !== undefined) {
    output.writeFieldBegin('logoLink', Thrift.Type.STRING, 9);
    output.writeString(this.logoLink);
    output.writeFieldEnd();
  }
  if (this.industry !== null && this.industry !== undefined) {
    output.writeFieldBegin('industry', Thrift.Type.I32, 10);
    output.writeI32(this.industry);
    output.writeFieldEnd();
  }
  if (this.tier !== null && this.tier !== undefined) {
    output.writeFieldBegin('tier', Thrift.Type.I32, 11);
    output.writeI32(this.tier);
    output.writeFieldEnd();
  }
  if (this.organizationDescription !== null && this.organizationDescription !== undefined) {
    output.writeFieldBegin('organizationDescription', Thrift.Type.STRING, 12);
    output.writeString(this.organizationDescription);
    output.writeFieldEnd();
  }
  if (this.githubProfile !== null && this.githubProfile !== undefined) {
    output.writeFieldBegin('githubProfile', Thrift.Type.STRING, 13);
    output.writeString(this.githubProfile);
    output.writeFieldEnd();
  }
  output.writeFieldStop();
  output.writeStructEnd();
  return;
};

var User = module.exports.User = function(args) {
  this.email = null;
  this.userId = null;
  this.name = null;
  this.roles = [1];
  this.profileImage = null;
  this.profileImageLink = null;
  this.githubProfile = null;
  this.firstName = null;
  this.middleName = null;
  this.lastName = null;
  this.birthdate = null;
  this.timeUserJoined = null;
  if (args) {
    if (args.email !== undefined && args.email !== null) {
      this.email = args.email;
    }
    if (args.userId !== undefined && args.userId !== null) {
      this.userId = args.userId;
    }
    if (args.name !== undefined && args.name !== null) {
      this.name = args.name;
    }
    if (args.roles !== undefined && args.roles !== null) {
      this.roles = Thrift.copyList(args.roles, [null]);
    }
    if (args.profileImage !== undefined && args.profileImage !== null) {
      this.profileImage = new ttypes.Image(args.profileImage);
    }
    if (args.profileImageLink !== undefined && args.profileImageLink !== null) {
      this.profileImageLink = args.profileImageLink;
    }
    if (args.githubProfile !== undefined && args.githubProfile !== null) {
      this.githubProfile = args.githubProfile;
    }
    if (args.firstName !== undefined && args.firstName !== null) {
      this.firstName = args.firstName;
    }
    if (args.middleName !== undefined && args.middleName !== null) {
      this.middleName = args.middleName;
    }
    if (args.lastName !== undefined && args.lastName !== null) {
      this.lastName = args.lastName;
    }
    if (args.birthdate !== undefined && args.birthdate !== null) {
      this.birthdate = args.birthdate;
    }
    if (args.timeUserJoined !== undefined && args.timeUserJoined !== null) {
      this.timeUserJoined = args.timeUserJoined;
    }
  }
};
User.prototype = {};
User.prototype.read = function(input) {
  input.readStructBegin();
  while (true)
  {
    var ret = input.readFieldBegin();
    var fname = ret.fname;
    var ftype = ret.ftype;
    var fid = ret.fid;
    if (ftype == Thrift.Type.STOP) {
      break;
    }
    switch (fid)
    {
      case 1:
      if (ftype == Thrift.Type.STRING) {
        this.email = input.readString();
      } else {
        input.skip(ftype);
      }
      break;
      case 2:
      if (ftype == Thrift.Type.STRING) {
        this.userId = input.readString();
      } else {
        input.skip(ftype);
      }
      break;
      case 3:
      if (ftype == Thrift.Type.STRING) {
        this.name = input.readString();
      } else {
        input.skip(ftype);
      }
      break;
      case 4:
      if (ftype == Thrift.Type.SET) {
        var _size8 = 0;
        var _rtmp312;
        this.roles = [];
        var _etype11 = 0;
        _rtmp312 = input.readSetBegin();
        _etype11 = _rtmp312.etype;
        _size8 = _rtmp312.size;
        for (var _i13 = 0; _i13 < _size8; ++_i13)
        {
          var elem14 = null;
          elem14 = input.readI32();
          this.roles.push(elem14);
        }
        input.readSetEnd();
      } else {
        input.skip(ftype);
      }
      break;
      case 5:
      if (ftype == Thrift.Type.STRUCT) {
        this.profileImage = new ttypes.Image();
        this.profileImage.read(input);
      } else {
        input.skip(ftype);
      }
      break;
      case 6:
      if (ftype == Thrift.Type.STRING) {
        this.profileImageLink = input.readString();
      } else {
        input.skip(ftype);
      }
      break;
      case 7:
      if (ftype == Thrift.Type.STRING) {
        this.githubProfile = input.readString();
      } else {
        input.skip(ftype);
      }
      break;
      case 8:
      if (ftype == Thrift.Type.STRING) {
        this.firstName = input.readString();
      } else {
        input.skip(ftype);
      }
      break;
      case 9:
      if (ftype == Thrift.Type.STRING) {
        this.middleName = input.readString();
      } else {
        input.skip(ftype);
      }
      break;
      case 10:
      if (ftype == Thrift.Type.STRING) {
        this.lastName = input.readString();
      } else {
        input.skip(ftype);
      }
      break;
      case 11:
      if (ftype == Thrift.Type.I64) {
        this.birthdate = input.readI64();
      } else {
        input.skip(ftype);
      }
      break;
      case 12:
      if (ftype == Thrift.Type.I64) {
        this.timeUserJoined = input.readI64();
      } else {
        input.skip(ftype);
      }
      break;
      default:
        input.skip(ftype);
    }
    input.readFieldEnd();
  }
  input.readStructEnd();
  return;
};

User.prototype.write = function(output) {
  output.writeStructBegin('User');
  if (this.email !== null && this.email !== undefined) {
    output.writeFieldBegin('email', Thrift.Type.STRING, 1);
    output.writeString(this.email);
    output.writeFieldEnd();
  }
  if (this.userId !== null && this.userId !== undefined) {
    output.writeFieldBegin('userId', Thrift.Type.STRING, 2);
    output.writeString(this.userId);
    output.writeFieldEnd();
  }
  if (this.name !== null && this.name !== undefined) {
    output.writeFieldBegin('name', Thrift.Type.STRING, 3);
    output.writeString(this.name);
    output.writeFieldEnd();
  }
  if (this.roles !== null && this.roles !== undefined) {
    output.writeFieldBegin('roles', Thrift.Type.SET, 4);
    output.writeSetBegin(Thrift.Type.I32, this.roles.length);
    for (var iter15 in this.roles)
    {
      if (this.roles.hasOwnProperty(iter15))
      {
        iter15 = this.roles[iter15];
        output.writeI32(iter15);
      }
    }
    output.writeSetEnd();
    output.writeFieldEnd();
  }
  if (this.profileImage !== null && this.profileImage !== undefined) {
    output.writeFieldBegin('profileImage', Thrift.Type.STRUCT, 5);
    this.profileImage.write(output);
    output.writeFieldEnd();
  }
  if (this.profileImageLink !== null && this.profileImageLink !== undefined) {
    output.writeFieldBegin('profileImageLink', Thrift.Type.STRING, 6);
    output.writeString(this.profileImageLink);
    output.writeFieldEnd();
  }
  if (this.githubProfile !== null && this.githubProfile !== undefined) {
    output.writeFieldBegin('githubProfile', Thrift.Type.STRING, 7);
    output.writeString(this.githubProfile);
    output.writeFieldEnd();
  }
  if (this.firstName !== null && this.firstName !== undefined) {
    output.writeFieldBegin('firstName', Thrift.Type.STRING, 8);
    output.writeString(this.firstName);
    output.writeFieldEnd();
  }
  if (this.middleName !== null && this.middleName !== undefined) {
    output.writeFieldBegin('middleName', Thrift.Type.STRING, 9);
    output.writeString(this.middleName);
    output.writeFieldEnd();
  }
  if (this.lastName !== null && this.lastName !== undefined) {
    output.writeFieldBegin('lastName', Thrift.Type.STRING, 10);
    output.writeString(this.lastName);
    output.writeFieldEnd();
  }
  if (this.birthdate !== null && this.birthdate !== undefined) {
    output.writeFieldBegin('birthdate', Thrift.Type.I64, 11);
    output.writeI64(this.birthdate);
    output.writeFieldEnd();
  }
  if (this.timeUserJoined !== null && this.timeUserJoined !== undefined) {
    output.writeFieldBegin('timeUserJoined', Thrift.Type.I64, 12);
    output.writeI64(this.timeUserJoined);
    output.writeFieldEnd();
  }
  output.writeFieldStop();
  output.writeStructEnd();
  return;
};

var Application = module.exports.Application = function(args) {
  this.owners = null;
  this.timeOfProvisioning = null;
  this.name = null;
  this.applicationId = null;
  this.totalMessagesSent = null;
  this.icon = null;
  this.programmingLanguage = null;
  this.followers = [];
  this.applicationDescription = null;
  this.organizationId = null;
  this.tier = 1;
  this.timeOfTokenExpiration = null;
  this.applicationIconMediaId = null;
  this.isFollowing = null;
  if (args) {
    if (args.owners !== undefined && args.owners !== null) {
      this.owners = Thrift.copyList(args.owners, [null]);
    }
    if (args.timeOfProvisioning !== undefined && args.timeOfProvisioning !== null) {
      this.timeOfProvisioning = args.timeOfProvisioning;
    }
    if (args.name !== undefined && args.name !== null) {
      this.name = args.name;
    }
    if (args.applicationId !== undefined && args.applicationId !== null) {
      this.applicationId = args.applicationId;
    }
    if (args.totalMessagesSent !== undefined && args.totalMessagesSent !== null) {
      this.totalMessagesSent = args.totalMessagesSent;
    }
    if (args.icon !== undefined && args.icon !== null) {
      this.icon = new ttypes.Image(args.icon);
    }
    if (args.programmingLanguage !== undefined && args.programmingLanguage !== null) {
      this.programmingLanguage = args.programmingLanguage;
    }
    if (args.followers !== undefined && args.followers !== null) {
      this.followers = Thrift.copyList(args.followers, [null]);
    }
    if (args.applicationDescription !== undefined && args.applicationDescription !== null) {
      this.applicationDescription = args.applicationDescription;
    }
    if (args.organizationId !== undefined && args.organizationId !== null) {
      this.organizationId = args.organizationId;
    }
    if (args.tier !== undefined && args.tier !== null) {
      this.tier = args.tier;
    }
    if (args.timeOfTokenExpiration !== undefined && args.timeOfTokenExpiration !== null) {
      this.timeOfTokenExpiration = args.timeOfTokenExpiration;
    }
    if (args.applicationIconMediaId !== undefined && args.applicationIconMediaId !== null) {
      this.applicationIconMediaId = args.applicationIconMediaId;
    }
    if (args.isFollowing !== undefined && args.isFollowing !== null) {
      this.isFollowing = args.isFollowing;
    }
  }
};
Application.prototype = {};
Application.prototype.read = function(input) {
  input.readStructBegin();
  while (true)
  {
    var ret = input.readFieldBegin();
    var fname = ret.fname;
    var ftype = ret.ftype;
    var fid = ret.fid;
    if (ftype == Thrift.Type.STOP) {
      break;
    }
    switch (fid)
    {
      case 1:
      if (ftype == Thrift.Type.SET) {
        var _size16 = 0;
        var _rtmp320;
        this.owners = [];
        var _etype19 = 0;
        _rtmp320 = input.readSetBegin();
        _etype19 = _rtmp320.etype;
        _size16 = _rtmp320.size;
        for (var _i21 = 0; _i21 < _size16; ++_i21)
        {
          var elem22 = null;
          elem22 = input.readString();
          this.owners.push(elem22);
        }
        input.readSetEnd();
      } else {
        input.skip(ftype);
      }
      break;
      case 2:
      if (ftype == Thrift.Type.I64) {
        this.timeOfProvisioning = input.readI64();
      } else {
        input.skip(ftype);
      }
      break;
      case 3:
      if (ftype == Thrift.Type.STRING) {
        this.name = input.readString();
      } else {
        input.skip(ftype);
      }
      break;
      case 4:
      if (ftype == Thrift.Type.STRING) {
        this.applicationId = input.readString();
      } else {
        input.skip(ftype);
      }
      break;
      case 5:
      if (ftype == Thrift.Type.I64) {
        this.totalMessagesSent = input.readI64();
      } else {
        input.skip(ftype);
      }
      break;
      case 6:
      if (ftype == Thrift.Type.STRUCT) {
        this.icon = new ttypes.Image();
        this.icon.read(input);
      } else {
        input.skip(ftype);
      }
      break;
      case 7:
      if (ftype == Thrift.Type.I32) {
        this.programmingLanguage = input.readI32();
      } else {
        input.skip(ftype);
      }
      break;
      case 8:
      if (ftype == Thrift.Type.SET) {
        var _size23 = 0;
        var _rtmp327;
        this.followers = [];
        var _etype26 = 0;
        _rtmp327 = input.readSetBegin();
        _etype26 = _rtmp327.etype;
        _size23 = _rtmp327.size;
        for (var _i28 = 0; _i28 < _size23; ++_i28)
        {
          var elem29 = null;
          elem29 = input.readString();
          this.followers.push(elem29);
        }
        input.readSetEnd();
      } else {
        input.skip(ftype);
      }
      break;
      case 9:
      if (ftype == Thrift.Type.STRING) {
        this.applicationDescription = input.readString();
      } else {
        input.skip(ftype);
      }
      break;
      case 10:
      if (ftype == Thrift.Type.STRING) {
        this.organizationId = input.readString();
      } else {
        input.skip(ftype);
      }
      break;
      case 11:
      if (ftype == Thrift.Type.I32) {
        this.tier = input.readI32();
      } else {
        input.skip(ftype);
      }
      break;
      case 12:
      if (ftype == Thrift.Type.I64) {
        this.timeOfTokenExpiration = input.readI64();
      } else {
        input.skip(ftype);
      }
      break;
      case 13:
      if (ftype == Thrift.Type.STRING) {
        this.applicationIconMediaId = input.readString();
      } else {
        input.skip(ftype);
      }
      break;
      case 14:
      if (ftype == Thrift.Type.BOOL) {
        this.isFollowing = input.readBool();
      } else {
        input.skip(ftype);
      }
      break;
      default:
        input.skip(ftype);
    }
    input.readFieldEnd();
  }
  input.readStructEnd();
  return;
};

Application.prototype.write = function(output) {
  output.writeStructBegin('Application');
  if (this.owners !== null && this.owners !== undefined) {
    output.writeFieldBegin('owners', Thrift.Type.SET, 1);
    output.writeSetBegin(Thrift.Type.STRING, this.owners.length);
    for (var iter30 in this.owners)
    {
      if (this.owners.hasOwnProperty(iter30))
      {
        iter30 = this.owners[iter30];
        output.writeString(iter30);
      }
    }
    output.writeSetEnd();
    output.writeFieldEnd();
  }
  if (this.timeOfProvisioning !== null && this.timeOfProvisioning !== undefined) {
    output.writeFieldBegin('timeOfProvisioning', Thrift.Type.I64, 2);
    output.writeI64(this.timeOfProvisioning);
    output.writeFieldEnd();
  }
  if (this.name !== null && this.name !== undefined) {
    output.writeFieldBegin('name', Thrift.Type.STRING, 3);
    output.writeString(this.name);
    output.writeFieldEnd();
  }
  if (this.applicationId !== null && this.applicationId !== undefined) {
    output.writeFieldBegin('applicationId', Thrift.Type.STRING, 4);
    output.writeString(this.applicationId);
    output.writeFieldEnd();
  }
  if (this.totalMessagesSent !== null && this.totalMessagesSent !== undefined) {
    output.writeFieldBegin('totalMessagesSent', Thrift.Type.I64, 5);
    output.writeI64(this.totalMessagesSent);
    output.writeFieldEnd();
  }
  if (this.icon !== null && this.icon !== undefined) {
    output.writeFieldBegin('icon', Thrift.Type.STRUCT, 6);
    this.icon.write(output);
    output.writeFieldEnd();
  }
  if (this.programmingLanguage !== null && this.programmingLanguage !== undefined) {
    output.writeFieldBegin('programmingLanguage', Thrift.Type.I32, 7);
    output.writeI32(this.programmingLanguage);
    output.writeFieldEnd();
  }
  if (this.followers !== null && this.followers !== undefined) {
    output.writeFieldBegin('followers', Thrift.Type.SET, 8);
    output.writeSetBegin(Thrift.Type.STRING, this.followers.length);
    for (var iter31 in this.followers)
    {
      if (this.followers.hasOwnProperty(iter31))
      {
        iter31 = this.followers[iter31];
        output.writeString(iter31);
      }
    }
    output.writeSetEnd();
    output.writeFieldEnd();
  }
  if (this.applicationDescription !== null && this.applicationDescription !== undefined) {
    output.writeFieldBegin('applicationDescription', Thrift.Type.STRING, 9);
    output.writeString(this.applicationDescription);
    output.writeFieldEnd();
  }
  if (this.organizationId !== null && this.organizationId !== undefined) {
    output.writeFieldBegin('organizationId', Thrift.Type.STRING, 10);
    output.writeString(this.organizationId);
    output.writeFieldEnd();
  }
  if (this.tier !== null && this.tier !== undefined) {
    output.writeFieldBegin('tier', Thrift.Type.I32, 11);
    output.writeI32(this.tier);
    output.writeFieldEnd();
  }
  if (this.timeOfTokenExpiration !== null && this.timeOfTokenExpiration !== undefined) {
    output.writeFieldBegin('timeOfTokenExpiration', Thrift.Type.I64, 12);
    output.writeI64(this.timeOfTokenExpiration);
    output.writeFieldEnd();
  }
  if (this.applicationIconMediaId !== null && this.applicationIconMediaId !== undefined) {
    output.writeFieldBegin('applicationIconMediaId', Thrift.Type.STRING, 13);
    output.writeString(this.applicationIconMediaId);
    output.writeFieldEnd();
  }
  if (this.isFollowing !== null && this.isFollowing !== undefined) {
    output.writeFieldBegin('isFollowing', Thrift.Type.BOOL, 14);
    output.writeBool(this.isFollowing);
    output.writeFieldEnd();
  }
  output.writeFieldStop();
  output.writeStructEnd();
  return;
};

var ServiceAnnouncement = module.exports.ServiceAnnouncement = function(args) {
  this.message = null;
  this.importance = null;
  this.id = null;
  this.timeOfExpiration = null;
  if (args) {
    if (args.message !== undefined && args.message !== null) {
      this.message = args.message;
    }
    if (args.importance !== undefined && args.importance !== null) {
      this.importance = args.importance;
    }
    if (args.id !== undefined && args.id !== null) {
      this.id = args.id;
    }
    if (args.timeOfExpiration !== undefined && args.timeOfExpiration !== null) {
      this.timeOfExpiration = args.timeOfExpiration;
    }
  }
};
ServiceAnnouncement.prototype = {};
ServiceAnnouncement.prototype.read = function(input) {
  input.readStructBegin();
  while (true)
  {
    var ret = input.readFieldBegin();
    var fname = ret.fname;
    var ftype = ret.ftype;
    var fid = ret.fid;
    if (ftype == Thrift.Type.STOP) {
      break;
    }
    switch (fid)
    {
      case 1:
      if (ftype == Thrift.Type.STRING) {
        this.message = input.readString();
      } else {
        input.skip(ftype);
      }
      break;
      case 2:
      if (ftype == Thrift.Type.I32) {
        this.importance = input.readI32();
      } else {
        input.skip(ftype);
      }
      break;
      case 3:
      if (ftype == Thrift.Type.STRING) {
        this.id = input.readString();
      } else {
        input.skip(ftype);
      }
      break;
      case 4:
      if (ftype == Thrift.Type.I64) {
        this.timeOfExpiration = input.readI64();
      } else {
        input.skip(ftype);
      }
      break;
      default:
        input.skip(ftype);
    }
    input.readFieldEnd();
  }
  input.readStructEnd();
  return;
};

ServiceAnnouncement.prototype.write = function(output) {
  output.writeStructBegin('ServiceAnnouncement');
  if (this.message !== null && this.message !== undefined) {
    output.writeFieldBegin('message', Thrift.Type.STRING, 1);
    output.writeString(this.message);
    output.writeFieldEnd();
  }
  if (this.importance !== null && this.importance !== undefined) {
    output.writeFieldBegin('importance', Thrift.Type.I32, 2);
    output.writeI32(this.importance);
    output.writeFieldEnd();
  }
  if (this.id !== null && this.id !== undefined) {
    output.writeFieldBegin('id', Thrift.Type.STRING, 3);
    output.writeString(this.id);
    output.writeFieldEnd();
  }
  if (this.timeOfExpiration !== null && this.timeOfExpiration !== undefined) {
    output.writeFieldBegin('timeOfExpiration', Thrift.Type.I64, 4);
    output.writeI64(this.timeOfExpiration);
    output.writeFieldEnd();
  }
  output.writeFieldStop();
  output.writeStructEnd();
  return;
};

ttypes.API_VERSION = 2.01;