text:
using System;
using System.Collections.Generic;
using Microsoft.EntityFrameworkCore.Migrations;
using Microsoft.EntityFrameworkCore.Metadata;

namespace PHBGTU.Data.Migrations
{
    public partial class Initialization : Migration
    {
        protected override void Up(MigrationBuilder migrationBuilder)
        {
            migrationBuilder.CreateTable(
                name: "IdentityRole",
                columns: table => new
                {
                    Id = table.Column<string>(nullable: false),
                    ConcurrencyStamp = table.Column<string>(nullable: true),
                    Name = table.Column<string>(maxLength: 256, nullable: true),
                    NormalizedName = table.Column<string>(maxLength: 256, nullable: true)
                },
                constraints: table =>
                {
                    table.PrimaryKey("PK_IdentityRole", x => x.Id);
                });

            migrationBuilder.CreateTable(
                name: "IdentityUserToken<string>",
                columns: table => new
                {
                    UserId = table.Column<string>(nullable: false),
                    LoginProvider = table.Column<string>(nullable: false),
                    Name = table.Column<string>(nullable: false),
                    Value = table.Column<string>(nullable: true)
                },
                constraints: table =>
                {
                    table.PrimaryKey("PK_IdentityUserToken<string>", x => new { x.UserId, x.LoginProvider, x.Name });
                });

            migrationBuilder.CreateTable(
                name: "ContactCategory",
                columns: table => new
                {
                    ContactCategoryId = table.Column<int>(nullable: false)
                        .Annotation("SqlServer:ValueGenerationStrategy", SqlServerValueGenerationStrategy.IdentityColumn),
                    Abbreviation = table.Column<string>(maxLength: 5, nullable: false),
                    CreateTimestamp = table.Column<DateTime>(nullable: false),
                    CreateUser = table.Column<string>(nullable: true),
                    Description = table.Column<string>(maxLength: 30, nullable: false),
                    UpdateTimestamp = table.Column<DateTime>(nullable: false),
                    UpdateUser = table.Column<string>(nullable: true)
                },
                constraints: table =>
                {
                    table.PrimaryKey("PK_ContactCategory", x => x.ContactCategoryId);
                });

            migrationBuilder.CreateTable(
                name: "ContentBlockCategory",
                columns: table => new
                {
                    ContentBlockCategoryId = table.Column<int>(nullable: false)
                        .Annotation("SqlServer:ValueGenerationStrategy", SqlServerValueGenerationStrategy.IdentityColumn),
                    CreateTimestamp = table.Column<DateTime>(nullable: false),
                    CreateUser = table.Column<string>(nullable: true),
                    Description = table.Column<string>(maxLength: 30, nullable: false),
                    UpdateTimestamp = table.Column<DateTime>(nullable: false),
                    UpdateUser = table.Column<string>(nullable: true)
                },
                constraints: table =>
                {
                    table.PrimaryKey("PK_ContentBlockCategory", x => x.ContentBlockCategoryId);
                });

            migrationBuilder.CreateTable(
                name: "IconCategory",
                columns: table => new
                {
                    IconCategoryId = table.Column<int>(nullable: false)
                        .Annotation("SqlServer:ValueGenerationStrategy", SqlServerValueGenerationStrategy.IdentityColumn),
                    CreateTimestamp = table.Column<DateTime>(nullable: false),
                    CreateUser = table.Column<string>(nullable: true),
                    Description = table.Column<string>(maxLength: 30, nullable: false),
                    UpdateTimestamp = table.Column<DateTime>(nullable: false),
                    UpdateUser = table.Column<string>(nullable: true)
                },
                constraints: table =>
                {
                    table.PrimaryKey("PK_IconCategory", x => x.IconCategoryId);
                });

            migrationBuilder.CreateTable(
                name: "Languaje",
                columns: table => new
                {
                    LanguageId = table.Column<int>(nullable: false)
                        .Annotation("SqlServer:ValueGenerationStrategy", SqlServerValueGenerationStrategy.IdentityColumn),
                    Abbreviation = table.Column<string>(maxLength: 5, nullable: false),
                    CreateTimestamp = table.Column<DateTime>(nullable: false),
                    CreateUser = table.Column<string>(nullable: true),
                    Description = table.Column<string>(maxLength: 30, nullable: false),
                    UpdateTimestamp = table.Column<DateTime>(nullable: false),
                    UpdateUser = table.Column<string>(nullable: true)
                },
                constraints: table =>
                {
                    table.PrimaryKey("PK_Languaje", x => x.LanguageId);
                });

            migrationBuilder.CreateTable(
                name: "LinkCategory",
                columns: table => new
                {
                    LinkCategoryId = table.Column<int>(nullable: false)
                        .Annotation("SqlServer:ValueGenerationStrategy", SqlServerValueGenerationStrategy.IdentityColumn),
                    CreateTimestamp = table.Column<DateTime>(nullable: false),
                    CreateUser = table.Column<string>(nullable: true),
                    Description = table.Column<string>(maxLength: 30, nullable: false),
                    UpdateTimestamp = table.Column<DateTime>(nullable: false),
                    UpdateUser = table.Column<string>(nullable: true)
                },
                constraints: table =>
                {
                    table.PrimaryKey("PK_LinkCategory", x => x.LinkCategoryId);
                });

            migrationBuilder.CreateTable(
                name: "MediaCategory",
                columns: table => new
                {
                    MediaCategoryId = table.Column<int>(nullable: false)
                        .Annotation("SqlServer:ValueGenerationStrategy", SqlServerValueGenerationStrategy.IdentityColumn),
                    CreateTimestamp = table.Column<DateTime>(nullable: false),
                    CreateUser = table.Column<string>(nullable: true),
                    Description = table.Column<string>(maxLength: 30, nullable: false),
                    MediaFolder = table.Column<string>(maxLength: 25, nullable: true),
                    UpdateTimestamp = table.Column<DateTime>(nullable: false),
                    UpdateUser = table.Column<string>(nullable: true)
                },
                constraints: table =>
                {
                    table.PrimaryKey("PK_MediaCategory", x => x.MediaCategoryId);
                });

            migrationBuilder.CreateTable(
                name: "NavigationCategory",
                columns: table => new
                {
                    NavigationCategoryId = table.Column<int>(nullable: false)
                        .Annotation("SqlServer:ValueGenerationStrategy", SqlServerValueGenerationStrategy.IdentityColumn),
                    CreateTimestamp = table.Column<DateTime>(nullable: false),
                    CreateUser = table.Column<string>(nullable: true),
                    Description = table.Column<string>(maxLength: 30, nullable: false),
                    UpdateTimestamp = table.Column<DateTime>(nullable: false),
                    UpdateUser = table.Column<string>(nullable: true)
                },
                constraints: table =>
                {
                    table.PrimaryKey("PK_NavigationCategory", x => x.NavigationCategoryId);
                });

            migrationBuilder.CreateTable(
                name: "PageCategory",
                columns: table => new
                {
                    PageCategoryId = table.Column<int>(nullable: false)
                        .Annotation("SqlServer:ValueGenerationStrategy", SqlServerValueGenerationStrategy.IdentityColumn),
                    CreateTimestamp = table.Column<DateTime>(nullable: false),
                    CreateUser = table.Column<string>(nullable: true),
                    Description = table.Column<string>(maxLength: 30, nullable: false),
                    UpdateTimestamp = table.Column<DateTime>(nullable: false),
                    UpdateUser = table.Column<string>(nullable: true)
                },
                constraints: table =>
                {
                    table.PrimaryKey("PK_PageCategory", x => x.PageCategoryId);
                });

            migrationBuilder.CreateTable(
                name: "SettingCategory",
                columns: table => new
                {
                    SettingCategoryId = table.Column<int>(nullable: false)
                        .Annotation("SqlServer:ValueGenerationStrategy", SqlServerValueGenerationStrategy.IdentityColumn),
                    CreateTimestamp = table.Column<DateTime>(nullable: false),
                    CreateUser = table.Column<string>(nullable: true),
                    Description = table.Column<string>(maxLength: 30, nullable: false),
                    UpdateTimestamp = table.Column<DateTime>(nullable: false),
                    UpdateUser = table.Column<string>(nullable: true)
                },
                constraints: table =>
                {
                    table.PrimaryKey("PK_SettingCategory", x => x.SettingCategoryId);
                });

            migrationBuilder.CreateTable(
                name: "TemplateCategory",
                columns: table => new
                {
                    TemplateCategoryId = table.Column<int>(nullable: false)
                        .Annotation("SqlServer:ValueGenerationStrategy", SqlServerValueGenerationStrategy.IdentityColumn),
                    CreateTimestamp = table.Column<DateTime>(nullable: false),
                    CreateUser = table.Column<string>(nullable: true),
                    Description = table.Column<string>(maxLength: 30, nullable: false),
                    UpdateTimestamp = table.Column<DateTime>(nullable: false),
                    UpdateUser = table.Column<string>(nullable: true)
                },
                constraints: table =>
                {
                    table.PrimaryKey("PK_TemplateCategory", x => x.TemplateCategoryId);
                });

            migrationBuilder.CreateTable(
                name: "ApplicationUser",
                columns: table => new
                {
                    Id = table.Column<string>(nullable: false),
                    AccessFailedCount = table.Column<int>(nullable: false),
                    ConcurrencyStamp = table.Column<string>(nullable: true),
                    Email = table.Column<string>(maxLength: 256, nullable: true),
                    EmailConfirmed = table.Column<bool>(nullable: false),
                    FirstName = table.Column<string>(nullable: true),
                    LastName = table.Column<string>(nullable: true),
                    LockoutEnabled = table.Column<bool>(nullable: false),
                    LockoutEnd = table.Column<DateTimeOffset>(nullable: true),
                    NormalizedEmail = table.Column<string>(maxLength: 256, nullable: true),
                    NormalizedUserName = table.Column<string>(maxLength: 256, nullable: true),
                    PasswordHash = table.Column<string>(nullable: true),
                    PhoneNumber = table.Column<string>(nullable: true),
                    PhoneNumberConfirmed = table.Column<bool>(nullable: false),
                    SecurityStamp = table.Column<string>(nullable: true),
                    TwoFactorEnabled = table.Column<bool>(nullable: false),
                    UserName = table.Column<string>(maxLength: 256, nullable: true)
                },
                constraints: table =>
                {
                    table.PrimaryKey("PK_ApplicationUser", x => x.Id);
                });

            migrationBuilder.CreateTable(
                name: "IdentityRoleClaim<string>",
                columns: table => new
                {
                    Id = table.Column<int>(nullable: false)
                        .Annotation("SqlServer:ValueGenerationStrategy", SqlServerValueGenerationStrategy.IdentityColumn),
                    ClaimType = table.Column<string>(nullable: true),
                    ClaimValue = table.Column<string>(nullable: true),
                    RoleId = table.Column<string>(nullable: false)
                },
                constraints: table =>
                {
                    table.PrimaryKey("PK_IdentityRoleClaim<string>", x => x.Id);
                    table.ForeignKey(
                        name: "FK_IdentityRoleClaim<string>_IdentityRole_RoleId",
                        column: x => x.RoleId,
                        principalTable: "IdentityRole",
                        principalColumn: "Id",
                        onDelete: ReferentialAction.Cascade);
                });

            migrationBuilder.CreateTable(
                name: "ContentBlock",
                columns: table => new
                {
                    ContentBlockId = table.Column<int>(nullable: false)
                        .Annotation("SqlServer:ValueGenerationStrategy", SqlServerValueGenerationStrategy.IdentityColumn),
                    Content = table.Column<string>(nullable: false),
                    ContentBlockCategoryId = table.Column<int>(nullable: false),
                    CreateTimestamp = table.Column<DateTime>(nullable: false),
                    CreateUser = table.Column<string>(nullable: true),
                    EventDateTime = table.Column<DateTime>(nullable: false),
                    PublishDateTime = table.Column<DateTime>(nullable: false),
                    ShowEventDateTime = table.Column<bool>(nullable: false),
                    Status = table.Column<string>(maxLength: 1, nullable: false),
                    UpdateTimestamp = table.Column<DateTime>(nullable: false),
                    UpdateUser = table.Column<string>(nullable: true)
                },
                constraints: table =>
                {
                    table.PrimaryKey("PK_ContentBlock", x => x.ContentBlockId);
                    table.ForeignKey(
                        name: "FK_ContentBlock_ContentBlockCategory_ContentBlockCategoryId",
                        column: x => x.ContentBlockCategoryId,
                        principalTable: "ContentBlockCategory",
                        principalColumn: "ContentBlockCategoryId",
                        onDelete: ReferentialAction.Cascade);
                });

            migrationBuilder.CreateTable(
                name: "Icon",
                columns: table => new
                {
                    IconId = table.Column<int>(nullable: false)
                        .Annotation("SqlServer:ValueGenerationStrategy", SqlServerValueGenerationStrategy.IdentityColumn),
                    CreateTimestamp = table.Column<DateTime>(nullable: false),
                    CreateUser = table.Column<string>(nullable: true),
                    Description = table.Column<string>(maxLength: 30, nullable: false),
                    IconCategoryId = table.Column<int>(nullable: false),
                    Status = table.Column<string>(maxLength: 1, nullable: false),
                    UpdateTimestamp = table.Column<DateTime>(nullable: false),
                    UpdateUser = table.Column<string>(nullable: true)
                },
                constraints: table =>
                {
                    table.PrimaryKey("PK_Icon", x => x.IconId);
                    table.ForeignKey(
                        name: "FK_Icon_IconCategory_IconCategoryId",
                        column: x => x.IconCategoryId,
                        principalTable: "IconCategory",
                        principalColumn: "IconCategoryId",
                        onDelete: ReferentialAction.Cascade);
                });

            migrationBuilder.CreateTable(
                name: "Media",
                columns: table => new
                {
                    MediaId = table.Column<int>(nullable: false)
                        .Annotation("SqlServer:ValueGenerationStrategy", SqlServerValueGenerationStrategy.IdentityColumn),
                    Album = table.Column<string>(nullable: false),
                    ContentDisposition = table.Column<string>(nullable: true),
                    ContentType = table.Column<string>(nullable: true),
                    CreateTimestamp = table.Column<DateTime>(nullable: false),
                    CreateUser = table.Column<string>(nullable: false),
                    Description = table.Column<string>(maxLength: 30, nullable: false),
                    Extension = table.Column<string>(nullable: true),
                    Filename = table.Column<string>(nullable: true),
                    Headers = table.Column<string>(nullable: true),
                    Keywords = table.Column<string>(nullable: true),
                    Length = table.Column<long>(nullable: false),
                    MediaCategoryId = table.Column<int>(nullable: false),
                    Month = table.Column<string>(maxLength: 2, nullable: true),
                    Name = table.Column<string>(nullable: true),
                    PhysicalPath = table.Column<string>(nullable: false),
                    PublishDateTime = table.Column<DateTime>(nullable: false),
                    Status = table.Column<string>(maxLength: 1, nullable: false),
                    UpdateTimestamp = table.Column<DateTime>(nullable: false),
                    UpdateUser = table.Column<string>(nullable: false),
                    WebPath = table.Column<string>(nullable: false),
                    Year = table.Column<string>(maxLength: 4, nullable: true)
                },
                constraints: table =>
                {
                    table.PrimaryKey("PK_Media", x => x.MediaId);
                    table.ForeignKey(
                        name: "FK_Media_MediaCategory_MediaCategoryId",
                        column: x => x.MediaCategoryId,
                        principalTable: "MediaCategory",
                        principalColumn: "MediaCategoryId",
                        onDelete: ReferentialAction.Cascade);
                });

            migrationBuilder.CreateTable(
                name: "Template",
                columns: table => new
                {
                    TemplateId = table.Column<int>(nullable: false)
                        .Annotation("SqlServer:ValueGenerationStrategy", SqlServerValueGenerationStrategy.IdentityColumn),
                    CreateTimestamp = table.Column<DateTime>(nullable: false),
                    CreateUser = table.Column<string>(nullable: true),
                    Description = table.Column<string>(maxLength: 30, nullable: false),
                    Status = table.Column<string>(maxLength: 1, nullable: false),
                    TemplateCategoryId = table.Column<int>(nullable: false),
                    UpdateTimestamp = table.Column<DateTime>(nullable: false),
                    UpdateUser = table.Column<string>(nullable: true)
                },
                constraints: table =>
                {
                    table.PrimaryKey("PK_Template", x => x.TemplateId);
                    table.ForeignKey(
                        name: "FK_Template_TemplateCategory_TemplateCategoryId",
                        column: x => x.TemplateCategoryId,
                        principalTable: "TemplateCategory",
                        principalColumn: "TemplateCategoryId",
                        onDelete: ReferentialAction.Cascade);
                });

            migrationBuilder.CreateTable(
                name: "IdentityUserClaim<string>",
                columns: table => new
                {
                    Id = table.Column<int>(nullable: false)
                        .Annotation("SqlServer:ValueGenerationStrategy", SqlServerValueGenerationStrategy.IdentityColumn),
                    ClaimType = table.Column<string>(nullable: true),
                    ClaimValue = table.Column<string>(nullable: true),
                    UserId = table.Column<string>(nullable: false)
                },
                constraints: table =>
                {
                    table.PrimaryKey("PK_IdentityUserClaim<string>", x => x.Id);
                    table.ForeignKey(
                        name: "FK_IdentityUserClaim<string>_ApplicationUser_UserId",
                        column: x => x.UserId,
                        principalTable: "ApplicationUser",
                        principalColumn: "Id",
                        onDelete: ReferentialAction.Cascade);
                });

            migrationBuilder.CreateTable(
                name: "IdentityUserLogin<string>",
                columns: table => new
                {
                    LoginProvider = table.Column<string>(nullable: false),
                    ProviderKey = table.Column<string>(nullable: false),
                    ProviderDisplayName = table.Column<string>(nullable: true),
                    UserId = table.Column<string>(nullable: false)
                },
                constraints: table =>
                {
                    table.PrimaryKey("PK_IdentityUserLogin<string>", x => new { x.LoginProvider, x.ProviderKey });
                    table.ForeignKey(
                        name: "FK_IdentityUserLogin<string>_ApplicationUser_UserId",
                        column: x => x.UserId,
                        principalTable: "ApplicationUser",
                        principalColumn: "Id",
                        onDelete: ReferentialAction.Cascade);
                });

            migrationBuilder.CreateTable(
                name: "IdentityUserRole<string>",
                columns: table => new
                {
                    UserId = table.Column<string>(nullable: false),
                    RoleId = table.Column<string>(nullable: false)
                },
                constraints: table =>
                {
                    table.PrimaryKey("PK_IdentityUserRole<string>", x => new { x.UserId, x.RoleId });
                    table.ForeignKey(
                        name: "FK_IdentityUserRole<string>_IdentityRole_RoleId",
                        column: x => x.RoleId,
                        principalTable: "IdentityRole",
                        principalColumn: "Id",
                        onDelete: ReferentialAction.Cascade);
                    table.ForeignKey(
                        name: "FK_IdentityUserRole<string>_ApplicationUser_UserId",
                        column: x => x.UserId,
                        principalTable: "ApplicationUser",
                        principalColumn: "Id",
                        onDelete: ReferentialAction.Cascade);
                });

            migrationBuilder.CreateTable(
                name: "Contact",
                columns: table => new
                {
                    ContactId = table.Column<int>(nullable: false)
                        .Annotation("SqlServer:ValueGenerationStrategy", SqlServerValueGenerationStrategy.IdentityColumn),
                    Address1 = table.Column<string>(maxLength: 50, nullable: true),
                    Address2 = table.Column<string>(maxLength: 50, nullable: true),
                    City = table.Column<string>(nullable: true),
                    ContactCategoryId = table.Column<int>(nullable: false),
                    Country = table.Column<string>(maxLength: 20, nullable: true),
                    CreateTimestamp = table.Column<DateTime>(nullable: false),
                    CreateUser = table.Column<string>(nullable: true),
                    Email = table.Column<string>(nullable: false),
                    FirstName = table.Column<string>(maxLength: 30, nullable: false),
                    IconId = table.Column<int>(nullable: false),
                    LastName = table.Column<string>(maxLength: 30, nullable: false),
                    MediaId = table.Column<int>(nullable: false),
                    MiddleName = table.Column<string>(maxLength: 20, nullable: true),
                    OrganizationName = table.Column<string>(maxLength: 30, nullable: true),
                    PhoneNumber1 = table.Column<int>(nullable: false),
                    PhoneNumber2 = table.Column<int>(nullable: false),
                    PostalCode = table.Column<string>(maxLength: 20, nullable: true),
                    StateProv = table.Column<string>(maxLength: 30, nullable: true),
                    Status = table.Column<string>(maxLength: 1, nullable: false),
                    UpdateTimestamp = table.Column<DateTime>(nullable: false),
                    UpdateUser = table.Column<string>(nullable: true),
                    Website = table.Column<string>(nullable: true)
                },
                constraints: table =>
                {
                    table.PrimaryKey("PK_Contact", x => x.ContactId);
                    table.ForeignKey(
                        name: "FK_Contact_ContactCategory_ContactCategoryId",
                        column: x => x.ContactCategoryId,
                        principalTable: "ContactCategory",
                        principalColumn: "ContactCategoryId",
                        onDelete: ReferentialAction.Cascade);
                    table.ForeignKey(
                        name: "FK_Contact_Icon_IconId",
                        column: x => x.IconId,
                        principalTable: "Icon",
                        principalColumn: "IconId",
                        onDelete: ReferentialAction.Cascade);
                    table.ForeignKey(
                        name: "FK_Contact_Media_MediaId",
                        column: x => x.MediaId,
                        principalTable: "Media",
                        principalColumn: "MediaId",
                        onDelete: ReferentialAction.Cascade);
                });

            migrationBuilder.CreateTable(
                name: "ContentBlockMedia",
                columns: table => new
                {
                    ContentBlockMediaId = table.Column<int>(nullable: false)
                        .Annotation("SqlServer:ValueGenerationStrategy", SqlServerValueGenerationStrategy.IdentityColumn),
                    ContentBlockId = table.Column<int>(nullable: false),
                    CreateTimestamp = table.Column<DateTime>(nullable: false),
                    CreateUser = table.Column<string>(nullable: true),
                    MediaId = table.Column<int>(nullable: false),
                    UpdateTimestamp = table.Column<DateTime>(nullable: false),
                    UpdateUser = table.Column<string>(nullable: true)
                },
                constraints: table =>
                {
                    table.PrimaryKey("PK_ContentBlockMedia", x => x.ContentBlockMediaId);
                    table.ForeignKey(
                        name: "FK_ContentBlockMedia_ContentBlock_ContentBlockId",
                        column: x => x.ContentBlockId,
                        principalTable: "ContentBlock",
                        principalColumn: "ContentBlockId",
                        onDelete: ReferentialAction.Cascade);
                    table.ForeignKey(
                        name: "FK_ContentBlockMedia_Media_MediaId",
                        column: x => x.MediaId,
                        principalTable: "Media",
                        principalColumn: "MediaId",
                        onDelete: ReferentialAction.Cascade);
                });

            migrationBuilder.CreateTable(
                name: "Setting",
                columns: table => new
                {
                    SettingId = table.Column<int>(nullable: false)
                        .Annotation("SqlServer:ValueGenerationStrategy", SqlServerValueGenerationStrategy.IdentityColumn),
                    CreateTimestamp = table.Column<DateTime>(nullable: false),
                    CreateUser = table.Column<string>(nullable: true),
                    Datatype = table.Column<string>(maxLength: 30, nullable: false),
                    Description = table.Column<string>(maxLength: 30, nullable: false),
                    IconId = table.Column<int>(nullable: false),
                    MediaId = table.Column<int>(nullable: false),
                    SettingCategoryId = table.Column<int>(nullable: false),
                    UpdateTimestamp = table.Column<DateTime>(nullable: false),
                    UpdateUser = table.Column<string>(nullable: true)
                },
                constraints: table =>
                {
                    table.PrimaryKey("PK_Setting", x => x.SettingId);
                    table.ForeignKey(
                        name: "FK_Setting_Icon_IconId",
                        column: x => x.IconId,
                        principalTable: "Icon",
                        principalColumn: "IconId",
                        onDelete: ReferentialAction.Cascade);
                    table.ForeignKey(
                        name: "FK_Setting_Media_MediaId",
                        column: x => x.MediaId,
                        principalTable: "Media",
                        principalColumn: "MediaId",
                        onDelete: ReferentialAction.Cascade);
                    table.ForeignKey(
                        name: "FK_Setting_SettingCategory_SettingCategoryId",
                        column: x => x.SettingCategoryId,
                        principalTable: "SettingCategory",
                        principalColumn: "SettingCategoryId",
                        onDelete: ReferentialAction.Cascade);
                });

            migrationBuilder.CreateTable(
                name: "Navigation",
                columns: table => new
                {
                    NavigationId = table.Column<int>(nullable: false)
                        .Annotation("SqlServer:ValueGenerationStrategy", SqlServerValueGenerationStrategy.IdentityColumn),
                    CreateTimestamp = table.Column<DateTime>(nullable: false),
                    CreateUser = table.Column<string>(nullable: true),
                    Description = table.Column<string>(maxLength: 30, nullable: false),
                    NavigationCategoryId = table.Column<int>(nullable: false),
                    Status = table.Column<string>(maxLength: 1, nullable: false),
                    TemplateId = table.Column<int>(nullable: false),
                    UpdateTimestamp = table.Column<DateTime>(nullable: false),
                    UpdateUser = table.Column<string>(nullable: true)
                },
                constraints: table =>
                {
                    table.PrimaryKey("PK_Navigation", x => x.NavigationId);
                    table.ForeignKey(
                        name: "FK_Navigation_NavigationCategory_NavigationCategoryId",
                        column: x => x.NavigationCategoryId,
                        principalTable: "NavigationCategory",
                        principalColumn: "NavigationCategoryId",
                        onDelete: ReferentialAction.Cascade);
                    table.ForeignKey(
                        name: "FK_Navigation_Template_TemplateId",
                        column: x => x.TemplateId,
                        principalTable: "Template",
                        principalColumn: "TemplateId",
                        onDelete: ReferentialAction.Cascade);
                });

            migrationBuilder.CreateTable(
                name: "Section",
                columns: table => new
                {
                    SectionId = table.Column<int>(nullable: false)
                        .Annotation("SqlServer:ValueGenerationStrategy", SqlServerValueGenerationStrategy.IdentityColumn),
                    CreateTimestamp = table.Column<DateTime>(nullable: false),
                    CreateUser = table.Column<string>(nullable: true),
                    Description = table.Column<string>(maxLength: 30, nullable: false),
                    Status = table.Column<string>(maxLength: 1, nullable: false),
                    TemplateId = table.Column<int>(nullable: false),
                    UpdateTimestamp = table.Column<DateTime>(nullable: false),
                    UpdateUser = table.Column<string>(nullable: true)
                },
                constraints: table =>
                {
                    table.PrimaryKey("PK_Section", x => x.SectionId);
                    table.ForeignKey(
                        name: "FK_Section_Template_TemplateId",
                        column: x => x.TemplateId,
                        principalTable: "Template",
                        principalColumn: "TemplateId",
                        onDelete: ReferentialAction.Cascade);
                });

            migrationBuilder.CreateTable(
                name: "TemplateSetting",
                columns: table => new
                {
                    TemplateSettingId = table.Column<int>(nullable: false)
                        .Annotation("SqlServer:ValueGenerationStrategy", SqlServerValueGenerationStrategy.IdentityColumn),
                    CreateTimestamp = table.Column<DateTime>(nullable: false),
                    CreateUser = table.Column<string>(nullable: true),
                    CurrentValue = table.Column<string>(nullable: false),
                    DefaultValue = table.Column<string>(nullable: false),
                    SettingId = table.Column<int>(nullable: false),
                    TemplateId = table.Column<int>(nullable: false),
                    UpdateTimestamp = table.Column<DateTime>(nullable: false),
                    UpdateUser = table.Column<string>(nullable: true)
                },
                constraints: table =>
                {
                    table.PrimaryKey("PK_TemplateSetting", x => x.TemplateSettingId);
                    table.ForeignKey(
                        name: "FK_TemplateSetting_Setting_SettingId",
                        column: x => x.SettingId,
                        principalTable: "Setting",
                        principalColumn: "SettingId",
                        onDelete: ReferentialAction.Cascade);
                    table.ForeignKey(
                        name: "FK_TemplateSetting_Template_TemplateId",
                        column: x => x.TemplateId,
                        principalTable: "Template",
                        principalColumn: "TemplateId",
                        onDelete: ReferentialAction.Cascade);
                });

            migrationBuilder.CreateTable(
                name: "Page",
                columns: table => new
                {
                    PageId = table.Column<int>(nullable: false)
                        .Annotation("SqlServer:ValueGenerationStrategy", SqlServerValueGenerationStrategy.IdentityColumn),
                    CreateTimestamp = table.Column<DateTime>(nullable: false),
                    CreateUser = table.Column<string>(nullable: true),
                    Description = table.Column<string>(maxLength: 30, nullable: false),
                    FooterId = table.Column<int>(nullable: true),
                    HeaderId = table.Column<int>(nullable: true),
                    Keywords = table.Column<string>(maxLength: 100, nullable: true),
                    NavigationId = table.Column<int>(nullable: true),
                    PageCategoryId = table.Column<int>(nullable: true),
                    SidebarLeftId = table.Column<int>(nullable: true),
                    SidebarRightId = table.Column<int>(nullable: true),
                    Status = table.Column<string>(maxLength: 1, nullable: false),
                    UpdateTimestamp = table.Column<DateTime>(nullable: false),
                    UpdateUser = table.Column<string>(nullable: true),
                    VirtualAction = table.Column<string>(nullable: false),
                    VirtualController = table.Column<string>(nullable: false)
                },
                constraints: table =>
                {
                    table.PrimaryKey("PK_Page", x => x.PageId);
                    table.ForeignKey(
                        name: "FK_Page_Navigation_FooterId",
                        column: x => x.FooterId,
                        principalTable: "Navigation",
                        principalColumn: "NavigationId",
                        onDelete: ReferentialAction.Restrict);
                    table.ForeignKey(
                        name: "FK_Page_Navigation_HeaderId",
                        column: x => x.HeaderId,
                        principalTable: "Navigation",
                        principalColumn: "NavigationId",
                        onDelete: ReferentialAction.Restrict);
                    table.ForeignKey(
                        name: "FK_Page_Navigation_NavigationId",
                        column: x => x.NavigationId,
                        principalTable: "Navigation",
                        principalColumn: "NavigationId",
                        onDelete: ReferentialAction.Restrict);
                    table.ForeignKey(
                        name: "FK_Page_PageCategory_PageCategoryId",
                        column: x => x.PageCategoryId,
                        principalTable: "PageCategory",
                        principalColumn: "PageCategoryId",
                        onDelete: ReferentialAction.Restrict);
                    table.ForeignKey(
                        name: "FK_Page_Navigation_SidebarLeftId",
                        column: x => x.SidebarLeftId,
                        principalTable: "Navigation",
                        principalColumn: "NavigationId",
                        onDelete: ReferentialAction.Restrict);
                    table.ForeignKey(
                        name: "FK_Page_Navigation_SidebarRightId",
                        column: x => x.SidebarRightId,
                        principalTable: "Navigation",
                        principalColumn: "NavigationId",
                        onDelete: ReferentialAction.Restrict);
                });

            migrationBuilder.CreateTable(
                name: "SectionContentBlock",
                columns: table => new
                {
                    SectionContentBlockId = table.Column<int>(nullable: false)
                        .Annotation("SqlServer:ValueGenerationStrategy", SqlServerValueGenerationStrategy.IdentityColumn),
                    ContentBlockId = table.Column<int>(nullable: false),
                    CreateTimestamp = table.Column<DateTime>(nullable: false),
                    CreateUser = table.Column<string>(nullable: true),
                    SectionId = table.Column<int>(nullable: false),
                    UpdateTimestamp = table.Column<DateTime>(nullable: false),
                    UpdateUser = table.Column<string>(nullable: true)
                },
                constraints: table =>
                {
                    table.PrimaryKey("PK_SectionContentBlock", x => x.SectionContentBlockId);
                    table.ForeignKey(
                        name: "FK_SectionContentBlock_ContentBlock_ContentBlockId",
                        column: x => x.ContentBlockId,
                        principalTable: "ContentBlock",
                        principalColumn: "ContentBlockId",
                        onDelete: ReferentialAction.Cascade);
                    table.ForeignKey(
                        name: "FK_SectionContentBlock_Section_SectionId",
                        column: x => x.SectionId,
                        principalTable: "Section",
                        principalColumn: "SectionId",
                        onDelete: ReferentialAction.Cascade);
                });

            migrationBuilder.CreateTable(
                name: "Link",
                columns: table => new
                {
                    LinkId = table.Column<int>(nullable: false)
                        .Annotation("SqlServer:ValueGenerationStrategy", SqlServerValueGenerationStrategy.IdentityColumn),
                    CreateTimestamp = table.Column<DateTime>(nullable: false),
                    CreateUser = table.Column<string>(nullable: true),
                    Description = table.Column<string>(maxLength: 30, nullable: false),
                    IconId = table.Column<int>(nullable: false),
                    LinkCategoryId = table.Column<int>(nullable: true),
                    MediaId = table.Column<int>(nullable: false),
                    PageId = table.Column<int>(nullable: false),
                    Status = table.Column<string>(maxLength: 1, nullable: false),
                    UpdateTimestamp = table.Column<DateTime>(nullable: false),
                    UpdateUser = table.Column<string>(nullable: true),
                    Url = table.Column<string>(nullable: true)
                },
                constraints: table =>
                {
                    table.PrimaryKey("PK_Link", x => x.LinkId);
                    table.ForeignKey(
                        name: "FK_Link_Icon_IconId",
                        column: x => x.IconId,
                        principalTable: "Icon",
                        principalColumn: "IconId",
                        onDelete: ReferentialAction.Cascade);
                    table.ForeignKey(
                        name: "FK_Link_LinkCategory_LinkCategoryId",
                        column: x => x.LinkCategoryId,
                        principalTable: "LinkCategory",
                        principalColumn: "LinkCategoryId",
                        onDelete: ReferentialAction.Restrict);
                    table.ForeignKey(
                        name: "FK_Link_Media_MediaId",
                        column: x => x.MediaId,
                        principalTable: "Media",
                        principalColumn: "MediaId",
                        onDelete: ReferentialAction.Cascade);
                    table.ForeignKey(
                        name: "FK_Link_Page_PageId",
                        column: x => x.PageId,
                        principalTable: "Page",
                        principalColumn: "PageId",
                        onDelete: ReferentialAction.Cascade);
                });

            migrationBuilder.CreateTable(
                name: "PageSection",
                columns: table => new
                {
                    PageSectionId = table.Column<int>(nullable: false)
                        .Annotation("SqlServer:ValueGenerationStrategy", SqlServerValueGenerationStrategy.IdentityColumn),
                    CreateTimestamp = table.Column<DateTime>(nullable: false),
                    CreateUser = table.Column<string>(nullable: true),
                    PageId = table.Column<int>(nullable: false),
                    SectionId = table.Column<int>(nullable: false),
                    UpdateTimestamp = table.Column<DateTime>(nullable: false),
                    UpdateUser = table.Column<string>(nullable: true)
                },
                constraints: table =>
                {
                    table.PrimaryKey("PK_PageSection", x => x.PageSectionId);
                    table.ForeignKey(
                        name: "FK_PageSection_Page_PageId",
                        column: x => x.PageId,
                        principalTable: "Page",
                        principalColumn: "PageId",
                        onDelete: ReferentialAction.Cascade);
                    table.ForeignKey(
                        name: "FK_PageSection_Section_SectionId",
                        column: x => x.SectionId,
                        principalTable: "Section",
                        principalColumn: "SectionId",
                        onDelete: ReferentialAction.Cascade);
                });

            migrationBuilder.CreateIndex(
                name: "RoleNameIndex",
                table: "IdentityRole",
                column: "NormalizedName");

            migrationBuilder.CreateIndex(
                name: "IX_IdentityRoleClaim<string>_RoleId",
                table: "IdentityRoleClaim<string>",
                column: "RoleId");

            migrationBuilder.CreateIndex(
                name: "IX_IdentityUserClaim<string>_UserId",
                table: "IdentityUserClaim<string>",
                column: "UserId");

            migrationBuilder.CreateIndex(
                name: "IX_IdentityUserLogin<string>_UserId",
                table: "IdentityUserLogin<string>",
                column: "UserId");

            migrationBuilder.CreateIndex(
                name: "IX_IdentityUserRole<string>_RoleId",
                table: "IdentityUserRole<string>",
                column: "RoleId");

            migrationBuilder.CreateIndex(
                name: "IX_IdentityUserRole<string>_UserId",
                table: "IdentityUserRole<string>",
                column: "UserId");

            migrationBuilder.CreateIndex(
                name: "IX_Contact_ContactCategoryId",
                table: "Contact",
                column: "ContactCategoryId");

            migrationBuilder.CreateIndex(
                name: "IX_Contact_IconId",
                table: "Contact",
                column: "IconId");

            migrationBuilder.CreateIndex(
                name: "IX_Contact_MediaId",
                table: "Contact",
                column: "MediaId");

            migrationBuilder.CreateIndex(
                name: "IX_ContentBlock_ContentBlockCategoryId",
                table: "ContentBlock",
                column: "ContentBlockCategoryId");

            migrationBuilder.CreateIndex(
                name: "IX_ContentBlockMedia_ContentBlockId",
                table: "ContentBlockMedia",
                column: "ContentBlockId");

            migrationBuilder.CreateIndex(
                name: "IX_ContentBlockMedia_MediaId",
                table: "ContentBlockMedia",
                column: "MediaId");

            migrationBuilder.CreateIndex(
                name: "IX_Icon_IconCategoryId",
                table: "Icon",
                column: "IconCategoryId");

            migrationBuilder.CreateIndex(
                name: "IX_Link_IconId",
                table: "Link",
                column: "IconId");

            migrationBuilder.CreateIndex(
                name: "IX_Link_LinkCategoryId",
                table: "Link",
                column: "LinkCategoryId");

            migrationBuilder.CreateIndex(
                name: "IX_Link_MediaId",
                table: "Link",
                column: "MediaId");

            migrationBuilder.CreateIndex(
                name: "IX_Link_PageId",
                table: "Link",
                column: "PageId");

            migrationBuilder.CreateIndex(
                name: "IX_Media_MediaCategoryId",
                table: "Media",
                column: "MediaCategoryId");

            migrationBuilder.CreateIndex(
                name: "IX_Navigation_NavigationCategoryId",
                table: "Navigation",
                column: "NavigationCategoryId");

            migrationBuilder.CreateIndex(
                name: "IX_Navigation_TemplateId",
                table: "Navigation",
                column: "TemplateId");

            migrationBuilder.CreateIndex(
                name: "IX_Page_FooterId",
                table: "Page",
                column: "FooterId");

            migrationBuilder.CreateIndex(
                name: "IX_Page_HeaderId",
                table: "Page",
                column: "HeaderId");

            migrationBuilder.CreateIndex(
                name: "IX_Page_NavigationId",
                table: "Page",
                column: "NavigationId");

            migrationBuilder.CreateIndex(
                name: "IX_Page_PageCategoryId",
                table: "Page",
                column: "PageCategoryId");

            migrationBuilder.CreateIndex(
                name: "IX_Page_SidebarLeftId",
                table: "Page",
                column: "SidebarLeftId");

            migrationBuilder.CreateIndex(
                name: "IX_Page_SidebarRightId",
                table: "Page",
                column: "SidebarRightId");

            migrationBuilder.CreateIndex(
                name: "IX_PageSection_PageId",
                table: "PageSection",
                column: "PageId");

            migrationBuilder.CreateIndex(
                name: "IX_PageSection_SectionId",
                table: "PageSection",
                column: "SectionId");

            migrationBuilder.CreateIndex(
                name: "IX_Section_TemplateId",
                table: "Section",
                column: "TemplateId");

            migrationBuilder.CreateIndex(
                name: "IX_SectionContentBlock_ContentBlockId",
                table: "SectionContentBlock",
                column: "ContentBlockId");

            migrationBuilder.CreateIndex(
                name: "IX_SectionContentBlock_SectionId",
                table: "SectionContentBlock",
                column: "SectionId");

            migrationBuilder.CreateIndex(
                name: "IX_Setting_IconId",
                table: "Setting",
                column: "IconId");

            migrationBuilder.CreateIndex(
                name: "IX_Setting_MediaId",
                table: "Setting",
                column: "MediaId");

            migrationBuilder.CreateIndex(
                name: "IX_Setting_SettingCategoryId",
                table: "Setting",
                column: "SettingCategoryId");

            migrationBuilder.CreateIndex(
                name: "IX_Template_TemplateCategoryId",
                table: "Template",
                column: "TemplateCategoryId");

            migrationBuilder.CreateIndex(
                name: "IX_TemplateSetting_SettingId",
                table: "TemplateSetting",
                column: "SettingId");

            migrationBuilder.CreateIndex(
                name: "IX_TemplateSetting_TemplateId",
                table: "TemplateSetting",
                column: "TemplateId");

            migrationBuilder.CreateIndex(
                name: "EmailIndex",
                table: "ApplicationUser",
                column: "NormalizedEmail");

            migrationBuilder.CreateIndex(
                name: "UserNameIndex",
                table: "ApplicationUser",
                column: "NormalizedUserName",
                unique: true);
        }

