text:
""" PyTorch Swin Transformer model."""

import collections.abc
import math
from dataclasses import dataclass
from typing import Optional, Tuple, Union

import torch
import torch.utils.checkpoint
from torch import nn
from torch.nn import BCEWithLogitsLoss, CrossEntropyLoss, MSELoss

from ...activations import ACT2FN
from ...modeling_utils import PreTrainedModel
from ...pytorch_utils import find_pruneable_heads_and_indices, prune_linear_layer
from ...utils import (
    ModelOutput,
    add_code_sample_docstrings,
    add_start_docstrings,
    add_start_docstrings_to_model_forward,
    logging,
    replace_return_docstrings,
)
from .configuration_swin import SwinConfig

logger = logging.get_logger(__name__)

# General docstring
_CONFIG_FOR_DOC = "SwinConfig"
_FEAT_EXTRACTOR_FOR_DOC = "AutoFeatureExtractor"

# Base docstring
_CHECKPOINT_FOR_DOC = "microsoft/swin-tiny-patch4-window7-224"
_EXPECTED_OUTPUT_SHAPE = [1, 49, 768]

# Image classification docstring
_IMAGE_CLASS_CHECKPOINT = "microsoft/swin-tiny-patch4-window7-224"
_IMAGE_CLASS_EXPECTED_OUTPUT = "tabby, tabby cat"

SWIN_PRETRAINED_MODEL_ARCHIVE_LIST = [
    "microsoft/swin-tiny-patch4-window7-224",
    # See all Swin models at https://huggingface.co/models?filter=swin
]

# drop_path, SwinPatchEmbeddings, SwinPatchMerging and SwinDropPath are from the timm library.

@dataclass
class SwinEncoderOutput(ModelOutput):
    """
    Swin encoder's outputs, with potential hidden states and attentions.

    Args:
        last_hidden_state (`torch.FloatTensor` of shape `(batch_size, sequence_length, hidden_size)`):
            Sequence of hidden-states at the output of the last layer of the model.
        hidden_states (`tuple(torch.FloatTensor)`, *optional*, returned when `output_hidden_states=True` is passed or when `config.output_hidden_states=True`):
            Tuple of `torch.FloatTensor` (one for the output of the embeddings + one for the output of each stage) of
            shape `(batch_size, sequence_length, hidden_size)`.

            Hidden-states of the model at the output of each layer plus the initial embedding outputs.
        attentions (`tuple(torch.FloatTensor)`, *optional*, returned when `output_attentions=True` is passed or when `config.output_attentions=True`):
            Tuple of `torch.FloatTensor` (one for each stage) of shape `(batch_size, num_heads, sequence_length,
            sequence_length)`.

            Attentions weights after the attention softmax, used to compute the weighted average in the self-attention
            heads.
        reshaped_hidden_states (`tuple(torch.FloatTensor)`, *optional*, returned when `output_hidden_states=True` is passed or when `config.output_hidden_states=True`):
            Tuple of `torch.FloatTensor` (one for the output of the embeddings + one for the output of each stage) of
            shape `(batch_size, hidden_size, height, width)`.

            Hidden-states of the model at the output of each layer plus the initial embedding outputs reshaped to
            include the spatial dimensions.
    """

    last_hidden_state: torch.FloatTensor = None
    hidden_states: Optional[Tuple[torch.FloatTensor]] = None
    attentions: Optional[Tuple[torch.FloatTensor]] = None
    reshaped_hidden_states: Optional[Tuple[torch.FloatTensor]] = None

@dataclass
class SwinModelOutput(ModelOutput):
    """
    Swin model's outputs that also contains a pooling of the last hidden states.

    Args:
        last_hidden_state (`torch.FloatTensor` of shape `(batch_size, sequence_length, hidden_size)`):
            Sequence of hidden-states at the output of the last layer of the model.
        pooler_output (`torch.FloatTensor` of shape `(batch_size, hidden_size)`, *optional*, returned when `add_pooling_layer=True` is passed):
            Average pooling of the last layer hidden-state.
        hidden_states (`tuple(torch.FloatTensor)`, *optional*, returned when `output_hidden_states=True` is passed or when `config.output_hidden_states=True`):
            Tuple of `torch.FloatTensor` (one for the output of the embeddings + one for the output of each stage) of
            shape `(batch_size, sequence_length, hidden_size)`.

            Hidden-states of the model at the output of each layer plus the initial embedding outputs.
        attentions (`tuple(torch.FloatTensor)`, *optional*, returned when `output_attentions=True` is passed or when `config.output_attentions=True`):
            Tuple of `torch.FloatTensor` (one for each stage) of shape `(batch_size, num_heads, sequence_length,
            sequence_length)`.

            Attentions weights after the attention softmax, used to compute the weighted average in the self-attention
            heads.
        reshaped_hidden_states (`tuple(torch.FloatTensor)`, *optional*, returned when `output_hidden_states=True` is passed or when `config.output_hidden_states=True`):
            Tuple of `torch.FloatTensor` (one for the output of the embeddings + one for the output of each stage) of
            shape `(batch_size, hidden_size, height, width)`.

            Hidden-states of the model at the output of each layer plus the initial embedding outputs reshaped to
            include the spatial dimensions.
    """

    last_hidden_state: torch.FloatTensor = None
    pooler_output: Optional[torch.FloatTensor] = None
    hidden_states: Optional[Tuple[torch.FloatTensor]] = None
    attentions: Optional[Tuple[torch.FloatTensor]] = None
    reshaped_hidden_states: Optional[Tuple[torch.FloatTensor]] = None

@dataclass
class SwinMaskedImageModelingOutput(ModelOutput):
    """
    Swin masked image model outputs.

    Args:
        loss (`torch.FloatTensor` of shape `(1,)`, *optional*, returned when `bool_masked_pos` is provided):
            Masked image modeling (MLM) loss.
        logits (`torch.FloatTensor` of shape `(batch_size, num_channels, height, width)`):
            Reconstructed pixel values.
        hidden_states (`tuple(torch.FloatTensor)`, *optional*, returned when `output_hidden_states=True` is passed or when `config.output_hidden_states=True`):
            Tuple of `torch.FloatTensor` (one for the output of the embeddings + one for the output of each stage) of
            shape `(batch_size, sequence_length, hidden_size)`.

            Hidden-states of the model at the output of each layer plus the initial embedding outputs.
        attentions (`tuple(torch.FloatTensor)`, *optional*, returned when `output_attentions=True` is passed or when `config.output_attentions=True`):
            Tuple of `torch.FloatTensor` (one for each stage) of shape `(batch_size, num_heads, sequence_length,
            sequence_length)`.

            Attentions weights after the attention softmax, used to compute the weighted average in the self-attention
            heads.
        reshaped_hidden_states (`tuple(torch.FloatTensor)`, *optional*, returned when `output_hidden_states=True` is passed or when `config.output_hidden_states=True`):
            Tuple of `torch.FloatTensor` (one for the output of the embeddings + one for the output of each stage) of
            shape `(batch_size, hidden_size, height, width)`.

            Hidden-states of the model at the output of each layer plus the initial embedding outputs reshaped to
            include the spatial dimensions.
    """

    loss: Optional[torch.FloatTensor] = None
    logits: torch.FloatTensor = None
    hidden_states: Optional[Tuple[torch.FloatTensor]] = None
    attentions: Optional[Tuple[torch.FloatTensor]] = None
    reshaped_hidden_states: Optional[Tuple[torch.FloatTensor]] = None

@dataclass
class SwinImageClassifierOutput(ModelOutput):
    """
    Swin outputs for image classification.

    Args:
        loss (`torch.FloatTensor` of shape `(1,)`, *optional*, returned when `labels` is provided):
            Classification (or regression if config.num_labels==1) loss.
        logits (`torch.FloatTensor` of shape `(batch_size, config.num_labels)`):
            Classification (or regression if config.num_labels==1) scores (before SoftMax).
        hidden_states (`tuple(torch.FloatTensor)`, *optional*, returned when `output_hidden_states=True` is passed or when `config.output_hidden_states=True`):
            Tuple of `torch.FloatTensor` (one for the output of the embeddings + one for the output of each stage) of
            shape `(batch_size, sequence_length, hidden_size)`.

            Hidden-states of the model at the output of each layer plus the initial embedding outputs.
        attentions (`tuple(torch.FloatTensor)`, *optional*, returned when `output_attentions=True` is passed or when `config.output_attentions=True`):
            Tuple of `torch.FloatTensor` (one for each stage) of shape `(batch_size, num_heads, sequence_length,
            sequence_length)`.

            Attentions weights after the attention softmax, used to compute the weighted average in the self-attention
            heads.
        reshaped_hidden_states (`tuple(torch.FloatTensor)`, *optional*, returned when `output_hidden_states=True` is passed or when `config.output_hidden_states=True`):
            Tuple of `torch.FloatTensor` (one for the output of the embeddings + one for the output of each stage) of
            shape `(batch_size, hidden_size, height, width)`.

            Hidden-states of the model at the output of each layer plus the initial embedding outputs reshaped to
            include the spatial dimensions.
    """

    loss: Optional[torch.FloatTensor] = None
    logits: torch.FloatTensor = None
    hidden_states: Optional[Tuple[torch.FloatTensor]] = None
    attentions: Optional[Tuple[torch.FloatTensor]] = None
    reshaped_hidden_states: Optional[Tuple[torch.FloatTensor]] = None

def window_partition(input_feature, window_size):
    """
    Partitions the given input into windows.
    """
    batch_size, height, width, num_channels = input_feature.shape
    input_feature = input_feature.view(
        batch_size, height // window_size, window_size, width // window_size, window_size, num_channels
    )
    windows = input_feature.permute(0, 1, 3, 2, 4, 5).contiguous().view(-1, window_size, window_size, num_channels)
    return windows