        protected override void Down(MigrationBuilder migrationBuilder)
        {
            migrationBuilder.DropTable(
                name: "IdentityRoleClaim<string>");

            migrationBuilder.DropTable(
                name: "IdentityUserClaim<string>");

            migrationBuilder.DropTable(
                name: "IdentityUserLogin<string>");

            migrationBuilder.DropTable(
                name: "IdentityUserRole<string>");

            migrationBuilder.DropTable(
                name: "IdentityUserToken<string>");

            migrationBuilder.DropTable(
                name: "Contact");

            migrationBuilder.DropTable(
                name: "ContentBlockMedia");

            migrationBuilder.DropTable(
                name: "Languaje");

            migrationBuilder.DropTable(
                name: "Link");

            migrationBuilder.DropTable(
                name: "PageSection");

            migrationBuilder.DropTable(
                name: "SectionContentBlock");

            migrationBuilder.DropTable(
                name: "TemplateSetting");

            migrationBuilder.DropTable(
                name: "IdentityRole");

            migrationBuilder.DropTable(
                name: "ApplicationUser");

            migrationBuilder.DropTable(
                name: "ContactCategory");

            migrationBuilder.DropTable(
                name: "LinkCategory");

            migrationBuilder.DropTable(
                name: "Page");

            migrationBuilder.DropTable(
                name: "ContentBlock");

            migrationBuilder.DropTable(
                name: "Section");

            migrationBuilder.DropTable(
                name: "Setting");

            migrationBuilder.DropTable(
                name: "Navigation");

            migrationBuilder.DropTable(
                name: "PageCategory");

            migrationBuilder.DropTable(
                name: "ContentBlockCategory");

            migrationBuilder.DropTable(
                name: "Icon");

            migrationBuilder.DropTable(
                name: "Media");

            migrationBuilder.DropTable(
                name: "SettingCategory");

            migrationBuilder.DropTable(
                name: "NavigationCategory");

            migrationBuilder.DropTable(
                name: "Template");

            migrationBuilder.DropTable(
                name: "IconCategory");

            migrationBuilder.DropTable(
                name: "MediaCategory");

            migrationBuilder.DropTable(
                name: "TemplateCategory");
        }
    }
}


text:
// Copyright (c) Microsoft Corporation. All rights reserved.
// Licensed under the MIT License.

using System;
using System.Collections.Generic;
using System.Text;

namespace Azure.Messaging.EventGrid
{
    /// <summary>
    /// SAS token used to authenticate to the Event Grid service.
    /// </summary>
    public class SharedAccessSignatureCredential
    {
        /// <summary>
        /// Initializes a new instance of the <see cref="SharedAccessSignatureCredential"/> class.
        /// </summary>
        /// <param name="signature">SAS token used for authentication</param>
        public SharedAccessSignatureCredential(string signature)
        {
            Signature = signature;
        }
        /// <summary>
        /// SAS token used to authenticate to the Event Grid service.
        /// </summary>
        public string Signature { get; }
    }
}

redpajama_set_name: RedPajamaGithub


text:
//========= Copyright © 1996-2005, Valve Corporation, All rights reserved. ============//
//
// Purpose: Base class for many flying NPCs
//
// $NoKeywords: $
//=============================================================================//

#include "cbase.h"
#include "ai_basenpc_physicsflyer.h"
#include "ai_route.h"
#include "ai_navigator.h"
#include "ai_motor.h"
#include "physics_saverestore.h"

// memdbgon must be the last include file in a .cpp file!!!
#include "tier0/memdbgon.h"