def window_reverse(windows, window_size, height, width):
    """
    Merges windows to produce higher resolution features.
    """
    num_channels = windows.shape[-1]
    windows = windows.view(-1, height // window_size, width // window_size, window_size, window_size, num_channels)
    windows = windows.permute(0, 1, 3, 2, 4, 5).contiguous().view(-1, height, width, num_channels)
    return windows

class SwinEmbeddings(nn.Module):
    """
    Construct the patch and position embeddings. Optionally, also the mask token.
    """

    def __init__(self, config, use_mask_token=False):
        super().__init__()

        self.patch_embeddings = SwinPatchEmbeddings(config)
        num_patches = self.patch_embeddings.num_patches
        self.patch_grid = self.patch_embeddings.grid_size
        self.mask_token = nn.Parameter(torch.zeros(1, 1, config.embed_dim)) if use_mask_token else None

        if config.use_absolute_embeddings:
            self.position_embeddings = nn.Parameter(torch.zeros(1, num_patches + 1, config.embed_dim))
        else:
            self.position_embeddings = None

        self.norm = nn.LayerNorm(config.embed_dim)
        self.dropout = nn.Dropout(config.hidden_dropout_prob)

    def forward(
        self, pixel_values: Optional[torch.FloatTensor], bool_masked_pos: Optional[torch.BoolTensor] = None
    ) -> Tuple[torch.Tensor]:
        embeddings, output_dimensions = self.patch_embeddings(pixel_values)
        embeddings = self.norm(embeddings)
        batch_size, seq_len, _ = embeddings.size()

        if bool_masked_pos is not None:
            mask_tokens = self.mask_token.expand(batch_size, seq_len, -1)
            # replace the masked visual tokens by mask_tokens
            mask = bool_masked_pos.unsqueeze(-1).type_as(mask_tokens)
            embeddings = embeddings * (1.0 - mask) + mask_tokens * mask

        if self.position_embeddings is not None:
            embeddings = embeddings + self.position_embeddings

        embeddings = self.dropout(embeddings)

        return embeddings, output_dimensions

class SwinPatchEmbeddings(nn.Module):
    """
    This class turns `pixel_values` of shape `(batch_size, num_channels, height, width)` into the initial
    `hidden_states` (patch embeddings) of shape `(batch_size, seq_length, hidden_size)` to be consumed by a
    Transformer.
    """

    def __init__(self, config):
        super().__init__()
        image_size, patch_size = config.image_size, config.patch_size
        num_channels, hidden_size = config.num_channels, config.embed_dim
        image_size = image_size if isinstance(image_size, collections.abc.Iterable) else (image_size, image_size)
        patch_size = patch_size if isinstance(patch_size, collections.abc.Iterable) else (patch_size, patch_size)
        num_patches = (image_size[1] // patch_size[1]) * (image_size[0] // patch_size[0])
        self.image_size = image_size
        self.patch_size = patch_size
        self.num_channels = num_channels
        self.num_patches = num_patches
        self.grid_size = (image_size[0] // patch_size[0], image_size[1] // patch_size[1])

        self.projection = nn.Conv2d(num_channels, hidden_size, kernel_size=patch_size, stride=patch_size)

    def maybe_pad(self, pixel_values, height, width):
        if width % self.patch_size[1] != 0:
            pad_values = (0, self.patch_size[1] - width % self.patch_size[1])
            pixel_values = nn.functional.pad(pixel_values, pad_values)
        if height % self.patch_size[0] != 0:
            pad_values = (0, 0, 0, self.patch_size[0] - height % self.patch_size[0])
            pixel_values = nn.functional.pad(pixel_values, pad_values)
        return pixel_values

    def forward(self, pixel_values: Optional[torch.FloatTensor]) -> Tuple[torch.Tensor, Tuple[int]]:
        _, num_channels, height, width = pixel_values.shape
        if num_channels != self.num_channels:
            raise ValueError(
                "Make sure that the channel dimension of the pixel values match with the one set in the configuration."
            )
        # pad the input to be divisible by self.patch_size, if needed
        pixel_values = self.maybe_pad(pixel_values, height, width)
        embeddings = self.projection(pixel_values)
        _, _, height, width = embeddings.shape
        output_dimensions = (height, width)
        embeddings = embeddings.flatten(2).transpose(1, 2)

        return embeddings, output_dimensions

class SwinPatchMerging(nn.Module):
    """
    Patch Merging Layer.

    Args:
        input_resolution (`Tuple[int]`):
            Resolution of input feature.
        dim (`int`):
            Number of input channels.
        norm_layer (`nn.Module`, *optional*, defaults to `nn.LayerNorm`):
            Normalization layer class.
    """

    def __init__(self, input_resolution: Tuple[int], dim: int, norm_layer: nn.Module = nn.LayerNorm) -> None:
        super().__init__()
        self.input_resolution = input_resolution
        self.dim = dim
        self.reduction = nn.Linear(4 * dim, 2 * dim, bias=False)
        self.norm = norm_layer(4 * dim)

    def maybe_pad(self, input_feature, height, width):
        should_pad = (height % 2 == 1) or (width % 2 == 1)
        if should_pad:
            pad_values = (0, 0, 0, width % 2, 0, height % 2)
            input_feature = nn.functional.pad(input_feature, pad_values)

        return input_feature

    def forward(self, input_feature: torch.Tensor, input_dimensions: Tuple[int, int]) -> torch.Tensor:
        height, width = input_dimensions
        # `dim` is height * width
        batch_size, dim, num_channels = input_feature.shape

        input_feature = input_feature.view(batch_size, height, width, num_channels)
        # pad input to be disible by width and height, if needed
        input_feature = self.maybe_pad(input_feature, height, width)
        # [batch_size, height/2, width/2, num_channels]
        input_feature_0 = input_feature[:, 0::2, 0::2, :]
        # [batch_size, height/2, width/2, num_channels]
        input_feature_1 = input_feature[:, 1::2, 0::2, :]
        # [batch_size, height/2, width/2, num_channels]
        input_feature_2 = input_feature[:, 0::2, 1::2, :]
        # [batch_size, height/2, width/2, num_channels]
        input_feature_3 = input_feature[:, 1::2, 1::2, :]
        # batch_size height/2 width/2 4*num_channels
        input_feature = torch.cat([input_feature_0, input_feature_1, input_feature_2, input_feature_3], -1)
        input_feature = input_feature.view(batch_size, -1, 4 * num_channels)  # batch_size height/2*width/2 4*C

        input_feature = self.norm(input_feature)
        input_feature = self.reduction(input_feature)

        return input_feature

# Copied from transformers.models.beit.modeling_beit.drop_path
def drop_path(input, drop_prob=0.0, training=False, scale_by_keep=True):
    """
    Drop paths (Stochastic Depth) per sample (when applied in main path of residual blocks).

    Comment by Ross Wightman: This is the same as the DropConnect impl I created for EfficientNet, etc networks,
    however, the original name is misleading as 'Drop Connect' is a different form of dropout in a separate paper...
    See discussion: https://github.com/tensorflow/tpu/issues/494#issuecomment-532968956 ... I've opted for changing the
    layer and argument names to 'drop path' rather than mix DropConnect as a layer name and use 'survival rate' as the
    argument.
    """
    if drop_prob == 0.0 or not training:
        return input
    keep_prob = 1 - drop_prob
    shape = (input.shape[0],) + (1,) * (input.ndim - 1)  # work with diff dim tensors, not just 2D ConvNets
    random_tensor = keep_prob + torch.rand(shape, dtype=input.dtype, device=input.device)
    random_tensor.floor_()  # binarize
    output = input.div(keep_prob) * random_tensor
    return output

# Copied from transformers.models.beit.modeling_beit.BeitDropPath with Beit->Swin
class SwinDropPath(nn.Module):
    """Drop paths (Stochastic Depth) per sample (when applied in main path of residual blocks)."""

    def __init__(self, drop_prob: Optional[float] = None) -> None:
        super().__init__()
        self.drop_prob = drop_prob

    def forward(self, x: torch.Tensor) -> torch.Tensor:
        return drop_path(x, self.drop_prob, self.training)

    def extra_repr(self) -> str:
        return "p={}".format(self.drop_prob)

class SwinSelfAttention(nn.Module):
    def __init__(self, config, dim, num_heads, window_size):
        super().__init__()
        if dim % num_heads != 0:
            raise ValueError(
                f"The hidden size ({dim}) is not a multiple of the number of attention heads ({num_heads})"
            )

        self.num_attention_heads = num_heads
        self.attention_head_size = int(dim / num_heads)
        self.all_head_size = self.num_attention_heads * self.attention_head_size
        self.window_size = (
            window_size if isinstance(window_size, collections.abc.Iterable) else (window_size, window_size)
        )

        self.relative_position_bias_table = nn.Parameter(
            torch.zeros((2 * self.window_size[0] - 1) * (2 * self.window_size[1] - 1), num_heads)
        )

        # get pair-wise relative position index for each token inside the window
        coords_h = torch.arange(self.window_size[0])
        coords_w = torch.arange(self.window_size[1])
        coords = torch.stack(torch.meshgrid([coords_h, coords_w]))
        coords_flatten = torch.flatten(coords, 1)
        relative_coords = coords_flatten[:, :, None] - coords_flatten[:, None, :]
        relative_coords = relative_coords.permute(1, 2, 0).contiguous()
        relative_coords[:, :, 0] += self.window_size[0] - 1
        relative_coords[:, :, 1] += self.window_size[1] - 1
        relative_coords[:, :, 0] *= 2 * self.window_size[1] - 1
        relative_position_index = relative_coords.sum(-1)
        self.register_buffer("relative_position_index", relative_position_index)

        self.query = nn.Linear(self.all_head_size, self.all_head_size, bias=config.qkv_bias)
        self.key = nn.Linear(self.all_head_size, self.all_head_size, bias=config.qkv_bias)
        self.value = nn.Linear(self.all_head_size, self.all_head_size, bias=config.qkv_bias)

        self.dropout = nn.Dropout(config.attention_probs_dropout_prob)

    def transpose_for_scores(self, x):
        new_x_shape = x.size()[:-1] + (self.num_attention_heads, self.attention_head_size)
        x = x.view(new_x_shape)
        return x.permute(0, 2, 1, 3)

    def forward(
        self,
        hidden_states: torch.Tensor,
        attention_mask: Optional[torch.FloatTensor] = None,
        head_mask: Optional[torch.FloatTensor] = None,
        output_attentions: Optional[bool] = False,
    ) -> Tuple[torch.Tensor]:
        batch_size, dim, num_channels = hidden_states.shape
        mixed_query_layer = self.query(hidden_states)

        key_layer = self.transpose_for_scores(self.key(hidden_states))
        value_layer = self.transpose_for_scores(self.value(hidden_states))
        query_layer = self.transpose_for_scores(mixed_query_layer)

        # Take the dot product between "query" and "key" to get the raw attention scores.
        attention_scores = torch.matmul(query_layer, key_layer.transpose(-1, -2))

        attention_scores = attention_scores / math.sqrt(self.attention_head_size)

        relative_position_bias = self.relative_position_bias_table[self.relative_position_index.view(-1)]
        relative_position_bias = relative_position_bias.view(
            self.window_size[0] * self.window_size[1], self.window_size[0] * self.window_size[1], -1
        )

        relative_position_bias = relative_position_bias.permute(2, 0, 1).contiguous()
        attention_scores = attention_scores + relative_position_bias.unsqueeze(0)

        if attention_mask is not None:
            # Apply the attention mask is (precomputed for all layers in SwinModel forward() function)
            mask_shape = attention_mask.shape[0]
            attention_scores = attention_scores.view(
                batch_size // mask_shape, mask_shape, self.num_attention_heads, dim, dim
            )
            attention_scores = attention_scores + attention_mask.unsqueeze(1).unsqueeze(0)
            attention_scores = attention_scores.view(-1, self.num_attention_heads, dim, dim)

        # Normalize the attention scores to probabilities.
        attention_probs = nn.functional.softmax(attention_scores, dim=-1)

        # This is actually dropping out entire tokens to attend to, which might
        # seem a bit unusual, but is taken from the original Transformer paper.
        attention_probs = self.dropout(attention_probs)

        # Mask heads if we want to
        if head_mask is not None:
            attention_probs = attention_probs * head_mask

        context_layer = torch.matmul(attention_probs, value_layer)
        context_layer = context_layer.permute(0, 2, 1, 3).contiguous()
        new_context_layer_shape = context_layer.size()[:-2] + (self.all_head_size,)
        context_layer = context_layer.view(new_context_layer_shape)

        outputs = (context_layer, attention_probs) if output_attentions else (context_layer,)

        return outputs

class SwinSelfOutput(nn.Module):
    def __init__(self, config, dim):
        super().__init__()
        self.dense = nn.Linear(dim, dim)
        self.dropout = nn.Dropout(config.attention_probs_dropout_prob)

    def forward(self, hidden_states: torch.Tensor, input_tensor: torch.Tensor) -> torch.Tensor:
        hidden_states = self.dense(hidden_states)
        hidden_states = self.dropout(hidden_states)

        return hidden_states

class SwinAttention(nn.Module):
    def __init__(self, config, dim, num_heads, window_size):
        super().__init__()
        self.self = SwinSelfAttention(config, dim, num_heads, window_size)
        self.output = SwinSelfOutput(config, dim)
        self.pruned_heads = set()

    def prune_heads(self, heads):
        if len(heads) == 0:
            return
        heads, index = find_pruneable_heads_and_indices(
            heads, self.self.num_attention_heads, self.self.attention_head_size, self.pruned_heads
        )

        # Prune linear layers
        self.self.query = prune_linear_layer(self.self.query, index)
        self.self.key = prune_linear_layer(self.self.key, index)
        self.self.value = prune_linear_layer(self.self.value, index)
        self.output.dense = prune_linear_layer(self.output.dense, index, dim=1)

        # Update hyper params and store pruned heads
        self.self.num_attention_heads = self.self.num_attention_heads - len(heads)
        self.self.all_head_size = self.self.attention_head_size * self.self.num_attention_heads
        self.pruned_heads = self.pruned_heads.union(heads)

    def forward(
        self,
        hidden_states: torch.Tensor,
        attention_mask: Optional[torch.FloatTensor] = None,
        head_mask: Optional[torch.FloatTensor] = None,
        output_attentions: Optional[bool] = False,
    ) -> Tuple[torch.Tensor]:
        self_outputs = self.self(hidden_states, attention_mask, head_mask, output_attentions)
        attention_output = self.output(self_outputs[0], hidden_states)
        outputs = (attention_output,) + self_outputs[1:]  # add attentions if we output them
        return outputs

class SwinIntermediate(nn.Module):
    def __init__(self, config, dim):
        super().__init__()
        self.dense = nn.Linear(dim, int(config.mlp_ratio * dim))
        if isinstance(config.hidden_act, str):
            self.intermediate_act_fn = ACT2FN[config.hidden_act]
        else:
            self.intermediate_act_fn = config.hidden_act

    def forward(self, hidden_states: torch.Tensor) -> torch.Tensor:
        hidden_states = self.dense(hidden_states)
        hidden_states = self.intermediate_act_fn(hidden_states)
        return hidden_states

class SwinOutput(nn.Module):
    def __init__(self, config, dim):
        super().__init__()
        self.dense = nn.Linear(int(config.mlp_ratio * dim), dim)
        self.dropout = nn.Dropout(config.hidden_dropout_prob)

    def forward(self, hidden_states: torch.Tensor) -> torch.Tensor:
        hidden_states = self.dense(hidden_states)
        hidden_states = self.dropout(hidden_states)
        return hidden_states

class SwinLayer(nn.Module):
    def __init__(self, config, dim, input_resolution, num_heads, shift_size=0):
        super().__init__()
        self.chunk_size_feed_forward = config.chunk_size_feed_forward
        self.shift_size = shift_size
        self.window_size = config.window_size
        self.input_resolution = input_resolution
        self.set_shift_and_window_size(input_resolution)
        self.layernorm_before = nn.LayerNorm(dim, eps=config.layer_norm_eps)
        self.attention = SwinAttention(config, dim, num_heads, window_size=self.window_size)
        self.drop_path = SwinDropPath(config.drop_path_rate) if config.drop_path_rate > 0.0 else nn.Identity()
        self.layernorm_after = nn.LayerNorm(dim, eps=config.layer_norm_eps)
        self.intermediate = SwinIntermediate(config, dim)
        self.output = SwinOutput(config, dim)

    def set_shift_and_window_size(self, input_resolution):
        if min(input_resolution) <= self.window_size:
            # if window size is larger than input resolution, we don't partition windows
            self.shift_size = 0
            self.window_size = min(input_resolution)

    def get_attn_mask(self, height, width, dtype):
        if self.shift_size > 0:
            # calculate attention mask for SW-MSA
            img_mask = torch.zeros((1, height, width, 1), dtype=dtype)
            height_slices = (
                slice(0, -self.window_size),
                slice(-self.window_size, -self.shift_size),
                slice(-self.shift_size, None),
            )
            width_slices = (
                slice(0, -self.window_size),
                slice(-self.window_size, -self.shift_size),
                slice(-self.shift_size, None),
            )
            count = 0
            for height_slice in height_slices:
                for width_slice in width_slices:
                    img_mask[:, height_slice, width_slice, :] = count
                    count += 1

            mask_windows = window_partition(img_mask, self.window_size)
            mask_windows = mask_windows.view(-1, self.window_size * self.window_size)
            attn_mask = mask_windows.unsqueeze(1) - mask_windows.unsqueeze(2)
            attn_mask = attn_mask.masked_fill(attn_mask != 0, float(-100.0)).masked_fill(attn_mask == 0, float(0.0))
        else:
            attn_mask = None
        return attn_mask

    def maybe_pad(self, hidden_states, height, width):
        pad_right = (self.window_size - width % self.window_size) % self.window_size
        pad_bottom = (self.window_size - height % self.window_size) % self.window_size
        pad_values = (0, 0, 0, pad_right, 0, pad_bottom)
        hidden_states = nn.functional.pad(hidden_states, pad_values)
        return hidden_states, pad_values

    def forward(
        self,
        hidden_states: torch.Tensor,
        input_dimensions: Tuple[int, int],
        head_mask: Optional[torch.FloatTensor] = None,
        output_attentions: Optional[bool] = False,
    ) -> Tuple[torch.Tensor, torch.Tensor]:
        self.set_shift_and_window_size(input_dimensions)
        height, width = input_dimensions
        batch_size, _, channels = hidden_states.size()
        shortcut = hidden_states

        hidden_states = self.layernorm_before(hidden_states)
        hidden_states = hidden_states.view(batch_size, height, width, channels)
        # pad hidden_states to multiples of window size
        hidden_states, pad_values = self.maybe_pad(hidden_states, height, width)

        _, height_pad, width_pad, _ = hidden_states.shape
        # cyclic shift
        if self.shift_size > 0:
            shifted_hidden_states = torch.roll(hidden_states, shifts=(-self.shift_size, -self.shift_size), dims=(1, 2))
        else:
            shifted_hidden_states = hidden_states

        # partition windows
        hidden_states_windows = window_partition(shifted_hidden_states, self.window_size)
        hidden_states_windows = hidden_states_windows.view(-1, self.window_size * self.window_size, channels)
        attn_mask = self.get_attn_mask(height_pad, width_pad, dtype=hidden_states.dtype)
        if attn_mask is not None:
            attn_mask = attn_mask.to(hidden_states_windows.device)

        attention_outputs = self.attention(
            hidden_states_windows, attn_mask, head_mask, output_attentions=output_attentions
        )

        attention_output = attention_outputs[0]

        attention_windows = attention_output.view(-1, self.window_size, self.window_size, channels)
        shifted_windows = window_reverse(attention_windows, self.window_size, height_pad, width_pad)

        # reverse cyclic shift
        if self.shift_size > 0:
            attention_windows = torch.roll(shifted_windows, shifts=(self.shift_size, self.shift_size), dims=(1, 2))
        else:
            attention_windows = shifted_windows

        was_padded = pad_values[3] > 0 or pad_values[5] > 0
        if was_padded:
            attention_windows = attention_windows[:, :height, :width, :].contiguous()

        attention_windows = attention_windows.view(batch_size, height * width, channels)

        hidden_states = shortcut + self.drop_path(attention_windows)

        layer_output = self.layernorm_after(hidden_states)
        layer_output = self.intermediate(layer_output)
        layer_output = hidden_states + self.output(layer_output)

        layer_outputs = (layer_output, attention_outputs[1]) if output_attentions else (layer_output,)
        return layer_outputs

class SwinStage(nn.Module):
    def __init__(self, config, dim, input_resolution, depth, num_heads, drop_path, downsample):
        super().__init__()
        self.config = config
        self.dim = dim
        self.blocks = nn.ModuleList(
            [
                SwinLayer(
                    config=config,
                    dim=dim,
                    input_resolution=input_resolution,
                    num_heads=num_heads,
                    shift_size=0 if (i % 2 == 0) else config.window_size // 2,
                )
                for i in range(depth)
            ]
        )

        # patch merging layer
        if downsample is not None:
            self.downsample = downsample(input_resolution, dim=dim, norm_layer=nn.LayerNorm)
        else:
            self.downsample = None

        self.pointing = False

    def forward(
        self,
        hidden_states: torch.Tensor,
        input_dimensions: Tuple[int, int],
        head_mask: Optional[torch.FloatTensor] = None,
        output_attentions: Optional[bool] = False,
    ) -> Tuple[torch.Tensor]:
        height, width = input_dimensions
        for i, layer_module in enumerate(self.blocks):

            layer_head_mask = head_mask[i] if head_mask is not None else None

            layer_outputs = layer_module(hidden_states, input_dimensions, layer_head_mask, output_attentions)

            hidden_states = layer_outputs[0]

        if self.downsample is not None:
            height_downsampled, width_downsampled = (height + 1) // 2, (width + 1) // 2
            output_dimensions = (height, width, height_downsampled, width_downsampled)
            hidden_states = self.downsample(layer_outputs[0], input_dimensions)
        else:
            output_dimensions = (height, width, height, width)

        stage_outputs = (hidden_states, output_dimensions)

        if output_attentions:
            stage_outputs += layer_outputs[1:]
        return stage_outputs

class SwinEncoder(nn.Module):
    def __init__(self, config, grid_size):
        super().__init__()
        self.num_layers = len(config.depths)
        self.config = config
        dpr = [x.item() for x in torch.linspace(0, config.drop_path_rate, sum(config.depths))]
        self.layers = nn.ModuleList(
            [
                SwinStage(
                    config=config,
                    dim=int(config.embed_dim * 2**i_layer),
                    input_resolution=(grid_size[0] // (2**i_layer), grid_size[1] // (2**i_layer)),
                    depth=config.depths[i_layer],
                    num_heads=config.num_heads[i_layer],
                    drop_path=dpr[sum(config.depths[:i_layer]) : sum(config.depths[: i_layer + 1])],
                    downsample=SwinPatchMerging if (i_layer < self.num_layers - 1) else None,
                )
                for i_layer in range(self.num_layers)
            ]
        )

        self.gradient_checkpointing = False

    def forward(
        self,
        hidden_states: torch.Tensor,
        input_dimensions: Tuple[int, int],
        head_mask: Optional[torch.FloatTensor] = None,
        output_attentions: Optional[bool] = False,
        output_hidden_states: Optional[bool] = False,
        return_dict: Optional[bool] = True,
    ) -> Union[Tuple, SwinEncoderOutput]:
        all_input_dimensions = ()
        all_hidden_states = () if output_hidden_states else None
        all_reshaped_hidden_states = () if output_hidden_states else None
        all_self_attentions = () if output_attentions else None

        if output_hidden_states:
            batch_size, _, hidden_size = hidden_states.shape
            # rearrange b (h w) c -> b c h w
            reshaped_hidden_state = hidden_states.view(batch_size, *input_dimensions, hidden_size)
            reshaped_hidden_state = reshaped_hidden_state.permute(0, 3, 1, 2)
            all_hidden_states += (hidden_states,)
            all_reshaped_hidden_states += (reshaped_hidden_state,)

        for i, layer_module in enumerate(self.layers):
            layer_head_mask = head_mask[i] if head_mask is not None else None

            if self.gradient_checkpointing and self.training:

                def create_custom_forward(module):
                    def custom_forward(*inputs):
                        return module(*inputs, output_attentions)

                    return custom_forward

                layer_outputs = torch.utils.checkpoint.checkpoint(
                    create_custom_forward(layer_module), hidden_states, input_dimensions, layer_head_mask
                )
            else:
                layer_outputs = layer_module(hidden_states, input_dimensions, layer_head_mask, output_attentions)

            hidden_states = layer_outputs[0]
            output_dimensions = layer_outputs[1]

            input_dimensions = (output_dimensions[-2], output_dimensions[-1])
            all_input_dimensions += (input_dimensions,)

            if output_hidden_states:
                batch_size, _, hidden_size = hidden_states.shape
                # rearrange b (h w) c -> b c h w
                reshaped_hidden_state = hidden_states.view(batch_size, *input_dimensions, hidden_size)
                reshaped_hidden_state = reshaped_hidden_state.permute(0, 3, 1, 2)
                all_hidden_states += (hidden_states,)
                all_reshaped_hidden_states += (reshaped_hidden_state,)

            if output_attentions:
                all_self_attentions += layer_outputs[2:]

        if not return_dict:
            return tuple(v for v in [hidden_states, all_hidden_states, all_self_attentions] if v is not None)

        return SwinEncoderOutput(
            last_hidden_state=hidden_states,
            hidden_states=all_hidden_states,
            attentions=all_self_attentions,
            reshaped_hidden_states=all_reshaped_hidden_states,
        )

class SwinPreTrainedModel(PreTrainedModel):
    """
    An abstract class to handle weights initialization and a simple interface for downloading and loading pretrained
    models.
    """

    config_class = SwinConfig
    base_model_prefix = "swin"
    main_input_name = "pixel_values"
    supports_gradient_checkpointing = True

    def _init_weights(self, module):
        """Initialize the weights"""
        if isinstance(module, (nn.Linear, nn.Conv2d)):
            # Slightly different from the TF version which uses truncated_normal for initialization
            # cf https://github.com/pytorch/pytorch/pull/5617
            module.weight.data.normal_(mean=0.0, std=self.config.initializer_range)
            if module.bias is not None:
                module.bias.data.zero_()
        elif isinstance(module, nn.LayerNorm):
            module.bias.data.zero_()
            module.weight.data.fill_(1.0)

    def _set_gradient_checkpointing(self, module, value=False):
        if isinstance(module, SwinEncoder):
            module.gradient_checkpointing = value

SWIN_START_DOCSTRING = r"""
    This model is a PyTorch [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module) sub-class. Use
    it as a regular PyTorch Module and refer to the PyTorch documentation for all matter related to general usage and
    behavior.

    Parameters:
        config ([`SwinConfig`]): Model configuration class with all the parameters of the model.
            Initializing with a config file does not load the weights associated with the model, only the
            configuration. Check out the [`~PreTrainedModel.from_pretrained`] method to load the model weights.
"""

SWIN_INPUTS_DOCSTRING = r"""
    Args:
        pixel_values (`torch.FloatTensor` of shape `(batch_size, num_channels, height, width)`):
            Pixel values. Pixel values can be obtained using [`AutoFeatureExtractor`]. See
            [`AutoFeatureExtractor.__call__`] for details.
        head_mask (`torch.FloatTensor` of shape `(num_heads,)` or `(num_layers, num_heads)`, *optional*):
            Mask to nullify selected heads of the self-attention modules. Mask values selected in `[0, 1]`:

            - 1 indicates the head is **not masked**,
            - 0 indicates the head is **masked**.

        output_attentions (`bool`, *optional*):
            Whether or not to return the attentions tensors of all attention layers. See `attentions` under returned
            tensors for more detail.
        output_hidden_states (`bool`, *optional*):
            Whether or not to return the hidden states of all layers. See `hidden_states` under returned tensors for
            more detail.
        return_dict (`bool`, *optional*):
            Whether or not to return a [`~utils.ModelOutput`] instead of a plain tuple.
"""

@add_start_docstrings(
    "The bare Swin Model transformer outputting raw hidden-states without any specific head on top.",
    SWIN_START_DOCSTRING,
)
class SwinModel(SwinPreTrainedModel):
    def __init__(self, config, add_pooling_layer=True, use_mask_token=False):
        super().__init__(config)
        self.config = config
        self.num_layers = len(config.depths)
        self.num_features = int(config.embed_dim * 2 ** (self.num_layers - 1))

        self.embeddings = SwinEmbeddings(config, use_mask_token=use_mask_token)
        self.encoder = SwinEncoder(config, self.embeddings.patch_grid)

        self.layernorm = nn.LayerNorm(self.num_features, eps=config.layer_norm_eps)
        self.pooler = nn.AdaptiveAvgPool1d(1) if add_pooling_layer else None

        # Initialize weights and apply final processing
        self.post_init()

    def get_input_embeddings(self):
        return self.embeddings.patch_embeddings

    def _prune_heads(self, heads_to_prune):
        """
        Prunes heads of the model. heads_to_prune: dict of {layer_num: list of heads to prune in this layer} See base
        class PreTrainedModel
        """
        for layer, heads in heads_to_prune.items():
            self.encoder.layer[layer].attention.prune_heads(heads)

    @add_start_docstrings_to_model_forward(SWIN_INPUTS_DOCSTRING)
    @add_code_sample_docstrings(
        processor_class=_FEAT_EXTRACTOR_FOR_DOC,
        checkpoint=_CHECKPOINT_FOR_DOC,
        output_type=SwinModelOutput,
        config_class=_CONFIG_FOR_DOC,
        modality="vision",
        expected_output=_EXPECTED_OUTPUT_SHAPE,
    )
    def forward(
        self,
        pixel_values: Optional[torch.FloatTensor] = None,
        bool_masked_pos: Optional[torch.BoolTensor] = None,
        head_mask: Optional[torch.FloatTensor] = None,
        output_attentions: Optional[bool] = None,
        output_hidden_states: Optional[bool] = None,
        return_dict: Optional[bool] = None,
    ) -> Union[Tuple, SwinModelOutput]:
        output_attentions = output_attentions if output_attentions is not None else self.config.output_attentions
        output_hidden_states = (
            output_hidden_states if output_hidden_states is not None else self.config.output_hidden_states
        )
        return_dict = return_dict if return_dict is not None else self.config.use_return_dict

        if pixel_values is None:
            raise ValueError("You have to specify pixel_values")

        # Prepare head mask if needed
        # 1.0 in head_mask indicate we keep the head
        # attention_probs has shape bsz x n_heads x N x N
        # input head_mask has shape [num_heads] or [num_hidden_layers x num_heads]
        # and head_mask is converted to shape [num_hidden_layers x batch x num_heads x seq_length x seq_length]
        head_mask = self.get_head_mask(head_mask, len(self.config.depths))

        embedding_output, input_dimensions = self.embeddings(pixel_values, bool_masked_pos=bool_masked_pos)

        encoder_outputs = self.encoder(
            embedding_output,
            input_dimensions,
            head_mask=head_mask,
            output_attentions=output_attentions,
            output_hidden_states=output_hidden_states,
            return_dict=return_dict,
        )

        sequence_output = encoder_outputs[0]
        sequence_output = self.layernorm(sequence_output)

        pooled_output = None
        if self.pooler is not None:
            pooled_output = self.pooler(sequence_output.transpose(1, 2))
            pooled_output = torch.flatten(pooled_output, 1)

        if not return_dict:
            output = (sequence_output, pooled_output) + encoder_outputs[1:]

            return output

        return SwinModelOutput(
            last_hidden_state=sequence_output,
            pooler_output=pooled_output,
            hidden_states=encoder_outputs.hidden_states,
            attentions=encoder_outputs.attentions,
            reshaped_hidden_states=encoder_outputs.reshaped_hidden_states,
        )

@add_start_docstrings(
    """Swin Model with a decoder on top for masked image modeling, as proposed in [SimMIM](https://arxiv.org/abs/2111.09886).

    <Tip>

    Note that we provide a script to pre-train this model on custom data in our [examples
    directory](https://github.com/huggingface/transformers/tree/main/examples/pytorch/image-pretraining).

    </Tip>
    """,
    SWIN_START_DOCSTRING,
)
class SwinForMaskedImageModeling(SwinPreTrainedModel):
    def __init__(self, config):
        super().__init__(config)

        self.swin = SwinModel(config, add_pooling_layer=False, use_mask_token=True)

        num_features = int(config.embed_dim * 2 ** (config.num_layers - 1))
        self.decoder = nn.Sequential(
            nn.Conv2d(
                in_channels=num_features, out_channels=config.encoder_stride**2 * config.num_channels, kernel_size=1
            ),
            nn.PixelShuffle(config.encoder_stride),
        )

        # Initialize weights and apply final processing
        self.post_init()

    @add_start_docstrings_to_model_forward(SWIN_INPUTS_DOCSTRING)
    @replace_return_docstrings(output_type=SwinMaskedImageModelingOutput, config_class=_CONFIG_FOR_DOC)
    def forward(
        self,
        pixel_values: Optional[torch.FloatTensor] = None,
        bool_masked_pos: Optional[torch.BoolTensor] = None,
        head_mask: Optional[torch.FloatTensor] = None,
        output_attentions: Optional[bool] = None,
        output_hidden_states: Optional[bool] = None,
        return_dict: Optional[bool] = None,
    ) -> Union[Tuple, SwinMaskedImageModelingOutput]:
        r"""
        bool_masked_pos (`torch.BoolTensor` of shape `(batch_size, num_patches)`):
            Boolean masked positions. Indicates which patches are masked (1) and which aren't (0).

        Returns:

        Examples:
        ```python
        >>> from transformers import AutoFeatureExtractor, SwinForMaskedImageModeling
        >>> import torch
        >>> from PIL import Image
        >>> import requests

        >>> url = "http://images.cocodataset.org/val2017/000000039769.jpg"
        >>> image = Image.open(requests.get(url, stream=True).raw)

        >>> feature_extractor = AutoFeatureExtractor.from_pretrained("microsoft/swin-base-simmim-window6-192")
        >>> model = SwinForMaskedImageModeling.from_pretrained("microsoft/swin-base-simmim-window6-192")

        >>> num_patches = (model.config.image_size // model.config.patch_size) ** 2
        >>> pixel_values = feature_extractor(images=image, return_tensors="pt").pixel_values
        >>> # create random boolean mask of shape (batch_size, num_patches)
        >>> bool_masked_pos = torch.randint(low=0, high=2, size=(1, num_patches)).bool()

        >>> outputs = model(pixel_values, bool_masked_pos=bool_masked_pos)
        >>> loss, reconstructed_pixel_values = outputs.loss, outputs.logits
        >>> list(reconstructed_pixel_values.shape)
        [1, 3, 192, 192]
        ```"""
        return_dict = return_dict if return_dict is not None else self.config.use_return_dict

        outputs = self.swin(
            pixel_values,
            bool_masked_pos=bool_masked_pos,
            head_mask=head_mask,
            output_attentions=output_attentions,
            output_hidden_states=output_hidden_states,
            return_dict=return_dict,
        )

        sequence_output = outputs[0]
        # Reshape to (batch_size, num_channels, height, width)
        sequence_output = sequence_output.transpose(1, 2)
        batch_size, num_channels, sequence_length = sequence_output.shape
        height = width = math.floor(sequence_length**0.5)
        sequence_output = sequence_output.reshape(batch_size, num_channels, height, width)

        # Reconstruct pixel values
        reconstructed_pixel_values = self.decoder(sequence_output)

        masked_im_loss = None
        if bool_masked_pos is not None:
            size = self.config.image_size // self.config.patch_size
            bool_masked_pos = bool_masked_pos.reshape(-1, size, size)
            mask = (
                bool_masked_pos.repeat_interleave(self.config.patch_size, 1)
                .repeat_interleave(self.config.patch_size, 2)
                .unsqueeze(1)
                .contiguous()
            )
            reconstruction_loss = nn.functional.l1_loss(pixel_values, reconstructed_pixel_values, reduction="none")
            masked_im_loss = (reconstruction_loss * mask).sum() / (mask.sum() + 1e-5) / self.config.num_channels

        if not return_dict:
            output = (reconstructed_pixel_values,) + outputs[2:]
            return ((masked_im_loss,) + output) if masked_im_loss is not None else output

        return SwinMaskedImageModelingOutput(
            loss=masked_im_loss,
            logits=reconstructed_pixel_values,
            hidden_states=outputs.hidden_states,
            attentions=outputs.attentions,
            reshaped_hidden_states=outputs.reshaped_hidden_states,
        )

@add_start_docstrings(
    """
    Swin Model transformer with an image classification head on top (a linear layer on top of the final hidden state of
    the [CLS] token) e.g. for ImageNet.
    """,
    SWIN_START_DOCSTRING,
)
class SwinForImageClassification(SwinPreTrainedModel):
    def __init__(self, config):
        super().__init__(config)

        self.num_labels = config.num_labels
        self.swin = SwinModel(config)

        # Classifier head
        self.classifier = (
            nn.Linear(self.swin.num_features, config.num_labels) if config.num_labels > 0 else nn.Identity()
        )

        # Initialize weights and apply final processing
        self.post_init()

    @add_start_docstrings_to_model_forward(SWIN_INPUTS_DOCSTRING)
    @add_code_sample_docstrings(
        processor_class=_FEAT_EXTRACTOR_FOR_DOC,
        checkpoint=_IMAGE_CLASS_CHECKPOINT,
        output_type=SwinImageClassifierOutput,
        config_class=_CONFIG_FOR_DOC,
        expected_output=_IMAGE_CLASS_EXPECTED_OUTPUT,
    )
    def forward(
        self,
        pixel_values: Optional[torch.FloatTensor] = None,
        head_mask: Optional[torch.FloatTensor] = None,
        labels: Optional[torch.LongTensor] = None,
        output_attentions: Optional[bool] = None,
        output_hidden_states: Optional[bool] = None,
        return_dict: Optional[bool] = None,
    ) -> Union[Tuple, SwinImageClassifierOutput]:
        r"""
        labels (`torch.LongTensor` of shape `(batch_size,)`, *optional*):
            Labels for computing the image classification/regression loss. Indices should be in `[0, ...,
            config.num_labels - 1]`. If `config.num_labels == 1` a regression loss is computed (Mean-Square loss), If
            `config.num_labels > 1` a classification loss is computed (Cross-Entropy).
        """
        return_dict = return_dict if return_dict is not None else self.config.use_return_dict

        outputs = self.swin(
            pixel_values,
            head_mask=head_mask,
            output_attentions=output_attentions,
            output_hidden_states=output_hidden_states,
            return_dict=return_dict,
        )

        pooled_output = outputs[1]

        logits = self.classifier(pooled_output)

        loss = None
        if labels is not None:
            if self.config.problem_type is None:
                if self.num_labels == 1:
                    self.config.problem_type = "regression"
                elif self.num_labels > 1 and (labels.dtype == torch.long or labels.dtype == torch.int):
                    self.config.problem_type = "single_label_classification"
                else:
                    self.config.problem_type = "multi_label_classification"

            if self.config.problem_type == "regression":
                loss_fct = MSELoss()
                if self.num_labels == 1:
                    loss = loss_fct(logits.squeeze(), labels.squeeze())
                else:
                    loss = loss_fct(logits, labels)
            elif self.config.problem_type == "single_label_classification":
                loss_fct = CrossEntropyLoss()
                loss = loss_fct(logits.view(-1, self.num_labels), labels.view(-1))
            elif self.config.problem_type == "multi_label_classification":
                loss_fct = BCEWithLogitsLoss()
                loss = loss_fct(logits, labels)

        if not return_dict:
            output = (logits,) + outputs[2:]
            return ((loss,) + output) if loss is not None else output

        return SwinImageClassifierOutput(
            loss=loss,
            logits=logits,
            hidden_states=outputs.hidden_states,
            attentions=outputs.attentions,
            reshaped_hidden_states=outputs.reshaped_hidden_states,
        )


text: export * from './datepicker-container.component';

redpajama_set_name: RedPajamaGithub


text:
var ___androidExists = true;

function disableAnnoyingBlueHighlightOnClick(){
	var sheet = document.createElement('style');
	sheet.innerHTML = "* { -webkit-tap-highlight-color: rgba(0, 0, 0, 0);	}";
	document.getElementsByTagName("head")[0].appendChild(sheet);
};
disableAnnoyingBlueHighlightOnClick();

console.log("core loaded");


text:
<!DOCTYPE html>

		<title>Birdport Simulator</title>
		<meta charset="utf-8">
		<meta name="viewport" content="width=device-width, user-scalable=no, minimum-scale=1.0, maximum-scale=1.0">

			Birdport Simulator for Airbus FYI 2015
			by Motoki Kimura and Team Birbport


text:
BOT_NAME = 'newspaper_name_finder'

SPIDER_MODULES = ['newspaper_name_finder.spiders']
NEWSPIDER_MODULE = 'newspaper_name_finder.spiders'

# Crawl responsibly by identifying yourself (and your website) on the user-agent
#USER_AGENT = 'newspaper_name_finder (+http://www.yourdomain.com)'


text:
.. _overloaded-strings:

Overloaded string literals
--------------------------

.. extension:: OverloadedStrings
    :shortdesc: Enable overloaded string literals.

    :since: 6.8.1

    Enable overloaded string literals (e.g. string literals desugared via the
    ``IsString`` class).

GHC supports *overloaded string literals*. Normally a string literal has
type ``String``, but with overloaded string literals enabled (with
:extension:`OverloadedStrings`) a string literal has type
``(IsString a) => a``.

This means that the usual string syntax can be used, e.g., for
``ByteString``, ``Text``, and other variations of string like types.
String literals behave very much like integer literals, i.e., they can
be used in both expressions and patterns. If used in a pattern the
literal will be replaced by an equality test, in the same way as an
integer literal is.

The class ``IsString`` is defined as: ::

    class IsString a where
        fromString :: String -> a

The only predefined instance is the obvious one to make strings work as
usual: ::

    instance IsString [Char] where
        fromString cs = cs

The class ``IsString`` is not in scope by default. If you want to
mention it explicitly (for example, to give an instance declaration for
it), you can import it from module ``Data.String``.

Haskell's defaulting mechanism (`Haskell Report, Section
4.3.4 <http://www.haskell.org/onlinereport/decls.html#sect4.3.4>`__) is
extended to cover string literals, when :extension:`OverloadedStrings` is
specified. Specifically:

-  Each type in a ``default`` declaration must be an instance of ``Num``
   *or* of ``IsString``.

-  If no ``default`` declaration is given, then it is just as if the
   module contained the declaration
   ``default( Integer, Double, String)``.

-  The standard defaulting rule is extended thus: defaulting applies
   when all the unresolved constraints involve standard classes *or*
   ``IsString``; and at least one is a numeric class *or* ``IsString``.

So, for example, the expression ``length "foo"`` will give rise to an
ambiguous use of ``IsString a0`` which, because of the above rules, will
default to ``String``.

A small example:

::

    module Main where

    import Data.String( IsString(..) )

    newtype MyString = MyString String deriving (Eq, Show)
    instance IsString MyString where
        fromString = MyString

    greet :: MyString -> MyString
    greet "hello" = "world"
    greet other = other

    main = do
        print $ greet "hello"
        print $ greet "fool"

Note that deriving ``Eq`` is necessary for the pattern matching to work
since it gets translated into an equality comparison.


text:
package com.ffbet.fase3.api;

import org.apache.catalina.servlet4preview.http.HttpServletRequest;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.DeleteMapping;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PatchMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

import com.ffbet.fase3.domain.BetTicket;
import com.ffbet.fase3.domain.Match;
import com.ffbet.fase3.domain.SportsMatch;
import com.ffbet.fase3.services.BetTicketService;
import com.ffbet.fase3.services.MatchService;
import com.ffbet.fase3.services.UserService;

@RestController
@RequestMapping("/api/bet")
public class BetRestController {

	@Autowired
	private MatchService matchService;
	@Autowired
	private BetTicketService btService;
	@Autowired
	private UserService userService;

	BetTicket ticket_erasable_SP = null;
	BetTicket ticket_erasable_EG = null;

	@GetMapping("/match/{type}")
	public ResponseEntity<BetTicket> getLocalTicket(@PathVariable String type, HttpServletRequest request) {
		BetTicket erasableTckt;
		if (type.equals("sports")) {
			erasableTckt = ticket_erasable_SP;
		} else {
			erasableTckt = ticket_erasable_EG;
		}
		if (erasableTckt != null) {
			return new ResponseEntity<>(ticket_erasable_SP, HttpStatus.OK);
		} else {
			return new ResponseEntity<>(HttpStatus.NOT_FOUND);
		}
	}

	/* BetMatch to ticket erasable zone */
	@PatchMapping("/match/{id}/{type}/{quota}")
	public ResponseEntity<BetTicket> addSportMatchToLocalBet(@PathVariable long id, @PathVariable String quota,
			@PathVariable String type, HttpServletRequest request) {
		Match match;
		if (type.equals("sports")) {
			match = matchService.findOneSports(id);
		} else {
			match = matchService.findOneEgames(id);
		}

		if (match != null) {

			if (SportsMatch.class.isInstance(match)) {
				ticket_erasable_SP = btService.addSportMatchToErasableTicket(ticket_erasable_SP, id, quota);

				return new ResponseEntity<>(ticket_erasable_SP, HttpStatus.OK);
			} else {
				ticket_erasable_EG = btService.addEgamesMatchToErasableTicket(ticket_erasable_EG, id, quota);

				return new ResponseEntity<>(ticket_erasable_EG, HttpStatus.OK);
			}

		} else {
			return new ResponseEntity<>(HttpStatus.NOT_FOUND);
		}

	}

	@DeleteMapping("/match/{id}/{type}")
	public ResponseEntity<BetTicket> removeMatchFromLocalBet(@PathVariable long id, @PathVariable String type) {

		Match match;
		if (type.equals("sports")) {
			match = matchService.findOneSports(id);
		} else {
			match = matchService.findOneEgames(id);
		}

		if (match != null) {

			if (SportsMatch.class.isInstance(match)) {
				ticket_erasable_SP = btService.removeMatchFromErasableTicket(ticket_erasable_SP, match.getId());

				return new ResponseEntity<>(ticket_erasable_SP, HttpStatus.OK);
			} else {
				ticket_erasable_EG = btService.removeMatchFromErasableTicket(ticket_erasable_EG, match.getId());

				return new ResponseEntity<>(ticket_erasable_EG, HttpStatus.OK);
			}

		} else {
			return new ResponseEntity<>(HttpStatus.NOT_FOUND);
		}
	}

	/* SEND BET ZONE */

	@PostMapping("/{amount}")
	public ResponseEntity<BetTicket> sendSportBet(@PathVariable int amount) {

		String code = "";
		int promoQuantity = 0;

		if (ticket_erasable_SP != null) {
			ticket_erasable_SP = btService.initializeAmountRest(amount, ticket_erasable_SP);
			if (btService.sendBet(ticket_erasable_SP, userService.handleUserLoggedFromComponent(), code,
					promoQuantity) == 0) {
				ticket_erasable_SP = null;
				return new ResponseEntity<>(ticket_erasable_SP, HttpStatus.OK);
			}
		}

		if (ticket_erasable_EG != null) {
			ticket_erasable_EG = btService.initializeAmountRest(amount, ticket_erasable_EG);

			if (btService.sendBet(ticket_erasable_EG, userService.handleUserLoggedFromComponent(), code,
					promoQuantity) == 0) {
				ticket_erasable_EG = null;
				return new ResponseEntity<>(ticket_erasable_EG, HttpStatus.OK);
			}
		}
		return new ResponseEntity<>(HttpStatus.NOT_FOUND);
	}

	/* VALIDATION BET ZONE */
	@GetMapping("/{id}/{userId}")
	public ResponseEntity<BetTicket> validateBet(@PathVariable long id, @PathVariable long userId) {

		BetTicket bttocheck = btService.findOne(id);

		if (bttocheck != null) {
			// salida en json
			if (bttocheck.isFinished()) {
				btService.validateBet(id, userId);
			}

			return new ResponseEntity<>(btService.findOne(id), HttpStatus.OK);
		} else {
			return new ResponseEntity<>(HttpStatus.NOT_FOUND);
		}
	}

	@DeleteMapping("/{id}")
	public ResponseEntity<BetTicket> removeBet(@PathVariable long id) {

		BetTicket bttocheck = btService.findOne(id);

		if (bttocheck != null) {

			btService.removeBetTicketFromUser(id);

			return new ResponseEntity<>(bttocheck, HttpStatus.OK);

		} else {
			return new ResponseEntity<>(HttpStatus.NOT_FOUND);
		}
	}
}


text:
package com.intellij.openapi.vcs.actions;

import com.intellij.openapi.actionSystem.AnAction;
import com.intellij.openapi.actionSystem.DataContext;
import com.intellij.openapi.extensions.ExtensionPointName;
import com.intellij.openapi.project.Project;
import com.intellij.openapi.vcs.AbstractVcs;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;

import java.util.List;

/**
 * Allow customizing actions in the context dependant 'Vcs Operations' popup.
 *
 * @see VcsQuickListPopupAction
 */
public interface VcsQuickListContentProvider {
  ExtensionPointName<VcsQuickListContentProvider> EP_NAME = ExtensionPointName.create("com.intellij.vcsPopupProvider");

  /**
   * Customize actions with specific VCS in the context.
   * See "Vcs.Operations.Popup.VcsAware" action group.
   *
   * @return action list or null if provider should be ignored
   */
  @Nullable
  default List<AnAction> getVcsActions(@Nullable Project project,
                                       @NotNull AbstractVcs activeVcs,
                                       @Nullable DataContext dataContext) { return null; }

  /**
   * Customize actions if project is not under VCS.
   * See "Vcs.Operations.Popup.NonVcsAware" action group.
   *
   * @return action list or null if provider should be ignored
   */
  @Nullable
  default List<AnAction> getNotInVcsActions(@Nullable Project project,
                                            @Nullable DataContext dataContext) { return null; }

  /**
   * @return True, if only this provider should be used.
   * In this case, default actions and other providers are ignored.
   * Otherwise, custom actions will be inserted at the end.
   * <p>
   * Usually it should be false.
   */
  default boolean replaceVcsActionsFor(@NotNull AbstractVcs activeVcs,
                                       @Nullable DataContext dataContext) { return false; }
}


text:
class CreateWuozAgencies < ActiveRecord::Migration
  def change
    create_table :wuoz_agencies do |t|
      t.string :city
      t.string :director
      t.string :email
      t.string :address
      t.string :districts
      t.string :wuoz_key

      t.timestamps
    end
  end
end


text: Realtime and Peer to Peer authentication and signaling layer internet api.


text:
/*
 * parse.c
 */
#include "config.h"

#include <stdio.h>

#if HAVE_UNISTD_H
#include <unistd.h>
#endif
#if HAVE_STDLIB_H
#include <stdlib.h>
#endif
#if HAVE_SYS_TYPES_H
#include <sys/types.h>
#endif
#if HAVE_CTYPE_H
#include <ctype.h>
#endif
#if HAVE_GNUMALLOC_H
#include <gnumalloc.h>
#elif HAVE_MALLOC_H
#include <malloc.h>
#endif
#if HAVE_MEMORY_H
#include <memory.h>
#endif
#ifdef HAVE_STRING_H
#include <string.h>
#endif
#ifdef HAVE_STRINGS_H
#include <strings.h>
#endif
#if HAVE_BSTRING_H
#include <bstring.h>
#endif
#if HAVE_SYS_SOCKET_H
#include <sys/socket.h>
#endif
#if HAVE_NETINET_IN_H
#include <netinet/in.h>
#endif
#if HAVE_ARPA_INET_H
#include <arpa/inet.h>
#endif
#if HAVE_SYS_TIME_H
#include <sys/time.h>
#endif
#if HAVE_NETDB_H
#include <netdb.h>
#endif
#if HAVE_ASSERT_H
#include <assert.h>
#endif

#include "asn1.h"
#include "snmp_vars.h"
#include "parse.h"
#include "snmp_debug.h"

#include "util.h"

#include "cache_snmp.h"
/*
 * This is one element of an object identifier with either an integer subidentifier,
 * or a textual string label, or both.
 * The subid is -1 if not present, and label is NULL if not present.
 */
struct subid {
    int subid;
    char *label;
};

/*
 * A linked list of nodes.
 */
struct node {
    struct node *next;
    char label[64];		/* This node's (unique) textual name */
    u_int subid;		/* This node's integer subidentifier */
    char parent[64];		/* The parent's textual name */
    int type;			/* The type of object this represents */
    struct enum_list *enums;	/* (optional) list of enumerated integers (otherwise NULL) */
};

int Line = 1;

/* types of tokens */
#define	CONTINUE    -1
#define ENDOFFILE   0
#define LABEL	    1
#define SUBTREE	    2
#define SYNTAX	    3
#undef OBJID
#define OBJID	    4
#define OCTETSTR    5
#undef INTEGER
#define INTEGER	    6
#define NETADDR	    7
#define	IPADDR	    8
#define COUNTER	    9
#define GAUGE	    10
#define TIMETICKS   11
#define SNMP_OPAQUE	    12
#define NUL	    13
#define SEQUENCE    14
#define OF	    15		/* SEQUENCE OF */
#define OBJTYPE	    16
#define ACCESS	    17
#define READONLY    18
#define READWRITE   19
#define	WRITEONLY   20
#undef NOACCESS
#define NOACCESS    21
#define SNMP_STATUS	22
#define MANDATORY   23
#define SNMP_OPTIONAL    24
#define OBSOLETE    25
#define RECOMMENDED 26
#define PUNCT	    27
#define EQUALS	    28
#define NUMBER	    29
#define LEFTBRACKET 30
#define RIGHTBRACKET 31
#define	LEFTPAREN   32
#define RIGHTPAREN  33
#define COMMA	    34
/* For SNMPv2 SMI pseudo-compliance */
#define DESCRIPTION 35
#define INDEX       36
#define QUOTE       37

struct tok {
    const char *name;			/* token name */
    int len;			/* length not counting nul */
    int token;			/* value */
    int hash;			/* hash of name */
    struct tok *next;		/* pointer to next in hash table */
};

struct tok tokens[] =
{
    {"obsolete", sizeof("obsolete") - 1, OBSOLETE},
    {"Opaque", sizeof("Opaque") - 1, SNMP_OPAQUE},
    {"recommended", sizeof("recommended") - 1, RECOMMENDED},
    {"optional", sizeof("optional") - 1, SNMP_OPTIONAL},
    {"mandatory", sizeof("mandatory") - 1, MANDATORY},
    {"current", sizeof("current") - 1, MANDATORY},
    {"not-accessible", sizeof("not-accessible") - 1, NOACCESS},
    {"write-only", sizeof("write-only") - 1, WRITEONLY},
    {"read-write", sizeof("read-write") - 1, READWRITE},
    {"TimeTicks", sizeof("TimeTicks") - 1, TIMETICKS},
    {"OBJECTIDENTIFIER", sizeof("OBJECTIDENTIFIER") - 1, OBJID},
	/*
	 * This CONTINUE appends the next word onto OBJECT,
	 * hopefully matching OBJECTIDENTIFIER above.
	 */
    {"OBJECT", sizeof("OBJECT") - 1, CONTINUE},
    {"NetworkAddress", sizeof("NetworkAddress") - 1, NETADDR},
    {"Gauge", sizeof("Gauge") - 1, GAUGE},
    {"OCTETSTRING", sizeof("OCTETSTRING") - 1, OCTETSTR},
    {"OCTET", sizeof("OCTET") - 1, -1},
    {"OF", sizeof("OF") - 1, OF},
    {"SEQUENCE", sizeof("SEQUENCE") - 1, SEQUENCE},
    {"NULL", sizeof("NULL") - 1, NUL},
    {"IpAddress", sizeof("IpAddress") - 1, IPADDR},
    {"INTEGER", sizeof("INTEGER") - 1, INTEGER},
    {"Counter", sizeof("Counter") - 1, COUNTER},
    {"read-only", sizeof("read-only") - 1, READONLY},
    {"ACCESS", sizeof("ACCESS") - 1, ACCESS},
    {"MAX-ACCESS", sizeof("MAX-ACCESS") - 1, ACCESS},
    {"STATUS", sizeof("STATUS") - 1, SNMP_STATUS},
    {"SYNTAX", sizeof("SYNTAX") - 1, SYNTAX},
    {"OBJECT-TYPE", sizeof("OBJECT-TYPE") - 1, OBJTYPE},
    {"{", sizeof("{") - 1, LEFTBRACKET},
    {"}", sizeof("}") - 1, RIGHTBRACKET},
    {"::=", sizeof("::=") - 1, EQUALS},
    {"(", sizeof("(") - 1, LEFTPAREN},
    {")", sizeof(")") - 1, RIGHTPAREN},
    {",", sizeof(",") - 1, COMMA},
    {"DESCRIPTION", sizeof("DESCRIPTION") - 1, DESCRIPTION},
    {"INDEX", sizeof("INDEX") - 1, INDEX},
    {"\"", sizeof("\"") - 1, QUOTE},
    {"END", sizeof("END") - 1, ENDOFFILE},
/* Hacks for easier MIBFILE coercing */
    {"read-create", sizeof("read-create") - 1, READWRITE},
    {NULL}
};

#define	HASHSIZE	32
#define	BUCKET(x)	(x & 0x01F)

static struct tok *buckets[HASHSIZE];

static void
hash_init(void)
{
    register struct tok *tp;
    register const char *cp;
    register int h;
    register int b;

    memset((char *) buckets, '\0', sizeof(buckets));
    for (tp = tokens; tp->name; tp++) {
	for (h = 0, cp = tp->name; *cp; cp++)
	    h += *cp;
	tp->hash = h;
	b = BUCKET(h);
	if (buckets[b])
	    tp->next = buckets[b];	/* BUG ??? */
	buckets[b] = tp;
    }
}

#define NHASHSIZE    128
#define NBUCKET(x)   (x & 0x7F)
struct node *nbuckets[NHASHSIZE];

static void
init_node_hash(struct node *nodes)
{
    register struct node *np, *nextp;
    register char *cp;
    register int hash;

    memset((char *) nbuckets, '\0', sizeof(nbuckets));
    for (np = nodes; np;) {
	nextp = np->next;
	hash = 0;
	for (cp = np->parent; *cp; cp++)
	    hash += *cp;
	np->next = nbuckets[NBUCKET(hash)];
	nbuckets[NBUCKET(hash)] = np;
	np = nextp;
    }
}

static void
print_error(const char *string, const char *token, int type)
{
    assert(string != NULL);
    if (type == ENDOFFILE)
	snmplib_debug(0, "%s(EOF): On or around line %d\n", string, Line);
    else if (token)
	snmplib_debug(0, "%s(%s): On or around line %d\n", string, token, Line);
    else
	snmplib_debug(0, "%s: On or around line %d\n", string, Line);
}

#ifdef TEST
print_subtree(tree, count)
     struct snmp_mib_tree *tree;
     int count;
{
    struct snmp_mib_tree *tp;
    int i;

    for (i = 0; i < count; i++)
	printf("  ");
    printf("Children of %s:\n", tree->label);
    count++;
    for (tp = tree->child_list; tp; tp = tp->next_peer) {
	for (i = 0; i < count; i++)
	    printf("  ");
	printf("%s\n", tp->label);
    }
    for (tp = tree->child_list; tp; tp = tp->next_peer) {
	print_subtree(tp, count);
    }
}
#endif /* TEST */

int translation_table[40];

static void
build_translation_table(void)
{
    int count;

    for (count = 0; count < 40; count++) {
	switch (count) {
	case OBJID:
	    translation_table[count] = TYPE_OBJID;
	    break;
	case OCTETSTR:
	    translation_table[count] = TYPE_OCTETSTR;
	    break;
	case INTEGER:
	    translation_table[count] = TYPE_INTEGER;
	    break;
	case NETADDR:
	    translation_table[count] = TYPE_IPADDR;
	    break;
	case IPADDR:
	    translation_table[count] = TYPE_IPADDR;
	    break;
	case COUNTER:
	    translation_table[count] = TYPE_COUNTER;
	    break;
	case GAUGE:
	    translation_table[count] = TYPE_GAUGE;
	    break;
	case TIMETICKS:
	    translation_table[count] = TYPE_TIMETICKS;
	    break;
	case SNMP_OPAQUE:
	    translation_table[count] = TYPE_OPAQUE;
	    break;
	case NUL:
	    translation_table[count] = TYPE_NULL;
	    break;
	default:
	    translation_table[count] = TYPE_OTHER;
	    break;
	}
    }
}

/*
 * Find all the children of root in the list of nodes.  Link them into the
 * tree and out of the nodes list.
 */
static void
do_subtree(struct snmp_mib_tree *root, struct node **nodes)
{
    register struct snmp_mib_tree *tp;
    struct snmp_mib_tree *peer = NULL;
    register struct node *np = NULL, **headp = NULL;
    struct node *oldnp = NULL, *child_list = NULL, *childp = NULL;
    char *cp;
    int hash;

    tp = root;
    hash = 0;
    for (cp = tp->label; *cp; cp++)
	hash += *cp;
    headp = &nbuckets[NBUCKET(hash)];
    /*
     * Search each of the nodes for one whose parent is root, and
     * move each into a separate list.
     */
    for (np = *headp; np; np = np->next) {
	if ((*tp->label != *np->parent) || strcmp(tp->label, np->parent)) {
	    if ((*tp->label == *np->label) && !strcmp(tp->label, np->label)) {
		/* if there is another node with the same label, assume that
		 * any children after this point in the list belong to the other node.
		 * This adds some scoping to the table and allows vendors to
		 * reuse names such as "ip".
		 */
		break;
	    }
	    oldnp = np;
	} else {
	    if (child_list == NULL) {
		child_list = childp = np;	/* first entry in child list */
	    } else {
		childp->next = np;
		childp = np;
	    }
	    /* take this node out of the node list */
	    if (oldnp == NULL) {
		*headp = np->next;	/* fix root of node list */
	    } else {
		oldnp->next = np->next;		/* link around this node */
	    }
	}
    }
    if (childp)
	childp->next = 0;	/* re-terminate list */
    /*
     * Take each element in the child list and place it into the tree.
     */
    for (np = child_list; np; np = np->next) {
	tp = (struct snmp_mib_tree *) xmalloc(sizeof(struct snmp_mib_tree));
	tp->parent = root;
	tp->next_peer = NULL;
	tp->child_list = NULL;
	strcpy(tp->label, np->label);
	tp->subid = np->subid;
	tp->type = translation_table[np->type];
	tp->enums = np->enums;
	np->enums = NULL;	/* so we don't free them later */
	if (root->child_list == NULL) {
	    root->child_list = tp;
	} else {
	    peer->next_peer = tp;
	}
	peer = tp;
/*      if (tp->type == TYPE_OTHER) */
	do_subtree(tp, nodes);	/* recurse on this child if it isn't an end node */
    }
    /* free all nodes that were copied into tree */
    oldnp = NULL;
    for (np = child_list; np; np = np->next) {
	if (oldnp)
	    xfree(oldnp);
	oldnp = np;
    }
    if (oldnp)
	xfree(oldnp);
}

#ifndef TEST
static
#endif
struct snmp_mib_tree *
build_tree(struct node *nodes)
{
    struct node *np;
    struct snmp_mib_tree *tp;
    int bucket, nodes_left = 0;

    /* build root node */
    tp = (struct snmp_mib_tree *) xmalloc(sizeof(struct snmp_mib_tree));
    tp->parent = NULL;
    tp->next_peer = NULL;
    tp->child_list = NULL;
    tp->enums = NULL;
    strcpy(tp->label, "iso");
    tp->subid = 1;
    tp->type = 0;
    build_translation_table();
    /* grow tree from this root node */
    init_node_hash(nodes);
    /* XXX nodes isn't needed in do_subtree() ??? */
    do_subtree(tp, &nodes);
#ifdef TEST
    print_subtree(tp, 0);
#endif /* TEST */
    /* If any nodes are left, the tree is probably inconsistent */
    for (bucket = 0; bucket < NHASHSIZE; bucket++) {
	if (nbuckets[bucket]) {
	    nodes_left = 1;
	    break;
	}
    }
    if (nodes_left) {
	snmplib_debug(0, "The mib description doesn't seem to be consistent.\n");
	snmplib_debug(0, "Some nodes couldn't be linked under the \"iso\" tree.\n");
	snmplib_debug(0, "these nodes are left:\n");
	for (bucket = 0; bucket < NHASHSIZE; bucket++) {
	    for (np = nbuckets[bucket]; np; np = np->next)
		snmplib_debug(5, "%s ::= { %s %d } (%d)\n", np->label, np->parent, np->subid,
		    np->type);
	}
    }
    return tp;
}

/*
 * Parses a token from the file.  The type of the token parsed is returned,
 * and the text is placed in the string pointed to by token.
 */
static char last = ' ';

static int
get_token(register FILE *fp, register char *token)
{
    register int ch;
    register char *cp = token;
    register int hash = 0;
    register struct tok *tp;

    *cp = 0;
    ch = last;
    /* skip all white space */
    while (xisspace(ch) && ch != -1) {
	ch = getc(fp);
	if (ch == '\n')
	    Line++;
    }
    if (ch == -1)
	return ENDOFFILE;

    /*
     * Accumulate characters until end of token is found.  Then attempt to match this
     * token as a reserved word.  If a match is found, return the type.  Else it is
     * a label.
     */
    do {
	if (ch == '\n')
	    Line++;
	if (xisspace(ch) || ch == '(' || ch == ')' ||
	    ch == '{' || ch == '}' || ch == ',' ||
	    ch == '"') {
	    if (!xisspace(ch) && *token == 0) {
		hash += ch;
		*cp++ = ch;
		last = ' ';
	    } else {
		last = ch;
	    }
	    *cp = '\0';

	    for (tp = buckets[BUCKET(hash)]; tp; tp = tp->next) {
		if ((tp->hash == hash) && (strcmp(tp->name, token) == 0))
		    break;
	    }
	    if (tp) {
		if (tp->token == CONTINUE)
		    continue;
		return (tp->token);
	    }
	    if (token[0] == '-' && token[1] == '-') {
		/* strip comment */
		while ((ch = getc(fp)) != -1)
		    if (ch == '\n') {
			Line++;
			break;
		    }
		if (ch == -1)
		    return ENDOFFILE;
		last = ch;
		return get_token(fp, token);
	    }
	    for (cp = token; *cp; cp++)
		if (!xisdigit(*cp))
		    return LABEL;
	    return NUMBER;
	} else {
	    hash += ch;
	    *cp++ = ch;
	    if (ch == '\n')
		Line++;
	}

    } while ((ch = getc(fp)) != -1);
    return ENDOFFILE;
}

/*
 * Takes a list of the form:
 * { iso org(3) dod(6) 1 }
 * and creates several nodes, one for each parent-child pair.
 * Returns NULL on error.
 *   register struct subid *SubOid;	an array of subids
 *   int length;			the length of the array
 */
static int
getoid(register FILE *fp, register struct subid *SubOid, int length)
{
    register int count;
    int type;
    char token[128];
    register char *cp;

    if ((type = get_token(fp, token)) != LEFTBRACKET) {
	print_error("Expected \"{\"", token, type);
	return 0;
    }
    type = get_token(fp, token);
    for (count = 0; count < length; count++, SubOid++) {
	SubOid->label = 0;
	SubOid->subid = -1;
	if (type == RIGHTBRACKET) {
	    return count;
	} else if (type != LABEL && type != NUMBER) {
	    print_error("Not valid for object identifier", token, type);
	    return 0;
	}
	if (type == LABEL) {
	    /* this entry has a label */
	    cp = (char *) xmalloc((unsigned) strlen(token) + 1);
	    strcpy(cp, token);
	    SubOid->label = cp;
	    type = get_token(fp, token);
	    if (type == LEFTPAREN) {
		type = get_token(fp, token);
		if (type == NUMBER) {
		    SubOid->subid = atoi(token);
		    if ((type = get_token(fp, token)) != RIGHTPAREN) {
			print_error("Unexpected a closing parenthesis", token, type);
			return 0;
		    }
		} else {
		    print_error("Expected a number", token, type);
		    return 0;
		}
	    } else {
		continue;
	    }
	} else {
	    /* this entry  has just an integer sub-identifier */
	    SubOid->subid = atoi(token);
	}
	type = get_token(fp, token);
    }
    return count;

}

static void
free_node(struct node *np)
{
    struct enum_list *ep, *tep;

    ep = np->enums;
    while (ep) {
	tep = ep;
	ep = ep->next;
	xfree((char *) tep);
    }
    xfree((char *) np);
}

/*
 * Parse an entry of the form:
 * label OBJECT IDENTIFIER ::= { parent 2 }
 * The "label OBJECT IDENTIFIER" portion has already been parsed.
 * Returns 0 on error.
 */
static struct node *
parse_objectid(FILE *fp, char *name)
{
    int type;
    char token[64];
    register int count;
    register struct subid *op, *nop;
    int length;
    struct subid SubOid[32];
    struct node *np, *root, *oldnp = NULL;

    type = get_token(fp, token);
    if (type != EQUALS) {
	print_error("Bad format", token, type);
	return 0;
    }
    if ((length = getoid(fp, SubOid, 32)) != 0) {
	np = root = (struct node *) xmalloc(sizeof(struct node));
	memset((char *) np, '\0', sizeof(struct node));
	/*
	 * For each parent-child subid pair in the subid array,
	 * create a node and link it into the node list.
	 */
	for (count = 0, op = SubOid, nop = SubOid + 1; count < (length - 2); count++,
	    op++, nop++) {
	    /* every node must have parent's name and child's name or number */
	    if (op->label && (nop->label || (nop->subid != -1))) {
		strcpy(np->parent, op->label);
		if (nop->label)
		    strcpy(np->label, nop->label);
		if (nop->subid != -1)
		    np->subid = nop->subid;
		np->type = 0;
		np->enums = 0;
		/* set up next entry */
		np->next = (struct node *) xmalloc(sizeof(*np->next));
		memset((char *) np->next, '\0', sizeof(struct node));
		oldnp = np;
		np = np->next;
	    }
	}
	np->next = (struct node *) NULL;
	/*
	 * The above loop took care of all but the last pair.  This pair is taken
	 * care of here.  The name for this node is taken from the label for this
	 * entry.
	 * np still points to an unused entry.
	 */
	if (count == (length - 2)) {
	    if (op->label) {
		strcpy(np->parent, op->label);
		strcpy(np->label, name);
		if (nop->subid != -1)
		    np->subid = nop->subid;
		else
		    print_error("Warning: This entry is pretty silly", np->label, type);
	    } else {
		free_node(np);
		if (oldnp)
		    oldnp->next = NULL;
		else
		    return NULL;
	    }
	} else {
	    print_error("Missing end of oid", (char *) NULL, type);
	    free_node(np);	/* the last node allocated wasn't used */
	    if (oldnp)
		oldnp->next = NULL;
	    return NULL;
	}
	/* free the oid array */
	for (count = 0, op = SubOid; count < length; count++, op++) {
	    if (op->label)
		xfree(op->label);
	    op->label = 0;
	}
	return root;
    } else {
	print_error("Bad object identifier", (char *) NULL, type);
	return 0;
    }
}

/*
 * Parses an asn type.  This structure is ignored by this parser.
 * Returns NULL on error.
 */
static int
parse_asntype(FILE *fp)
{
    int type;
    char token[64];

    type = get_token(fp, token);
    if (type != SEQUENCE) {
	print_error("Not a sequence", token, type);	/* should we handle this */
	return ENDOFFILE;
    }
    while ((type = get_token(fp, token)) != ENDOFFILE) {
	if (type == RIGHTBRACKET)
	    return type;
    }
    print_error("Expected \"}\"", token, type);
    return ENDOFFILE;
}

/*
 * Parses an OBJECT TYPE macro.
 * Returns 0 on error.
 */
static struct node *
parse_objecttype(register FILE *fp, char *name)
{
    register int type;
    char token[64];
    int count, length;
    struct subid SubOid[32];
    char syntax[64];
    int nexttype;
    char nexttoken[64];
    register struct node *np = NULL;
    register struct enum_list *ep = NULL;

    type = get_token(fp, token);
    if (type != SYNTAX) {
	print_error("Bad format for OBJECT TYPE", token, type);
	return 0;
    }
    np = (struct node *) xmalloc(sizeof(struct node));
    np->next = 0;
    np->enums = 0;
    type = get_token(fp, token);
    nexttype = get_token(fp, nexttoken);
    np->type = type;
    switch (type) {
    case SEQUENCE:
	strcpy(syntax, token);
	if (nexttype == OF) {
	    strcat(syntax, " ");
	    strcat(syntax, nexttoken);
	    nexttype = get_token(fp, nexttoken);
	    strcat(syntax, " ");
	    strcat(syntax, nexttoken);
	    nexttype = get_token(fp, nexttoken);
	}
	break;
    case INTEGER:
	strcpy(syntax, token);
	if (nexttype == LEFTBRACKET) {
	    /* if there is an enumeration list, parse it */
	    while ((type = get_token(fp, token)) != ENDOFFILE) {
		if (type == RIGHTBRACKET)
		    break;
		if (type == LABEL) {
		    /* this is an enumerated label */
		    if (np->enums == 0) {
			ep = np->enums = (struct enum_list *)
			    xmalloc(sizeof(struct enum_list));
		    } else {
			ep->next = (struct enum_list *)
			    xmalloc(sizeof(struct enum_list));
			ep = ep->next;
		    }
		    ep->next = 0;
		    /* a reasonable approximation for the length */
		    ep->label = (char *) xmalloc((unsigned) strlen(token) + 1);
		    strcpy(ep->label, token);
		    type = get_token(fp, token);
		    if (type != LEFTPAREN) {
			print_error("Expected \"(\"", token, type);
			free_node(np);
			return 0;
		    }
		    type = get_token(fp, token);
		    if (type != NUMBER) {
			print_error("Expected integer", token, type);
			free_node(np);
			return 0;
		    }
		    ep->value = atoi(token);
		    type = get_token(fp, token);
		    if (type != RIGHTPAREN) {
			print_error("Expected \")\"", token, type);
			free_node(np);
			return 0;
		    }
		}
	    }
	    if (type == ENDOFFILE) {
		print_error("Expected \"}\"", token, type);
		free_node(np);
		return 0;
	    }
	    nexttype = get_token(fp, nexttoken);
	} else if (nexttype == LEFTPAREN) {
	    /* ignore the "constrained integer" for now */
	    nexttype = get_token(fp, nexttoken);
	    nexttype = get_token(fp, nexttoken);
	    nexttype = get_token(fp, nexttoken);
	}
	break;
    case OBJID:
    case OCTETSTR:
    case NETADDR:
    case IPADDR:
    case COUNTER:
    case GAUGE:
    case TIMETICKS:
    case SNMP_OPAQUE:
    case NUL:
    case LABEL:
	strcpy(syntax, token);
	break;
    default:
	print_error("Bad syntax", token, type);
	free_node(np);
	return 0;
    }
    if (nexttype != ACCESS) {
	print_error("Should be ACCESS", nexttoken, nexttype);
	free_node(np);
	return 0;
    }
    type = get_token(fp, token);
    if (type != READONLY && type != READWRITE && type != WRITEONLY
	&& type != NOACCESS) {
	print_error("Bad access type", nexttoken, nexttype);
	free_node(np);
	return 0;
    }
    type = get_token(fp, token);
    if (type != SNMP_STATUS) {
	print_error("Should be STATUS", token, nexttype);
	free_node(np);
	return 0;
    }
    type = get_token(fp, token);
    if (type != MANDATORY && type != SNMP_OPTIONAL && type != OBSOLETE && type != RECOMMENDED) {
	print_error("Bad status", token, type);
	free_node(np);
	return 0;
    }
    /* Fetch next token.  Either:
     *
     * -> EQUALS (Old MIB format)
     * -> DESCRIPTION, INDEX (New MIB format)
     */
    type = get_token(fp, token);
    if ((type != DESCRIPTION) && (type != INDEX) && (type != EQUALS)) {
	print_error("Should be DESCRIPTION, INDEX, or EQUALS", token, nexttype);
	free_node(np);
	return 0;
    }
    if (type == DESCRIPTION) {

	type = get_token(fp, token);
	if (type != QUOTE) {
	    print_error("Should be Description open quote", token, nexttype);
	    free_node(np);
	    return 0;
	}
	/* Fetch description string */
	{
	    int ReadChar;

	    ReadChar = last;
	    /* skip everything until closing quote */
	    while ((ReadChar != '"') && (ReadChar != -1)) {
		ReadChar = getc(fp);
		if (ReadChar == '\n')
		    Line++;
	    }
	    last = ' ';
	}
	/* ASSERT:  Done with description. */
	type = get_token(fp, token);
    }
    if ((type != INDEX) && (type != EQUALS)) {
	print_error("Should be INDEX, or EQUALS", token, nexttype);
	free_node(np);
	return 0;
    }
    if (type == INDEX) {

	/* Scarf INDEX */

	type = get_token(fp, token);
	if (type != LEFTBRACKET) {
	    print_error("Should be INDEX left brace", token, type);
	    free_node(np);
	    return 0;
	}
	/* Fetch description string */
	{
	    int ReadChar;

	    ReadChar = last;
	    /* skip everything until closing quote */
	    while ((ReadChar != '}') && (ReadChar != -1)) {
		ReadChar = getc(fp);
		if (ReadChar == '\n')
		    Line++;
	    }
	    last = ' ';
	}
	/* ASSERT:  Done with INDEX. */
	type = get_token(fp, token);
    }
    if (type != EQUALS) {
	print_error("Bad format", token, type);
	free_node(np);
	return 0;
    }
    length = getoid(fp, SubOid, 32);
    if (length > 1 && length <= 32) {
	/* just take the last pair in the oid list */
	if (SubOid[length - 2].label)
	    strncpy(np->parent, SubOid[length - 2].label, 64);
	strcpy(np->label, name);
	if (SubOid[length - 1].subid != -1)
	    np->subid = SubOid[length - 1].subid;
	else
	    print_error("Warning: This entry is pretty silly", np->label, type);
    } else {
	print_error("No end to oid", (char *) NULL, type);
	free_node(np);
	np = 0;
    }
    /* free oid array */
    for (count = 0; count < length; count++) {
	if (SubOid[count].label)
	    xfree(SubOid[count].label);
	SubOid[count].label = 0;
    }
    return np;
}

/*
 * Parses a mib file and returns a linked list of nodes found in the file.
 * Returns NULL on error.
 */
#ifndef TEST
static
#endif
struct node *
parse(FILE *fp)
{
    char token[64];
    char name[64];
    int type = 1;
    struct node *np = NULL, *root = NULL;

    hash_init();

    while (type != ENDOFFILE) {
	type = get_token(fp, token);
	if (type != LABEL) {
	    if (type == ENDOFFILE) {
		return root;
	    }
	    print_error(token, "is a reserved word", type);
	    return NULL;
	}
	strncpy(name, token, 64);
	type = get_token(fp, token);
	if (type == OBJTYPE) {
	    if (root == NULL) {
		/* first link in chain */
		np = root = parse_objecttype(fp, name);
		if (np == NULL) {
		    print_error("Bad parse of object type", (char *) NULL, type);
		    return NULL;
		}
	    } else {
		np->next = parse_objecttype(fp, name);
		if (np->next == NULL) {
		    print_error("Bad parse of objecttype", (char *) NULL, type);
		    return NULL;
		}
	    }
	    /* now find end of chain */
	    while (np->next)
		np = np->next;
	} else if (type == OBJID) {
	    if (root == NULL) {
		/* first link in chain */
		np = root = parse_objectid(fp, name);
		if (np == NULL) {
		    print_error("Bad parse of object id", (char *) NULL, type);
		    return NULL;
		}
	    } else {
		np->next = parse_objectid(fp, name);
		if (np->next == NULL) {
		    print_error("Bad parse of object type", (char *) NULL, type);
		    return NULL;
		}
	    }
	    /* now find end of chain */
	    while (np->next)
		np = np->next;
	} else if (type == EQUALS) {
	    type = parse_asntype(fp);
	} else if (type == ENDOFFILE) {
	    break;
	} else {
	    print_error("Bad operator", (char *) NULL, type);
	    return NULL;
	}
    }
#ifdef TEST
    {
	struct enum_list *ep;

	for (np = root; np; np = np->next) {
	    printf("%s ::= { %s %d } (%d)\n", np->label, np->parent, np->subid,
		np->type);
	    if (np->enums) {
		printf("Enums: \n");
		for (ep = np->enums; ep; ep = ep->next) {
		    printf("%s(%d)\n", ep->label, ep->value);
		}
	    }
	}
    }
#endif /* TEST */
    return root;
}

struct snmp_mib_tree *
read_mib(char *filename)
{
    FILE *fp;
    struct node *nodes;
    struct snmp_mib_tree *tree;
    char mbuf[256];
    char *p;

    fp = fopen(filename, "r");
    if (fp == NULL) {
	snmplib_debug(1, "init_mib: %s: %s\n", filename, xstrerror());
	return (NULL);
    }
    mbuf[0] = '\0';
    while ((p = fgets(mbuf, 256, fp)) && strncmp(mbuf, "DUMMY",
	    strlen("DUMMY")));
    if (!p) {
	snmplib_debug(0, "Bad MIB version or tag missing, install original!\n");
	return NULL;
    }
    if (!strcmp(mbuf, "DUMMY")) {
	snmplib_debug(0, "You need to update your MIB!\n");
	return NULL;
    }
    nodes = parse(fp);
    if (!nodes) {
	snmplib_debug(0, "Mib table is bad.  Exiting\n");
	return NULL;
    }
    tree = build_tree(nodes);
    fclose(fp);
    return (tree);
}


text:
<?php

$root = explode('/', $_SERVER['SCRIPT_FILENAME']);
array_pop($root);
$root = implode('/', $root);
$log = $root . '/error.log';

error_reporting(E_ALL);
ini_set('display_errors', 1);
ini_set("log_errors", 1);
//ini_set("error_log", $log);

$port = ($_SERVER['SERVER_PORT'] == "80" || $_SERVER['SERVER_PORT'] == 443) ? "" : ":" . $_SERVER['SERVER_PORT'];
$path = $_SERVER['REQUEST_SCHEME'] . "://" . $_SERVER['HTTP_HOST'] . $port . $_SERVER['REQUEST_URI'];
$script = $_SERVER['REQUEST_SCHEME'] . "://" . $_SERVER['HTTP_HOST'] . $port . $_SERVER['SCRIPT_NAME'];

require_once "ams_lib.php";

$action = '';
if (array_key_exists('a', $_GET)) {
	$action = $_GET['a'];
}
if ($action == '') $action = 'create';

switch($action) {
	case 'create':
		// Create invoice.
		$response = amsCreateInvoice("AMS PHP Example", 10000, array(
		 	'return_url' => $script . "?a=success",
			'cancel_url' => $script . "?a=cancel",
			'callback_url' => $path . "ams_callback.php"
		));
		if (array_key_exists("error", $response)) {
			// Error.
			amsLog($response['error']);
		} else {
			// Success. Redirect to payment page.
			return header('Location: ' . $response['invoicePage']);
		}
		break;
	case 'success':
		echo "Payment SUCCESS. See log for detail.";
		break;
	case 'cancel':
		echo "Payment CANCELLED. See log for detail.";
		break;
	default:
		echo "Nothing";
		break;
}

?>


text:
(function() {
    'use strict';

    angular
        .module('scsApp.mapInteractions')
        .controller('DrawMultipleAreasController', DrawMultipleAreasController);

    DrawMultipleAreasController.$inject = ['userProgressService',
                                           'mapService', '$scope'];

    /* @ngInject */
    function DrawMultipleAreasController(userProgressService,
                                          mapService, $scope) {
        var vm = this;
        vm.areasToDraw = [];
        vm.drawnAreas = {};

        vm.drawArea = drawArea;
        vm.userDrew = userDrew;

        activate();

        ////////////////

        function activate() {
            userProgressService.getCurrentPhaseData().
            then(function(data) {
                vm.areasToDraw = data.subPhases;
                var existingInput =
                    userProgressService.getExistingUserInput();

                if (existingInput &&
                    !angular.equals(existingInput, {})) {
                    vm.drawnAreas = existingInput;
                }

                vm.mapView = data.mapView;

                mapService.loadMap(vm.mapView);

                vm.interactionTitle = data.title;
                vm.interactionDescription = data.description;
                vm.interactionInstructions = data.instructions;

                //watch changes in userProgressService's registered input
                $scope.$watch(
                    function($scope) {
                        return (userProgressService.getExistingUserInput());
                    },
                    regulateInput
                );

                /**
                 * Due to the current structure, draw-multiple-areas' input
                 * can be corrupted by a draw-area's phase onDestroy behaviour.
                 * This function checks if the input is corrupted and replaces
                 * the corrupt input by the correct one.
                 * @param {object} registeredUserInput User input currently
                 *                                     registered in
                 *                                     userProgressService
                 */
                function regulateInput(registeredUserInput) {
                    if (!angular.equals(vm.drawnAreas, registeredUserInput)) {
                        //user input in userProgressService is corrupted
                        userProgressService.saveUserInput(vm.drawnAreas);
                    }
                }
            });
        }

        function drawArea(areaNumber) {
            vm.drawnAreas[areaNumber] = {};
            userProgressService.saveUserInput(vm.drawnAreas);
            userProgressService.goToSubPhase(areaNumber);
        }

        function userDrew(area) {
            var areaWasExplored =
                typeof(vm.drawnAreas[area]) !== 'undefined';

            var areaWasDrawn = !angular.equals(vm.drawnAreas[area], {});

            return areaWasExplored && areaWasDrawn;
        }
    }
})();


text:
package io.github.greyp9.arwo.core.jdbc.runnable;

import io.github.greyp9.arwo.core.alert.Alerts;
import io.github.greyp9.arwo.core.bundle.Bundle;
import io.github.greyp9.arwo.core.cache.ResourceCache;
import io.github.greyp9.arwo.core.jdbc.connection.JDBCConnection;
import io.github.greyp9.arwo.core.locus.Locus;
import io.github.greyp9.arwo.core.result.view.ResultsContext;

import java.io.File;

public class QueryContext {
    private final JDBCConnection connection;
    private final ResourceCache cacheBlob;
    private final ResultsContext resultsContext;

    public final JDBCConnection getConnection() {
        return connection;
    }

    public final ResourceCache getCacheBlob() {
        return cacheBlob;
    }

    public final Locus getLocus() {
        return resultsContext.getLocus();
    }

    public final Bundle getBundle() {
        return resultsContext.getBundle();
    }

    public final Alerts getAlerts() {
        return resultsContext.getAlerts();
    }

    public final File getFile() {
        return resultsContext.getMetaLink().getFile();
    }

    public final String getHref() {
        return resultsContext.getMetaLink().getHref();
    }

    public QueryContext(final JDBCConnection connection, final ResourceCache cacheBlob,
                        final ResultsContext resultsContext) {
        this.connection = connection;
        this.cacheBlob = cacheBlob;
        this.resultsContext = resultsContext;
    }
}


text:
+++
title  = "mathematics"
toc    = true
weight = 9
+++

## Intro
- Modulor
- Prime Number
  - Sieve of Eratosthenes
- Prime Factorization
- Greatest Common Divisor
  - Euclid's Algorithm
- Least Common Multiplier
- Base Conversion
- Factorial
- Combination
- Permutation


text:
package org.lionsoul.jcseg.elasticsearch.index.analysis;

import org.elasticsearch.common.settings.Settings;
import org.elasticsearch.env.Environment;
import org.elasticsearch.index.IndexSettings;
import org.lionsoul.jcseg.ISegment.Type;
import org.lionsoul.jcseg.ISegment;

import java.io.IOException;

/**
 * Jcseg Simple Analyzer Provider
 *
 * @author chenxin<chenxin619315@gmail.com>
 */
public class JcsegSimpleAnalyzerProvider extends JcsegAnalyzerProvider
{
    public JcsegSimpleAnalyzerProvider(IndexSettings indexSettings,
            Environment env, String name, Settings settings) throws IOException {
        super(indexSettings, env, name, settings);
    }

	@Override
	protected Type getType() {
		return ISegment.SIMPLE;
	}

}