BEGIN_DATADESC( CAI_BasePhysicsFlyingBot )

	DEFINE_FIELD( m_vCurrentVelocity,			FIELD_VECTOR),
	DEFINE_FIELD( m_vCurrentBanking,			FIELD_VECTOR),
	DEFINE_FIELD( m_vNoiseMod,				FIELD_VECTOR),
	DEFINE_FIELD( m_fHeadYaw,					FIELD_FLOAT),
	DEFINE_FIELD( m_vLastPatrolDir,			FIELD_VECTOR),

	DEFINE_PHYSPTR( m_pMotionController ),

END_DATADESC()

//------------------------------------------------------------------------------
// Purpose : Override to return correct velocity
// Input   :
// Output  :
//------------------------------------------------------------------------------
void CAI_BasePhysicsFlyingBot::GetVelocity(Vector *vVelocity, AngularImpulse *vAngVelocity)
{
	Assert( GetMoveType() == MOVETYPE_VPHYSICS );
	if ( VPhysicsGetObject() )
	{
		VPhysicsGetObject()->GetVelocity( vVelocity, vAngVelocity );
	}
	else
	{
		if ( vVelocity )
		{
			vVelocity->Init();
		}
		if ( vAngVelocity )
		{
			vAngVelocity->Init();
		}
	}
}

//-----------------------------------------------------------------------------
// Purpose: Turn head yaw into facing direction
// Input  :
// Output :
//-----------------------------------------------------------------------------
QAngle CAI_BasePhysicsFlyingBot::BodyAngles()
{
	return QAngle(0,m_fHeadYaw,0);
}

//-----------------------------------------------------------------------------
// Purpose:
// Input  :
// Output :
//-----------------------------------------------------------------------------
void CAI_BasePhysicsFlyingBot::TurnHeadToTarget(float flInterval, const Vector &MoveTarget )
{
	float desYaw = UTIL_AngleDiff(VecToYaw(MoveTarget - GetLocalOrigin()), 0 );

	m_fHeadYaw = desYaw;

	return;

	// If I've flipped completely around, reverse angles
	float fYawDiff = m_fHeadYaw - desYaw;
	if (fYawDiff > 180)
	{
		m_fHeadYaw -= 360;
	}
	else if (fYawDiff < -180)
	{
		m_fHeadYaw += 360;
	}

	// RIGHT NOW, this affects every flying bot. This rate should be member data that individuals
	// can manipulate. THIS change for MANHACKS E3 2003 (sjb)
	float iRate = 0.8;

	// Make frame rate independent
	float timeToUse = flInterval;
	while (timeToUse > 0)
	{
		m_fHeadYaw	   = (iRate * m_fHeadYaw) + (1-iRate)*desYaw;
		timeToUse -= 0.1;
	}

	while( m_fHeadYaw > 360 )
	{
		m_fHeadYaw -= 360.0f;
	}

	while( m_fHeadYaw < 0 )
	{
		m_fHeadYaw += 360.f;
	}

	// SetBoneController( 0, m_fHeadYaw );
}

//------------------------------------------------------------------------------
// Purpose :
// Input   :
// Output  :
//------------------------------------------------------------------------------
float CAI_BasePhysicsFlyingBot::MinGroundDist(void)
{
	return 0;
}

//------------------------------------------------------------------------------
// Purpose :
// Input   :
// Output  :
//------------------------------------------------------------------------------
Vector CAI_BasePhysicsFlyingBot::VelocityToAvoidObstacles(float flInterval)
{
	// --------------------------------
	//  Avoid banging into stuff
	// --------------------------------
	trace_t tr;
	Vector vTravelDir = m_vCurrentVelocity*flInterval;
	Vector endPos = GetAbsOrigin() + vTravelDir;
	AI_TraceEntity( this, GetAbsOrigin(), endPos, GetAITraceMask()|CONTENTS_WATER, &tr);
	if (tr.fraction != 1.0)
	{
		// Bounce off in normal
		Vector vBounce = tr.plane.normal * 0.5 * m_vCurrentVelocity.Length();
		return (vBounce);
	}

	// --------------------------------
	// Try to remain above the ground.
	// --------------------------------
	float flMinGroundDist = MinGroundDist();
	AI_TraceLine(GetAbsOrigin(), GetAbsOrigin() + Vector(0, 0, -flMinGroundDist),
		GetAITraceMask_BrushOnly()|CONTENTS_WATER, this, COLLISION_GROUP_NONE, &tr);
	if (tr.fraction < 1)
	{
		// Clamp veloctiy
		if (tr.fraction < 0.1)
		{
			tr.fraction = 0.1;
		}

		return Vector(0, 0, 50/tr.fraction);
	}
	return vec3_origin;
}

//------------------------------------------------------------------------------
// Purpose :
// Input   :
// Output  :
//------------------------------------------------------------------------------
void CAI_BasePhysicsFlyingBot::StartTask( const Task_t *pTask )
{
	switch (pTask->iTask)
	{
		// Skip as done via bone controller
		case TASK_FACE_ENEMY:
		{
			TaskComplete();
			break;
		}
		// Activity is just idle (have no run)
		case TASK_RUN_PATH:
		{
			GetNavigator()->SetMovementActivity(ACT_IDLE);
			TaskComplete();
			break;
		}
		// Don't check for run/walk activity
		case TASK_SCRIPT_RUN_TO_TARGET:
		case TASK_SCRIPT_WALK_TO_TARGET:
		{
			if (GetTarget() == NULL)
			{
				TaskFail(FAIL_NO_TARGET);
			}
			else
			{
				if (!GetNavigator()->SetGoal( GOALTYPE_TARGETENT ) )
				{
					TaskFail(FAIL_NO_ROUTE);
					GetNavigator()->ClearGoal();
				}
			}
			TaskComplete();
			break;
		}
		// Override to get more to get a directional path
		case TASK_GET_PATH_TO_RANDOM_NODE:
		{
			if ( GetNavigator()->SetRandomGoal( pTask->flTaskData, m_vLastPatrolDir ) )
				TaskComplete();
			else
				TaskFail(FAIL_NO_REACHABLE_NODE);
			break;
		}
		default:
		{
			BaseClass::StartTask(pTask);
		}
	}
}

//------------------------------------------------------------------------------

void CAI_BasePhysicsFlyingBot::MoveToTarget(float flInterval, const Vector &MoveTarget)
{
	Assert(0);	// This must be overridden in the leaf classes
}

//------------------------------------------------------------------------------

AI_NavPathProgress_t CAI_BasePhysicsFlyingBot::ProgressFlyPath(
	float flInterval,
	const CBaseEntity *pNewTarget,
	unsigned collisionMask,
	bool bNewTrySimplify,
	float strictPointTolerance)
{
  	AI_ProgressFlyPathParams_t params( collisionMask );
	params.strictPointTolerance = strictPointTolerance;
	params.SetCurrent( pNewTarget, bNewTrySimplify );

	AI_NavPathProgress_t progress = GetNavigator()->ProgressFlyPath( params );

	switch ( progress )
	{
		case AINPP_NO_CHANGE:
		case AINPP_ADVANCED:
		{
			MoveToTarget(flInterval, GetNavigator()->GetCurWaypointPos());
			break;
		}

		case AINPP_COMPLETE:
		{
			TaskMovementComplete();
			break;
		}

		case AINPP_BLOCKED: // function is not supposed to test blocking, just simple path progression
		default:
		{
			AssertMsg( 0, ( "Unexpected result" ) );
			break;
		}
	}

	return progress;
}

//------------------------------------------------------------------------------
// Purpose :
// Input   :
// Output  :
//------------------------------------------------------------------------------
CAI_BasePhysicsFlyingBot::CAI_BasePhysicsFlyingBot()
{
#ifdef _DEBUG
	m_vCurrentVelocity.Init();
	m_vCurrentBanking.Init();
	m_vLastPatrolDir.Init();
#endif
}

//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
CAI_BasePhysicsFlyingBot::~CAI_BasePhysicsFlyingBot( void )
{
	physenv->DestroyMotionController( m_pMotionController );
}

//-----------------------------------------------------------------------------
// Purpose:
//
//
//-----------------------------------------------------------------------------
bool CAI_BasePhysicsFlyingBot::CreateVPhysics( void )
{
	// Create the object in the physics system
	IPhysicsObject *pPhysicsObject = VPhysicsInitNormal( SOLID_BBOX, FSOLID_NOT_STANDABLE, false );

	m_pMotionController = physenv->CreateMotionController( this );
	m_pMotionController->AttachObject( pPhysicsObject, true );
	return true;
}

//-----------------------------------------------------------------------------
// Purpose:
// Input  : *pTarget -
//			&chasePosition -
//-----------------------------------------------------------------------------
void CAI_BasePhysicsFlyingBot::TranslateNavGoal( CBaseEntity *pTarget, Vector &chasePosition )
{
	Assert( pTarget != NULL );

	if ( pTarget == NULL )
	{
		chasePosition = vec3_origin;
		return;
	}

	// Chase their eyes
	chasePosition = pTarget->GetAbsOrigin() + pTarget->GetViewOffset();
}

//-----------------------------------------------------------------------------
// Purpose:
// Input  : *pController -
//			*pObject -
//			deltaTime -
//			&linear -
//			&angular -
// Output : IMotionEvent::simresult_e
//-----------------------------------------------------------------------------
IMotionEvent::simresult_e CAI_BasePhysicsFlyingBot::Simulate( IPhysicsMotionController *pController, IPhysicsObject *pObject, float deltaTime, Vector &linear, AngularImpulse &angular )
{
	static int count;

	IPhysicsObject *pPhysicsObject = VPhysicsGetObject();
	// Assert( pPhysicsObject );
	if (!pPhysicsObject)
		return SIM_NOTHING;

	// move
	Vector actualVelocity;
	AngularImpulse actualAngularVelocity;
	pPhysicsObject->GetVelocity( &actualVelocity, &actualAngularVelocity );
	linear = (m_vCurrentVelocity - actualVelocity) * (0.1 / deltaTime) * 10.0;

	/*
	DevMsg("Sim %d : %5.1f %5.1f %5.1f\n", count++,
		m_vCurrentVelocity.x - actualVelocity.x,
		m_vCurrentVelocity.y - actualVelocity.y,
		m_vCurrentVelocity.z - actualVelocity.z );
	*/

	// do angles.
	Vector actualPosition;
	QAngle actualAngles;
	pPhysicsObject->GetPosition( &actualPosition, &actualAngles );

	// FIXME: banking currently disabled, forces simple upright posture
	angular.x = (UTIL_AngleDiff( m_vCurrentBanking.z, actualAngles.z ) - actualAngularVelocity.x) * (1 / deltaTime);
	angular.y = (UTIL_AngleDiff( m_vCurrentBanking.x, actualAngles.x ) - actualAngularVelocity.y) * (1 / deltaTime);

	// turn toward target
	angular.z = UTIL_AngleDiff( m_fHeadYaw, actualAngles.y + actualAngularVelocity.z * 0.1 ) * (1 / deltaTime);

	// angular = m_vCurrentAngularVelocity - actualAngularVelocity;

	// DevMsg("Sim %d : %.1f %.1f %.1f (%.1f)\n", count++, actualAngles.x, actualAngles.y, actualAngles.z, m_fHeadYaw );

	// FIXME: remove the stuff from MoveExecute();
	// FIXME: check MOVE?

	ClampMotorForces( linear, angular );

	return SIM_GLOBAL_ACCELERATION; // on my local axis.   SIM_GLOBAL_ACCELERATION
}


text:
module ActiveRecord
  module Type
    class Decimal < Value # :nodoc:
      include Numeric

      def type
        :decimal
      end

      def type_cast_for_schema(value)
        value.to_s
      end

      private

      def cast_value(value)
        case value
        when ::Float
          BigDecimal(value, float_precision)
        when ::Numeric, ::String
          BigDecimal(value, precision.to_i)
        else
          if value.respond_to?(:to_d)
            value.to_d
          else
            cast_value(value.to_s)
          end
        end
      end

      def float_precision
        if precision.to_i > ::Float::DIG + 1
          ::Float::DIG + 1
        else
          precision.to_i
        end
      end
    end
  end
end


text:
function somethingElse(something) {
  console.log('Wow, look at that!', something);
}

module.exports = somethingElse;


text:
package io.druid.cli;

import io.airlift.airline.Cli;

/**
 */
public interface CliCommandCreator
{
  void addCommands(Cli.CliBuilder builder);
}


text:
<!DOCTYPE html>

    <meta charset="utf-8">
    <meta http-equiv="X-UA-Compatible" content="IE=edge">
    <meta name="viewport" content="width=device-width, initial-scale=1">

    <title>Inicio </title>

    <link href="css/bootstrap.min.css" rel="stylesheet">

  		<input type="date" name="fecha">
  		<input type="datetime" name="fechahora">

Lavanderia abc

		        	         	  <input type="number" class="form-control form-effect" name="celular" placeholder="celular">

																			    Inicio

Nosotros

Servicio

Contacto

lavado

Este es el lavado!!

lavado

Este es el lavado!!

lavado

Este es el lavado!!

lavado

Este es el lavado!!

									    Anterior

									    Siguiente

Mision

Vision

LA  LAVANDERÍA tiene un objetivo explícito:

														Para proporcionar a los residentes y negocios de abancay con el servicio de lavandería  calidad más alta para el Wash-N-Fold, Seco-Limpieza y Servicios Toalla comerciales sin cobrar precios de cinco estrellas, la creación de una forma cómoda y sencilla para conseguir hacer de lavandería.

														Nos esforzamos por ofrecer a nuestros clientes con un método simple y conveniente para lavar la ropa utilizando gente disciplinada, pensamiento disciplinado y acción disciplinada.

LA LAVANDERIA quiere ser lider en el secor lavado de ropas en la regio  apurimac en facebock ubiquenos como lavanderiaabc

		        								<address>
												  Facebock, Lavanderia ABC.

												  av Panamericana s/n

												  calle dias barcenas 323

												  P: (083) 324-448
												</address>

												<address>
												  LAVANDERIA ABC

												  lavanderiaabc@gmail.com

																				        <button type="button" class="close" data-dismiss="modal" aria-label="Close">×</button>

Enviando mensaje a lavanderia ABC

																				        <form>

																				            Titulo:
																				            <input type="text" class="form-control" id="recipient-name">

																				            Mensaje:
																				            <textarea class="form-control" id="message-text"></textarea>

																				        </form>

																				        <button type="button" class="btn btn-default" data-dismiss="modal">Cerrar</button>
																				        <button type="button" class="btn btn-primary">Enviar mensaje</button>

												</address>

														        <form class="form-inline">

												    Nombre
												    <input type="text" class="form-control" id="exampleInputName2" placeholder="richard">

												    Email
												    <input type="email" class="form-control" id="exampleInputEmail2" placeholder="email@ejemplo.com">

												  Registrarte

												</form>

© 2015 Lavandería abc, S.R.L,Abancay


text:
package org.sindice.siren.qparser.keyword.builders;

import org.apache.lucene.index.Term;
import org.apache.lucene.queryparser.flexible.core.QueryNodeException;
import org.apache.lucene.queryparser.flexible.core.nodes.QueryNode;
import org.apache.lucene.queryparser.flexible.standard.builders.RegexpQueryNodeBuilder;
import org.apache.lucene.queryparser.flexible.standard.builders.StandardQueryBuilder;
import org.apache.lucene.queryparser.flexible.standard.nodes.RegexpQueryNode;
import org.sindice.siren.qparser.keyword.processors.MultiNodeTermRewriteMethodProcessor;
import org.sindice.siren.search.node.MultiNodeTermQuery;
import org.sindice.siren.search.node.NodeQuery;
import org.sindice.siren.search.node.NodeRegexpQuery;

/**
 * Builds a {@link NodeRegexpQuery} object from a {@link RegexpQueryNode} object.
 *
 * <p>
 *
 * Code taken from {@link RegexpQueryNodeBuilder} and adapted for SIREn.
 */
public class NodeRegexpQueryNodeBuilder implements StandardQueryBuilder {

  public NodeRegexpQueryNodeBuilder() {
    // empty constructor
  }

  public NodeQuery build(final QueryNode queryNode) throws QueryNodeException {
    final RegexpQueryNode regexpNode = (RegexpQueryNode) queryNode;

    final NodeRegexpQuery q = new NodeRegexpQuery(new Term(regexpNode.getFieldAsString(),
        regexpNode.textToBytesRef()));

    final MultiNodeTermQuery.RewriteMethod method = (MultiNodeTermQuery.RewriteMethod) queryNode
        .getTag(MultiNodeTermRewriteMethodProcessor.TAG_ID);
    if (method != null) {
      q.setRewriteMethod(method);
    }
    return q;
  }

}


text:
package com.navercorp.test.pinpoint.jdk8.lambda;

/**
 * @author Jongho Moon
 *
 */
public class Maru {
    public boolean test(Morae morae) {
        return morae.test((m) -> m.getAge() > 1);
    }
}


text:
package com.genymobile.relay;

import java.nio.channels.Selector;
import java.util.Timer;
import java.util.TimerTask;

public class SelectorAlarm {

    private static final int CLEANING_INTERVAL = 60 * 1000;

    private final Selector selector;
    private final Timer timer = new Timer();
    private final TimerTask timerTask = new TimerTask() {
        @Override
        public void run() {
            tick();
        }
    };

    private boolean signaled;

    public SelectorAlarm(Selector selector) {
        this.selector = selector;
    }

    public void start() {
        timer.scheduleAtFixedRate(timerTask, UDPConnection.IDLE_TIMEOUT, CLEANING_INTERVAL);
    }

    public void stop() {
        timer.cancel();
    }

    private synchronized void tick() {
        signaled = true;
        selector.wakeup();
    }

    public synchronized boolean accept() {
        if (signaled) {
            signaled = false;
            return true;
        }
        return false;
    }
}


text:
\section{\textbf{BackoffLockTest}}

\subsection{Particular Case (problem)}
This is part of the chapter 7, where we are dealing with the generic
issue of building real-life lock implementations that solve the
mutual exclusion problem. The particular subproblem is doing that
with spinning locks (those which repeatedly try to acquire the lock);
and the very concrete sub-subproblem here is how to reduce the
contention out of the \C{TTASLock}.

\subsection{Solution}
The solution is based on a key observation, for which we need to cite
the \C{TTASLock} code first: \\

\begin{lstlisting}[style=numbers]
public class TTASLock implements Lock {
  AtomicBoolean state = new AtomicBoolean(false);
  public void lock() {
    while (true) {
      while (state.get()) {};  // spin
      if (!state.getAndSet(true))
        return;
    }
  }
  public void unlock() {
    state.set(false);
  }
  ...
}
\end{lstlisting}
\hfill

If between the calls to \C{get} and \C{getAndSet}, another thread took
the look; then it must be that there is high contention for such
resource (many threads trying to acquire it). Insisting on acquiring
the lock on high contention scenarios is a bad idea; we will add a lot
of traffic to the bus used by cores to communicate (as primitive
\C{getAndSet} forces reads to be consistent) and the chances of
getting it are scarce (too much competition). \\

The solution then, is to wait some time before retrying; how much?
Well, the more we fail to acquire the lock the more we wait next time.
The concrete solution for that, on the context of this test, is to use
what is called ``adaptive exponential backoff''. Each time we fail to
acquire the lock, a random number is generated within a given range
and the thread sleeps that time \footnote{This sample uses
  milliseconds, a common unit when dealing with multi-thread
  programming}. Every time we do this waiting, the range is enlarged
twice (meaning that on average the random number is twice large);
this is done up to a maximum established (1024 in this case).
Code is presented below for reference (note that we also have a lower
bound for the minimum amount of time to wait; being 32 milliseconds
here): \\

\begin{lstlisting}[style=numbers]
public class BackoffLock implements Lock {
  private Backoff backoff;
  private AtomicBoolean state = new AtomicBoolean(false);
  private static final int MIN_DELAY = 32;
  private static final int MAX_DELAY = 1024;
  public void lock() {
    Backoff backoff = new Backoff(MIN_DELAY, MAX_DELAY);
    while (true) {
      while (state.get()) {};	// spin
      if (!state.getAndSet(true)) { // try to acquire lock
        return;
      } else {			// backoff on failure
        try {
          backoff.backoff();
        } catch (InterruptedException ex) {
        }
      }
    }
  }
  public void unlock() {
    state.set(false);
  }
  ...
}

public class Backoff {
  ...

  /**
   * Backoff for random duration.
   * @throws java.lang.InterruptedException
   */
  public void backoff() throws InterruptedException {
    int delay = random.nextInt(limit);
    if (limit < maxDelay) { // double limit if less than max
      limit = 2 * limit;
    }
    Thread.sleep(delay);
  }
}
\end{lstlisting}
\hfill

By the way, the code for \C{Backoff} has an error (not shown above to
save space in this report); the argument
\C{max} passed to the constructor is not really used (there seems to
be a typo there, where we used \C{min} parameter instead).

\subsection{Experiment Description}

The test consists in a single case \C{testParallel}, which creates 8
threads and puts each one to increase 1024 times a shared counter. The
access to the counter is protected by the \C{BackoffLock} solution we
described already. The assertion of the test is that the shared
counter ends up with a final value, that reflects the fact that all
the thread contributions are present (nobody lost increments, and we
do not have more than expected).

\subsection{Observations and Interpretations}
With or without the fix mentioned about the \C{max} argument
constructor in \C{Backoff} class, the test works fine on 2 and 24
cores. Below a sample execution: \\

\begin{verbatim}
.parallel

Time: 0.075

OK (1 test)
\end{verbatim}
\hfill


text:
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace NDomain.Bus
{
    public interface IProcessor : IDisposable
    {
        void Start();
        void Stop();

        bool IsRunning { get; }
    }
}


text:
#pragma once
#include <aws/identitystore/IdentityStore_EXPORTS.h>
#include <aws/identitystore/IdentityStoreErrors.h>
#include <aws/core/client/AWSError.h>
#include <aws/core/client/ClientConfiguration.h>
#include <aws/core/client/AWSClient.h>
#include <aws/core/utils/memory/stl/AWSString.h>
#include <aws/core/utils/json/JsonSerializer.h>
#include <aws/identitystore/model/DescribeGroupResult.h>
#include <aws/identitystore/model/DescribeUserResult.h>
#include <aws/identitystore/model/ListGroupsResult.h>
#include <aws/identitystore/model/ListUsersResult.h>
#include <aws/core/client/AsyncCallerContext.h>
#include <aws/core/http/HttpTypes.h>
#include <future>
#include <functional>

namespace Aws
{

namespace Http
{
  class HttpClient;
  class HttpClientFactory;
} // namespace Http

namespace Utils
{
  template< typename R, typename E> class Outcome;
namespace Threading
{
  class Executor;
} // namespace Threading
} // namespace Utils

namespace Auth
{
  class AWSCredentials;
  class AWSCredentialsProvider;
} // namespace Auth

namespace Client
{
  class RetryStrategy;
} // namespace Client

namespace IdentityStore
{

namespace Model
{
        class DescribeGroupRequest;
        class DescribeUserRequest;
        class ListGroupsRequest;
        class ListUsersRequest;

        typedef Aws::Utils::Outcome<DescribeGroupResult, IdentityStoreError> DescribeGroupOutcome;
        typedef Aws::Utils::Outcome<DescribeUserResult, IdentityStoreError> DescribeUserOutcome;
        typedef Aws::Utils::Outcome<ListGroupsResult, IdentityStoreError> ListGroupsOutcome;
        typedef Aws::Utils::Outcome<ListUsersResult, IdentityStoreError> ListUsersOutcome;

        typedef std::future<DescribeGroupOutcome> DescribeGroupOutcomeCallable;
        typedef std::future<DescribeUserOutcome> DescribeUserOutcomeCallable;
        typedef std::future<ListGroupsOutcome> ListGroupsOutcomeCallable;
        typedef std::future<ListUsersOutcome> ListUsersOutcomeCallable;
} // namespace Model

  class IdentityStoreClient;

    typedef std::function<void(const IdentityStoreClient*, const Model::DescribeGroupRequest&, const Model::DescribeGroupOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > DescribeGroupResponseReceivedHandler;
    typedef std::function<void(const IdentityStoreClient*, const Model::DescribeUserRequest&, const Model::DescribeUserOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > DescribeUserResponseReceivedHandler;
    typedef std::function<void(const IdentityStoreClient*, const Model::ListGroupsRequest&, const Model::ListGroupsOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > ListGroupsResponseReceivedHandler;
    typedef std::function<void(const IdentityStoreClient*, const Model::ListUsersRequest&, const Model::ListUsersOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > ListUsersResponseReceivedHandler;

  /**
   *
The AWS Single Sign-On (SSO) Identity Store service provides a single place
   * to retrieve all of your identities (users and groups). For more information
   * about AWS, see the AWS
   * Single Sign-On User Guide.

   */
  class AWS_IDENTITYSTORE_API IdentityStoreClient : public Aws::Client::AWSJsonClient
  {
    public:
      typedef Aws::Client::AWSJsonClient BASECLASS;

       /**
        * Initializes client to use DefaultCredentialProviderChain, with default http client factory, and optional client config. If client config
        * is not specified, it will be initialized to default values.
        */
        IdentityStoreClient(const Aws::Client::ClientConfiguration& clientConfiguration = Aws::Client::ClientConfiguration());

       /**
        * Initializes client to use SimpleAWSCredentialsProvider, with default http client factory, and optional client config. If client config
        * is not specified, it will be initialized to default values.
        */
        IdentityStoreClient(const Aws::Auth::AWSCredentials& credentials, const Aws::Client::ClientConfiguration& clientConfiguration = Aws::Client::ClientConfiguration());

       /**
        * Initializes client to use specified credentials provider with specified client config. If http client factory is not supplied,
        * the default http client factory will be used
        */
        IdentityStoreClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
            const Aws::Client::ClientConfiguration& clientConfiguration = Aws::Client::ClientConfiguration());

        virtual ~IdentityStoreClient();

        /**
         *
Retrieves the group metadata and attributes from GroupId in an
         * identity store.

See Also:
   AWS
         * API Reference

         */
        virtual Model::DescribeGroupOutcome DescribeGroup(const Model::DescribeGroupRequest& request) const;

        /**
         * A Callable wrapper for DescribeGroup that returns a future to the operation so that it can be executed in parallel to other requests.
         */
        virtual Model::DescribeGroupOutcomeCallable DescribeGroupCallable(const Model::DescribeGroupRequest& request) const;

        /**
         * An Async wrapper for DescribeGroup that queues the request into a thread executor and triggers associated callback when operation has finished.
         */
        virtual void DescribeGroupAsync(const Model::DescribeGroupRequest& request, const DescribeGroupResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const;

        /**
         *
Retrieves the user metadata and attributes from UserId in an
         * identity store.

See Also:
   AWS
         * API Reference

         */
        virtual Model::DescribeUserOutcome DescribeUser(const Model::DescribeUserRequest& request) const;

        /**
         * A Callable wrapper for DescribeUser that returns a future to the operation so that it can be executed in parallel to other requests.
         */
        virtual Model::DescribeUserOutcomeCallable DescribeUserCallable(const Model::DescribeUserRequest& request) const;

        /**
         * An Async wrapper for DescribeUser that queues the request into a thread executor and triggers associated callback when operation has finished.
         */
        virtual void DescribeUserAsync(const Model::DescribeUserRequest& request, const DescribeUserResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const;

        /**
         *
Lists the attribute name and value of the group that you specified in the
         * search. We only support DisplayName as a valid filter attribute
         * path currently, and filter is required. This API returns minimum attributes,
         * including GroupId and group DisplayName in the
         * response.

See Also:
   AWS
         * API Reference

         */
        virtual Model::ListGroupsOutcome ListGroups(const Model::ListGroupsRequest& request) const;

        /**
         * A Callable wrapper for ListGroups that returns a future to the operation so that it can be executed in parallel to other requests.
         */
        virtual Model::ListGroupsOutcomeCallable ListGroupsCallable(const Model::ListGroupsRequest& request) const;

        /**
         * An Async wrapper for ListGroups that queues the request into a thread executor and triggers associated callback when operation has finished.
         */
        virtual void ListGroupsAsync(const Model::ListGroupsRequest& request, const ListGroupsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const;

        /**
         *
Lists the attribute name and value of the user that you specified in the
         * search. We only support UserName as a valid filter attribute path
         * currently, and filter is required. This API returns minimum attributes,
         * including UserId and UserName in the
         * response.

See Also:
   AWS
         * API Reference

         */
        virtual Model::ListUsersOutcome ListUsers(const Model::ListUsersRequest& request) const;

        /**
         * A Callable wrapper for ListUsers that returns a future to the operation so that it can be executed in parallel to other requests.
         */
        virtual Model::ListUsersOutcomeCallable ListUsersCallable(const Model::ListUsersRequest& request) const;

        /**
         * An Async wrapper for ListUsers that queues the request into a thread executor and triggers associated callback when operation has finished.
         */
        virtual void ListUsersAsync(const Model::ListUsersRequest& request, const ListUsersResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const;

      void OverrideEndpoint(const Aws::String& endpoint);
    private:
      void init(const Aws::Client::ClientConfiguration& clientConfiguration);
        void DescribeGroupAsyncHelper(const Model::DescribeGroupRequest& request, const DescribeGroupResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const;
        void DescribeUserAsyncHelper(const Model::DescribeUserRequest& request, const DescribeUserResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const;
        void ListGroupsAsyncHelper(const Model::ListGroupsRequest& request, const ListGroupsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const;
        void ListUsersAsyncHelper(const Model::ListUsersRequest& request, const ListUsersResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const;

      Aws::String m_uri;
      Aws::String m_configScheme;
      std::shared_ptr<Aws::Utils::Threading::Executor> m_executor;
  };

} // namespace IdentityStore
} // namespace Aws


text:
using ProgrammersSpot.Business.Models.Users;
using ProgrammersSpot.Business.MVP.Args;
using ProgrammersSpot.Business.MVP.Presenters;
using ProgrammersSpot.Business.MVP.ViewModels;
using ProgrammersSpot.Business.MVP.Views;
using System;
using System.Linq;
using System.Web.ModelBinding;
using System.Web.UI;
using WebFormsMvp;
using WebFormsMvp.Web;

namespace ProgrammersSpot.WebClient.Companies
{
    [PresenterBinding(typeof(FirmsPresenter))]
    public partial class Companies : MvpPage<FirmsViewModel>, IFirmsView
    {
        public event EventHandler<EventArgs> EventGetFirms;
        public event EventHandler<SearchEventArgs> EventSearchFirms;

        protected void Page_Load(object sender, EventArgs e)
        {
        }

        public IQueryable<FirmUser> ListViewFirms_GetData([Control] string sortBy, [QueryString("companyName")] string query)
        {
            if (query == null)
            {
                this.EventGetFirms?.Invoke(this, new EventArgs());
            }
            else
            {
                this.EventSearchFirms?.Invoke(this, new SearchEventArgs(query));
            }

            var firms = this.Model.Firms;

            if (sortBy == "Rating")
            {
                if (this.CheckBoxIsDescending.Checked)
                {
                    firms = firms.OrderByDescending(f => f.Rating);
                }
                else
                {
                    firms = firms.OrderBy(f => f.Rating);
                }
            }
            else if (sortBy == "CompanyName")
            {
                if (this.CheckBoxIsDescending.Checked)
                {
                    firms = firms.OrderByDescending(f => f.FirmName);
                }
                else
                {
                    firms = firms.OrderBy(f => f.FirmName);
                }
            }
            else if (sortBy == "EmployeesCount")
            {
                if (this.CheckBoxIsDescending.Checked)
                {
                    firms = firms.OrderByDescending(f => f.EmployeesCount);
                }
                else
                {
                    firms = firms.OrderBy(f => f.EmployeesCount);
                }
            }

            return firms;
        }

        protected void LinkButtonSearch_Click(object sender, EventArgs e)
        {
            string queryParam = string.Format("?companyName={0}", this.TextBoxSearch.Text);
            Response.Redirect(this.ResolveUrl("~/Companies" + queryParam));
        }
    }
}


text:
var router = require('express').Router();
var bodyParser = require('body-parser');

router.get('/', (req, res, next) => {
  res.json({ session: req.session })
});

module.exports = router;


text:
import BasicMaths
import Bayes
import BIQUAD
import ComplexMaths
import Controller
import Convolutions
import Decimate
import Distance
import FastMath
import FIR
import Matrix
import Softmax
import Stats
import Support
import SVM
import Transform

BasicMaths.generatePatterns()
Bayes.generatePatterns()
BIQUAD.generatePatterns()
ComplexMaths.generatePatterns()
Controller.generatePatterns()
Convolutions.generatePatterns()
Decimate.generatePatterns()
Distance.generatePatterns()
FastMath.generatePatterns()
FIR.generatePatterns()
Interpolate.generatePatterns()
Matrix.generatePatterns()
Softmax.generatePatterns()
Stats.generatePatterns()
Support.generatePatterns()
SVM.generatePatterns()
Transform.generatePatterns()