text:
<idea-plugin package="org.intellij.plugins.markdown">
  <id>org.intellij.plugins.markdown</id>
  <name>Markdown</name>
  <vendor>JetBrains</vendor>
  <category>Languages</category>
  <resource-bundle>messages.MarkdownBundle</resource-bundle>

  <dependencies>
    <plugin id="com.intellij.modules.lang"/>
    <plugin id="com.intellij.platform.images"/>
  </dependencies>
  <content>
    <module name="intellij.markdown.fenceInjection"/>
  </content>

  <description><![CDATA[

Provides the capability to edit Markdown files within the IDE and see the rendered HTML in a live preview.

Includes the following features:

Document structure view, headers folding, highlighting, TODOs.

Code completion and navigation for links to project files.

Embedding fenced code blocks for different languages.

Visualizing diagrams for the DOT or PlantUML diagramming languages.

Ability to use custom stylesheets for a live preview.

]]></description>

  <extensionPoints>
    <extensionPoint qualifiedName="org.intellij.markdown.html.panel.provider"
                    interface="org.intellij.plugins.markdown.ui.preview.MarkdownHtmlPanelProvider"
                    dynamic="true"/>
    <extensionPoint qualifiedName="org.intellij.markdown.fenceLanguageProvider"
                    interface="org.intellij.plugins.markdown.injection.CodeFenceLanguageProvider"
                    dynamic="true"/>
    <extensionPoint qualifiedName="org.intellij.markdown.fenceGeneratingProvider"
                    interface="org.intellij.plugins.markdown.extensions.CodeFenceGeneratingProvider"
                    dynamic="true"/>
    <extensionPoint qualifiedName="org.intellij.markdown.previewStylesProvider"
                    interface="org.intellij.plugins.markdown.ui.preview.MarkdownPreviewStylesProvider"
                    dynamic="true"/>
    <extensionPoint qualifiedName="org.intellij.markdown.browserPreviewExtensionProvider"
                    interface="org.intellij.plugins.markdown.extensions.MarkdownBrowserPreviewExtension$Provider"
                    dynamic="true"/>
    <extensionPoint qualifiedName="org.intellij.markdown.markdownExportProvider"
                    interface="org.intellij.plugins.markdown.fileActions.export.MarkdownExportProvider"
                    dynamic="true"/>
    <extensionPoint qualifiedName="org.intellij.markdown.markdownRunner"
                    interface="org.intellij.plugins.markdown.extensions.jcef.commandRunner.MarkdownRunner"
                    dynamic="true"/>
  </extensionPoints>

  <extensions defaultExtensionNs="com.intellij">
    <typedHandler implementation="org.intellij.plugins.markdown.editor.tables.handlers.MarkdownTableTypedHandler"/>
    <backspaceHandlerDelegate implementation="org.intellij.plugins.markdown.editor.tables.handlers.MarkdownTableBackspaceHandler"/>
    <enterHandlerDelegate implementation="org.intellij.plugins.markdown.editor.tables.handlers.MarkdownTableEnterHandler"/>
    <editorActionHandler action="EditorTab" implementationClass="org.intellij.plugins.markdown.editor.tables.handlers.MarkdownTableTabHandler$Tab"/>
    <editorActionHandler action="EditorUnindentSelection" implementationClass="org.intellij.plugins.markdown.editor.tables.handlers.MarkdownTableTabHandler$ShiftTab"/>
    <editorActionHandler action="EditorStartNewLine" implementationClass="org.intellij.plugins.markdown.editor.tables.handlers.MarkdownTableShiftEnterHandler"/>
    <editorActionHandler action="EditorDeleteToWordStart" implementationClass="org.intellij.plugins.markdown.editor.tables.handlers.MarkdownTableReformatAfterActionHook"/>
    <codeInsight.inlayProvider language="Markdown"
                               implementationClass="org.intellij.plugins.markdown.editor.tables.ui.MarkdownTableInlayProvider"
                               id="MarkdownTableInlayProvider"/>
    <editorFactoryListener implementation="org.intellij.plugins.markdown.editor.tables.ui.MarkdownInlayUpdateOnSoftWrapListener"/>

    <localInspection language="Markdown"
                     shortName="MarkdownIncorrectTableFormatting"
                     bundle="messages.MarkdownBundle"
                     key="markdown.incorrect.table.formatting.inspection.name"
                     groupKey="markdown.inspection.group.ruby.name"
                     enabledByDefault="true"
                     level="WEAK WARNING"
                     implementationClass="org.intellij.plugins.markdown.editor.tables.inspections.MarkdownIncorrectTableFormattingInspection"/>

    <localInspection language="Markdown"
                     shortName="MarkdownNoTableBorders"
                     bundle="messages.MarkdownBundle"
                     key="markdown.no.table.borders.inspection.name"
                     groupKey="markdown.inspection.group.ruby.name"
                     enabledByDefault="true"
                     level="ERROR"
                     implementationClass="org.intellij.plugins.markdown.editor.tables.inspections.MarkdownNoTableBordersInspection"/>

    <intentionAction>
      <className>org.intellij.plugins.markdown.editor.tables.intentions.MarkdownInsertTableColumnIntention$InsertBefore</className>
      <bundleName>messages.MarkdownBundle</bundleName>
      <categoryKey>markdown.intention.category</categoryKey>
    </intentionAction>
    <intentionAction>
      <className>org.intellij.plugins.markdown.editor.tables.intentions.MarkdownInsertTableColumnIntention$InsertAfter</className>
      <bundleName>messages.MarkdownBundle</bundleName>
      <categoryKey>markdown.intention.category</categoryKey>
    </intentionAction>
    <intentionAction>
      <className>org.intellij.plugins.markdown.editor.tables.intentions.MarkdownSetColumnAlignmentIntention</className>
      <bundleName>messages.MarkdownBundle</bundleName>
      <categoryKey>markdown.intention.category</categoryKey>
    </intentionAction>
    <intentionAction>
      <className>org.intellij.plugins.markdown.editor.tables.intentions.MarkdownRemoveColumnIntention</className>
      <bundleName>messages.MarkdownBundle</bundleName>
      <categoryKey>markdown.intention.category</categoryKey>
    </intentionAction>
    <intentionAction>
      <className>org.intellij.plugins.markdown.editor.tables.intentions.MarkdownRemoveRowIntention</className>
      <bundleName>messages.MarkdownBundle</bundleName>
      <categoryKey>markdown.intention.category</categoryKey>
    </intentionAction>

    <httpRequestHandler implementation="org.intellij.plugins.markdown.google.authorization.GoogleOAuthCallbackHandler"/>

    <renameHandler implementation="org.intellij.plugins.markdown.ui.projectTree.MarkdownRenameHandler"/>
    <automaticRenamerFactory implementation="org.intellij.plugins.markdown.ui.projectTree.MarkdownRenamerFactory"/>

    <fileType name="Markdown" extensions="markdown;md" language="Markdown"
              implementationClass="org.intellij.plugins.markdown.lang.MarkdownFileType" fieldName="INSTANCE"/>
    <lang.fileViewProviderFactory language="Markdown"
                                  implementationClass="org.intellij.plugins.markdown.lang.MarkdownFileViewProviderFactory"/>
    <lang.parserDefinition language="Markdown" implementationClass="org.intellij.plugins.markdown.lang.parser.MarkdownParserDefinition"/>
    <lang.ast.factory language="Markdown" implementationClass="org.intellij.plugins.markdown.lang.psi.MarkdownAstFactory"/>

    <lang.elementManipulator forClass="org.intellij.plugins.markdown.lang.psi.impl.MarkdownCodeFence"
                             implementationClass="org.intellij.plugins.markdown.lang.psi.impl.MarkdownCodeFence$Manipulator"/>
    <lang.elementManipulator forClass="org.intellij.plugins.markdown.lang.psi.impl.MarkdownLinkDestination"
                             implementationClass="org.intellij.plugins.markdown.lang.psi.impl.MarkdownLinkDestination$Manipulator"/>

    <colorSettingsPage implementation="org.intellij.plugins.markdown.highlighting.MarkdownColorSettingsPage"/>
    <syntaxHighlighter key="Markdown" implementationClass="org.intellij.plugins.markdown.highlighting.MarkdownSyntaxHighlighter"/>
    <additionalTextAttributes scheme="Default" file="colorSchemes/MarkdownDefault.xml"/>
    <additionalTextAttributes scheme="Darcula" file="colorSchemes/MarkdownDarcula.xml"/>

    <braceMatcher filetype="Markdown" implementationClass="org.intellij.plugins.markdown.braces.MarkdownBraceMatcher"/>
    <quoteHandler fileType="Markdown" className="org.intellij.plugins.markdown.braces.MarkdownQuoteHandler"/>
    <typedHandler implementation="org.intellij.plugins.markdown.editor.MarkdownTypedHandler"/>

    <bidiRegionsSeparator language="Markdown" implementationClass="org.intellij.plugins.markdown.editor.MarkdownBidiRegionsSeparator"/>

    <annotator language="Markdown" implementationClass="org.intellij.plugins.markdown.highlighting.MarkdownHighlightingAnnotator"/>

    <runLineMarkerContributor language="Markdown" implementationClass="org.intellij.plugins.markdown.extensions.jcef.commandRunner.MarkdownRunLineMarkersProvider"/>

    <completion.contributor language="Markdown"
                            implementationClass="org.intellij.plugins.markdown.editor.MarkdownCompletionContributor"/>

    <fileEditorProvider implementation="org.intellij.plugins.markdown.ui.preview.MarkdownSplitEditorProvider"/>

    <customPasteProvider implementation="org.intellij.plugins.markdown.editor.images.MarkdownImagePasteProvider"/>

    <customFileDropHandler implementation="org.intellij.plugins.markdown.editor.images.MarkdownImageFileDropHandler"/>

    <spellchecker.support language="Markdown"
                          implementationClass="org.intellij.plugins.markdown.spellchecking.MarkdownSpellcheckingStrategy"/>

    <customFileDropHandler implementation="org.intellij.plugins.markdown.fileActions.importFrom.docx.MarkdownDocxFileDropHandler"/>

    <breadcrumbsInfoProvider implementation="org.intellij.plugins.markdown.breadcrumbs.MarkdownBreadcrumbsProvider"/>

    <treeStructureProvider implementation="org.intellij.plugins.markdown.ui.projectTree.MarkdownTreeStructureProvider"/>

    <applicationService serviceInterface="org.intellij.plugins.markdown.extensions.ExtensionsExternalFilesPathManager"
                        serviceImplementation="org.intellij.plugins.markdown.extensions.ExtensionsExternalFilesPathManager$Impl"/>

    <applicationService serviceInterface="org.intellij.plugins.markdown.ui.preview.accessor.MarkdownLinkOpener"
                        serviceImplementation="org.intellij.plugins.markdown.ui.preview.accessor.impl.MarkdownLinkOpenerImpl"/>

    <applicationService serviceImplementation="org.intellij.plugins.markdown.google.accounts.GooglePersistentAccounts"/>
    <applicationService serviceImplementation="org.intellij.plugins.markdown.google.authorization.GoogleOAuthService"/>
    <filePasteProvider implementation="org.intellij.plugins.markdown.fileActions.importFrom.googleDocs.GoogleDocsImportPasteProvider"/>

    <projectService serviceImplementation="org.intellij.plugins.markdown.settings.MarkdownSettings"/>
    <projectService serviceImplementation="org.intellij.plugins.markdown.settings.pandoc.PandocSettings"/>

    <projectConfigurable id="Settings.Markdown"
                         bundle="messages.MarkdownBundle"
                         groupId="language"
                         nonDefaultProject="false"
                         key="markdown.settings.name"
                         instance="org.intellij.plugins.markdown.settings.MarkdownSettingsConfigurable"/>

    <applicationConfigurable parentId="Settings.Markdown" instance="org.intellij.plugins.markdown.google.ui.GoogleSettingsConfigurable"/>

    <applicationService serviceImplementation="org.intellij.plugins.markdown.settings.MarkdownApplicationSettings"/>
    <applicationService serviceImplementation="org.intellij.plugins.markdown.ui.preview.html.MarkdownCodeFenceHtmlCache"/>
    <applicationService serviceImplementation="org.intellij.plugins.markdown.fileActions.export.MarkdownHtmlExportSettings"/>
    <lang.psiStructureViewFactory language="Markdown"
                                  implementationClass="org.intellij.plugins.markdown.structureView.MarkdownStructureViewFactory"/>
    <psi.referenceContributor implementation="org.intellij.plugins.markdown.lang.references.MarkdownReferenceProvider"/>
    <stripTrailingSpacesFilterFactory implementation="org.intellij.plugins.markdown.editor.MarkdownStripTrailingSpacesFilterFactory"/>
    <httpRequestHandler implementation="org.intellij.plugins.markdown.ui.preview.PreviewStaticServer"/>

    <localInspection language="Markdown" shortName="MarkdownUnresolvedFileReference" bundle="messages.MarkdownBundle"
                     key="markdown.unresolved.file.inspection.name" groupKey="markdown.inspection.group.ruby.name"
                     enabledByDefault="true" level="WARNING"
                     implementationClass="org.intellij.plugins.markdown.lang.references.MarkdownUnresolvedFileReferenceInspection"/>

    <lang.foldingBuilder language="Markdown" implementationClass="org.intellij.plugins.markdown.folding.MarkdownFoldingBuilder"/>
    <stubIndex implementation="org.intellij.plugins.markdown.lang.index.MarkdownHeadersIndex"/>
    <stubElementTypeHolder class="org.intellij.plugins.markdown.lang.MarkdownElementTypes"/>
    <anchorReferenceProvider implementation="org.intellij.plugins.markdown.lang.references.MissingExtensionPathReferenceProvider"/>
    <anchorReferenceProvider implementation="org.intellij.plugins.markdown.lang.references.MarkdownAnchorPathReferenceProvider"/>
    <todoIndexer filetype="Markdown" implementationClass="org.intellij.plugins.markdown.highlighting.MarkdownTodoIndexer"/>
    <indexPatternBuilder implementation="org.intellij.plugins.markdown.highlighting.MarkdownIndexPatternBuilder"/>
    <enterHandlerDelegate id="MarkdownEnterHandler"
                          implementation="org.intellij.plugins.markdown.editor.MarkdownEnterHandler"/>
    <highlightErrorFilter
      implementation="org.intellij.plugins.markdown.injection.MarkdownCodeFenceErrorHighlightingIntention$CodeFenceHighlightErrorFilter"/>
    <extendWordSelectionHandler implementation="org.intellij.plugins.markdown.editor.MarkdownCodeSpanExtendWordSelectionHandler"/>

    <typedHandler implementation="org.intellij.plugins.markdown.editor.lists.MarkdownListItemCreatingTypedHandlerDelegate"/>

    <lineIndentProvider implementation="org.intellij.plugins.markdown.editor.lists.MarkdownListIndentProvider"/>
    <enterHandlerDelegate implementation="org.intellij.plugins.markdown.editor.lists.MarkdownListEnterHandlerDelegate"
                          order="before MarkdownEnterHandler"/>

    <backspaceHandlerDelegate implementation="org.intellij.plugins.markdown.editor.lists.MarkdownListMarkerBackspaceHandlerDelegate"/>
    <backspaceHandlerDelegate implementation="org.intellij.plugins.markdown.editor.lists.MarkdownListIndentBackspaceHandlerDelegate"
                              order="before SmartIndentingBackspaceHandler"/>

    <editorActionHandler action="EditorTab" implementationClass="org.intellij.plugins.markdown.editor.lists.MarkdownListItemTabHandler"/>
    <editorActionHandler action="EditorIndentSelection"
                         implementationClass="org.intellij.plugins.markdown.editor.lists.MarkdownListItemTabHandler"/>
    <editorActionHandler action="EditorUnindentSelection"
                         implementationClass="org.intellij.plugins.markdown.editor.lists.MarkdownListItemUnindentHandler"/>

    <actionPromoter implementation="org.intellij.plugins.markdown.ui.actions.MarkdownActionPromoter"/>

    <langCodeStyleSettingsProvider implementation="org.intellij.plugins.markdown.lang.formatter.settings.MarkdownCodeStyleSettingsProvider"/>
    <lang.formatter language="Markdown" implementationClass="org.intellij.plugins.markdown.lang.formatter.MarkdownFormattingModelBuilder"/>
    <postFormatProcessor implementation="org.intellij.plugins.markdown.lang.formatter.BlockQuotePostFormatProcessor"/>
    <lang.lineWrapStrategy language="Markdown" implementationClass="org.intellij.plugins.markdown.editor.MarkdownLineWrapPositionStrategy"/>

    <lang.commenter language="Markdown" implementationClass="org.intellij.plugins.markdown.lang.MarkdownCommenter"/>

    <codeInsight.lineMarkerProvider language="Markdown"
                                    implementationClass="org.intellij.plugins.markdown.extensions.common.plantuml.PlantUMLCodeFenceDownloadLineMarkerProvider"/>
    <codeInsight.lineMarkerProvider language="Markdown"
                                    implementationClass="org.intellij.plugins.markdown.extensions.jcef.mermaid.MermaidCodeFenceDownloadLineMarkerProvider"/>
    <codeInsight.lineMarkerProvider language="Markdown"
                                    implementationClass="org.intellij.plugins.markdown.editor.images.ConfigureMarkdownImageLineMarkerProvider"/>
    <codeInsight.lineMarkerProvider language="HTML"
                                    implementationClass="org.intellij.plugins.markdown.editor.images.ConfigureHtmlImageLineMarkerProvider"/>
    <codeInsight.lineMarkerProvider language="Markdown"
                                    implementationClass="org.intellij.plugins.markdown.editor.images.ConfigureTextHtmlImageLineMarkerProvider"/>

    <intentionAction>
      <className>org.intellij.plugins.markdown.injection.MarkdownCodeFenceErrorHighlightingIntention</className>
      <bundleName>messages.MarkdownBundle</bundleName>
      <categoryKey>markdown.intention.category</categoryKey>
    </intentionAction>
    <intentionAction>
      <className>org.intellij.plugins.markdown.editor.images.MarkdownConfigureImageIntention</className>
      <bundleName>messages.MarkdownBundle</bundleName>
      <categoryKey>markdown.intention.category</categoryKey>
    </intentionAction>

    <notificationGroup id="Markdown" displayType="BALLOON"/>

    <registryKey key="markdown.clear.cache.interval"
                 defaultValue="600000"
                 description="Interval in milliseconds defining how often Markdown plugin caches (e.g. PlantUML diagrams) should be cleared"/>
    <registryKey key="markdown.plantuml.download.link"
                 defaultValue="https://download.jetbrains.com/grazie/markdown/extensions/plantuml/plantuml-1.2021.12-3.jar"
                 description="Link which Markdown plugin will use to download PlantUML JAR"/>
    <registryKey key="markdown.mermaid.download.link"
                 defaultValue="https://download.jetbrains.com/grazie/markdown/extensions/mermaid/mermaid-8.13.6-4.js"
                 description="Link which Markdown plugin will use to download Mermaid.js library"/>
    <registryKey key="markdown.open.link.in.external.browser"
                 defaultValue="true"
                 description="Open Markdown link in an external browser (otherwise open in the IDE viewer)"/>
    <registryKey key="markdown.formatter.apply.to.code.fence"
                 defaultValue="false"
                 description="Should Markdown use injected languages' formatters to format code-fences"/>
    <registryKey key="markdown.mermaid.theme"
                 defaultValue="follow-ide"
                 description="Theme name to be used for Mermaid.js diagrams (set to 'follow-ide' to let the IDE decide)"/>
    <registryKey key="markdown.structure.view.list.visibility"
                 defaultValue="false"
                 description="Determines whether lists are visible in the document structure view"/>

    <registryKey key="markdown.google.docs.import.paste.link.enable"
                 defaultValue="false"
                 description="Temporarily disabling the ability to import documents from Google by inserting a link"/>

    <registryKey key="markdown.google.docs.import.action.enable"
                 defaultValue="false"
                 description="Temporarily disable the action of the import docs from google"/>

    <registryKey key="markdown.tables.editing.support.enable"
                 defaultValue="true"
                 description="Enables Markdown tables editing support"/>

    <registryKey key="markdown.experimental.boundary.precise.scroll.enable"
                 defaultValue="false"
                 description="Enables precise scrolling on the document boundaries (direct passing of scroll events from IDE to JCEF preview). Any opened Markdown editors should be manually reopened."/>
    <registryKey key="markdown.experimental.boundary.precise.scroll.multiplier"
                 defaultValue="8"
                 description="A multiplier used in translation of awt scroll event to the browser one"/>

    <advancedSetting id="markdown.hide.floating.toolbar" default="false" groupKey="markdown.settings.name"/>
  </extensions>

  <applicationListeners>
    <listener topic="com.intellij.ide.ui.LafManagerListener"
              class="org.intellij.plugins.markdown.settings.MarkdownLafListener"/>
  </applicationListeners>

  <projectListeners>
    <listener topic="org.intellij.plugins.markdown.settings.MarkdownSettings$ChangeListener"
              class="org.intellij.plugins.markdown.injection.MarkdownCodeFenceErrorHighlightingIntention$CodeAnalyzerRestartListener"/>
  </projectListeners>

  <extensions defaultExtensionNs="org.intellij.markdown">

    <fenceLanguageProvider implementation="org.intellij.plugins.markdown.extensions.common.plantuml.PlantUMLCodeFenceLanguageProvider"/>

    <fenceGeneratingProvider implementation="org.intellij.plugins.markdown.extensions.common.plantuml.PlantUMLCodeGeneratingProvider"/>

    <fenceGeneratingProvider implementation="org.intellij.plugins.markdown.extensions.common.highlighter.MarkdownCodeFencePreviewHighlighter"/>
    <browserPreviewExtensionProvider implementation="org.intellij.plugins.markdown.extensions.common.BaseStylesExtension$Provider"/>
    <browserPreviewExtensionProvider implementation="org.intellij.plugins.markdown.extensions.common.InlineStylesExtension$Provider"/>

    <browserPreviewExtensionProvider implementation="org.intellij.plugins.markdown.extensions.jcef.ProcessLinksExtension$Provider"/>
    <browserPreviewExtensionProvider implementation="org.intellij.plugins.markdown.extensions.jcef.commandRunner.CommandRunnerExtension$Provider"/>

    <fenceLanguageProvider implementation="org.intellij.plugins.markdown.extensions.jcef.mermaid.MermaidCodeFenceLanguageProvider"/>
    <browserPreviewExtensionProvider implementation="org.intellij.plugins.markdown.extensions.jcef.mermaid.MermaidBrowserExtension$Provider"/>

    <fenceGeneratingProvider implementation="org.intellij.plugins.markdown.extensions.jcef.mermaid.MermaidCodeGeneratingProviderExtension"/>

    <browserPreviewExtensionProvider implementation="org.intellij.plugins.markdown.extensions.common.highlighter.CodeFenceCopyButtonBrowserExtension$Provider"/>

    <markdownExportProvider implementation="org.intellij.plugins.markdown.fileActions.export.MarkdownDocxExportProvider"/>

    <markdownExportProvider implementation="org.intellij.plugins.markdown.fileActions.export.MarkdownPdfExportProvider"/>

    <markdownExportProvider implementation="org.intellij.plugins.markdown.fileActions.export.MarkdownHtmlExportProvider"/>
  </extensions>

  <actions>
    <group id="Markdown.TableActions" compact="true" class="org.intellij.plugins.markdown.editor.tables.actions.TableActionsGroup">
      <group id="Markdown.TableColumnActions" compact="true">
        <action id="Markdown.Table.SwapColumns.SwapWithLeftColumn"
                class="org.intellij.plugins.markdown.editor.tables.actions.column.SwapColumnsAction$SwapWithLeftColumn"
                icon="AllIcons.Actions.Back"/>
        <action id="Markdown.Table.SwapColumns.SwapWithRightColumn"
                class="org.intellij.plugins.markdown.editor.tables.actions.column.SwapColumnsAction$SwapWithRightColumn"
                icon="AllIcons.Actions.Forward"/>
        <separator/>
        <action id="Markdown.Table.InsertTableColumn.InsertBefore"
                class="org.intellij.plugins.markdown.editor.tables.actions.column.InsertTableColumnAction$InsertBefore"
                icon="org.intellij.plugins.markdown.MarkdownIcons.EditorActions.AddColumnLeft"/>
        <action id="Markdown.Table.InsertTableColumn.InsertAfter"
                class="org.intellij.plugins.markdown.editor.tables.actions.column.InsertTableColumnAction$InsertAfter"
                icon="org.intellij.plugins.markdown.MarkdownIcons.EditorActions.AddColumnRight"/>
        <separator/>
        <action id="Markdown.Table.SelectCurrentColumn.SelectContentCells"
                class="org.intellij.plugins.markdown.editor.tables.actions.column.SelectCurrentColumnAction$SelectContentCells"
                icon="AllIcons.Actions.InSelection"/>
        <separator/>

        <group id="Markdown.Table.ColumnAlignmentActions"
               compact="true"
               class="org.intellij.plugins.markdown.editor.tables.actions.column.TableColumnAlignmentActionsGroup">

          <action id="Markdown.Table.SetColumnAlignment.Left"
                  class="org.intellij.plugins.markdown.editor.tables.actions.column.SetColumnAlignmentAction$Left"
                  icon="org.intellij.plugins.markdown.MarkdownIcons.EditorActions.LeftAlign"/>
          <action id="Markdown.Table.SetColumnAlignment.Center"
                  class="org.intellij.plugins.markdown.editor.tables.actions.column.SetColumnAlignmentAction$Center"
                  icon="org.intellij.plugins.markdown.MarkdownIcons.EditorActions.CenterAlign"/>
          <action id="Markdown.Table.SetColumnAlignment.Right"
                  class="org.intellij.plugins.markdown.editor.tables.actions.column.SetColumnAlignmentAction$Right"
                  icon="org.intellij.plugins.markdown.MarkdownIcons.EditorActions.RightAlign"/>
        </group>
        <separator/>
        <action id="Markdown.Table.RemoveCurrentColumn"
                class="org.intellij.plugins.markdown.editor.tables.actions.column.RemoveCurrentColumnAction"
                icon="AllIcons.Actions.GC"/>
      </group>
      <group id="Markdown.TableRowActions" compact="true">
        <action id="Markdown.Table.SwapRows.SwapWithAbove"
                class="org.intellij.plugins.markdown.editor.tables.actions.row.SwapRowsAction$SwapWithAbove"
                icon="AllIcons.Actions.PreviousOccurence"/>
        <action id="Markdown.Table.SwapRows.SwapWithBelow"
                class="org.intellij.plugins.markdown.editor.tables.actions.row.SwapRowsAction$SwapWithBelow"
                icon="AllIcons.Actions.NextOccurence"/>
        <separator/>
        <action id="Markdown.Table.InsertRow.InsertAbove"
                class="org.intellij.plugins.markdown.editor.tables.actions.row.InsertRowAction$InsertAbove"
                icon="org.intellij.plugins.markdown.MarkdownIcons.EditorActions.AddRowAbove"/>
        <action id="Markdown.Table.InsertRow.InsertBelow"
                class="org.intellij.plugins.markdown.editor.tables.actions.row.InsertRowAction$InsertBelow"
                icon="org.intellij.plugins.markdown.MarkdownIcons.EditorActions.AddRowBelow"/>
        <separator/>
        <action id="Markdown.Table.SelectRow"
                class="org.intellij.plugins.markdown.editor.tables.actions.row.SelectRowAction"
                icon="AllIcons.Actions.InSelection"/>
        <separator/>
        <action id="Markdown.Table.RemoveCurrentRow"
                class="org.intellij.plugins.markdown.editor.tables.actions.row.RemoveCurrentRowAction"
                icon="AllIcons.Actions.GC"/>
      </group>

      <group id="Markdown.TableContextMenuGroup"
             class="com.intellij.ide.actions.NonTrivialActionGroup"
             popup="true"
             compact="true">
        <reference id="Markdown.Table.InsertTableColumn.InsertBefore"/>
        <reference id="Markdown.Table.InsertTableColumn.InsertAfter"/>
        <reference id="Markdown.Table.InsertRow.InsertAbove"/>
        <reference id="Markdown.Table.InsertRow.InsertBelow"/>
        <separator/>
        <group id="Markdown.TableColumnActions.ColumnAlignmentActions.Popup"
               class="com.intellij.ide.actions.NonTrivialActionGroup"
               popup="true"
               compact="true">
          <reference id="Markdown.Table.ColumnAlignmentActions"/>
        </group>
        <reference id="Markdown.Table.SwapColumns.SwapWithLeftColumn"/>
        <reference id="Markdown.Table.SwapColumns.SwapWithRightColumn"/>
        <separator/>
        <reference id="Markdown.Table.RemoveCurrentColumn"/>
        <reference id="Markdown.Table.RemoveCurrentRow"/>
      </group>
    </group>

    <group id="Markdown.Toolbar.Floating" class="com.intellij.openapi.actionSystem.DefaultActionGroup">
      <action class="org.intellij.plugins.markdown.ui.actions.styling.ToggleBoldAction"
              id="org.intellij.plugins.markdown.ui.actions.styling.ToggleBoldAction"
              icon="org.intellij.plugins.markdown.MarkdownIcons.EditorActions.Bold">
        <keyboard-shortcut first-keystroke="control B" keymap="$default"/>
      </action>

      <action class="org.intellij.plugins.markdown.ui.actions.styling.ToggleItalicAction"
              id="org.intellij.plugins.markdown.ui.actions.styling.ToggleItalicAction"
              icon="org.intellij.plugins.markdown.MarkdownIcons.EditorActions.Italic">
        <keyboard-shortcut first-keystroke="control I" keymap="$default"/>
      </action>

      <action class="org.intellij.plugins.markdown.ui.actions.styling.ToggleStrikethroughAction"
              id="org.intellij.plugins.markdown.ui.actions.styling.ToggleStrikethroughAction"
              icon="org.intellij.plugins.markdown.MarkdownIcons.EditorActions.Strike_through">
        <keyboard-shortcut first-keystroke="control shift S" keymap="$default"/>
      </action>

      <action class="org.intellij.plugins.markdown.ui.actions.styling.ToggleCodeSpanAction"
              id="org.intellij.plugins.markdown.ui.actions.styling.ToggleCodeSpanAction"
              icon="org.intellij.plugins.markdown.MarkdownIcons.EditorActions.Code_span">
        <keyboard-shortcut first-keystroke="control shift C" keymap="$default"/>
      </action>

      <separator/>

      <action class="org.intellij.plugins.markdown.ui.actions.styling.HeaderDownAction"
              id="org.intellij.plugins.markdown.ui.actions.styling.HeaderDownAction"
              icon="org.intellij.plugins.markdown.MarkdownIcons.EditorActions.Header_level_down">
      </action>

      <action class="org.intellij.plugins.markdown.ui.actions.styling.HeaderUpAction"
              id="org.intellij.plugins.markdown.ui.actions.styling.HeaderUpAction"
              icon="org.intellij.plugins.markdown.MarkdownIcons.EditorActions.Header_level_up">
      </action>
    </group>

    <group id="Markdown.InsertGroup">

      <add-to-group group-id="GenerateGroup" anchor="last"/>
      <action class="org.intellij.plugins.markdown.ui.actions.styling.MarkdownCreateLinkAction"
              id="org.intellij.plugins.markdown.ui.actions.styling.MarkdownCreateLinkAction"
              icon="org.intellij.plugins.markdown.MarkdownIcons.EditorActions.Link">
        <keyboard-shortcut first-keystroke="control shift U" keymap="$default"/>
      </action>
      <action id="Markdown.InsertEmptyTable"
              class="org.intellij.plugins.markdown.editor.tables.actions.InsertEmptyTableAction"
              icon="org.intellij.plugins.markdown.MarkdownIcons.EditorActions.Table"/>
      <action class="org.intellij.plugins.markdown.ui.actions.styling.InsertImageAction"
              id="org.intellij.plugins.markdown.ui.actions.styling.InsertImageAction"
              icon="AllIcons.General.LayoutPreviewOnly">
        <keyboard-shortcut first-keystroke="control U" keymap="$default"/>
      </action>
    </group>
    <action id="Markdown.Insert"
            class="org.intellij.plugins.markdown.ui.actions.InsertAction"
            use-shortcut-of="Generate"/>

    <action class="org.intellij.plugins.markdown.ui.actions.styling.MarkdownIntroduceLinkReferenceAction"
            id="org.intellij.plugins.markdown.ui.actions.styling.MarkdownIntroduceLinkReferenceAction"
            icon="org.intellij.plugins.markdown.MarkdownIcons.EditorActions.Link">
    </action>

    <group id="Markdown.EditorContextMenuGroup">
      <add-to-group group-id="EditorPopupMenu" anchor="after" relative-to-action="EditorToggleColumnMode"/>
      <separator/>
      <reference id="Markdown.TableContextMenuGroup"/>
      <reference id="Markdown.Insert"/>
    </group>

    <group id="Markdown.Toolbar.Left" class="com.intellij.openapi.actionSystem.DefaultActionGroup">
    </group>

    <group id="Markdown.Toolbar.Right" class="com.intellij.openapi.actionSystem.DefaultActionGroup">
      <action class="org.intellij.plugins.markdown.ui.actions.scrolling.AutoScrollAction"
              id="org.intellij.plugins.markdown.ui.actions.scrolling.AutoScrollAction"
              icon="AllIcons.Actions.SynchronizeScrolling">
      </action>
    </group>

    <group id="Markdown.Tools" popup="true">
      <add-to-group group-id="ToolsMenu" anchor="before" relative-to-action="ExternalToolsGroup"/>
      <action id="org.intellij.plugins.markdown.fileActions.importFrom.docx.MarkdownImportFromDocxAction"
              class="org.intellij.plugins.markdown.fileActions.importFrom.docx.MarkdownImportFromDocxAction"/>
      <action id="org.intellij.plugins.markdown.fileActions.importFrom.googleDocs.GoogleDocsImportAction"
              class="org.intellij.plugins.markdown.fileActions.importFrom.googleDocs.GoogleDocsImportAction"/>
      <action id="org.intellij.plugins.markdown.fileActions.export.MarkdownExportAction"
              class="org.intellij.plugins.markdown.fileActions.export.MarkdownExportAction"/>
      <action id="org.intellij.plugins.markdown.ui.actions.ConfigurePandocAction"
              class="org.intellij.plugins.markdown.ui.actions.ConfigurePandocAction"/>
    </group>
    <action id="Markdown.OpenDevtoolsAction"
            class="org.intellij.plugins.markdown.ui.actions.MarkdownOpenDevtoolsAction"/>
    <action id="Markdown.Extensions.CleanupExternalFiles"
            class="org.intellij.plugins.markdown.extensions.CleanupExtensionsExternalFilesAction"
            icon="AllIcons.Actions.GC"/>

    <action id="Markdown.Layout.EditorOnly" class="org.intellij.plugins.markdown.ui.actions.ChangePreviewLayoutAction$EditorOnly"/>
    <action id="Markdown.Layout.EditorAndPreview" class="org.intellij.plugins.markdown.ui.actions.ChangePreviewLayoutAction$EditorAndPreview"/>
    <action id="Markdown.Layout.PreviewOnly" class="org.intellij.plugins.markdown.ui.actions.ChangePreviewLayoutAction$PreviewOnly"/>
  </actions>
</idea-plugin>


text:
#region Copyright

#endregion

#region

using Autodesk.DesignScript.Runtime;
using Dynamo.Models;
using System.Collections.Generic;
using Dynamo.Nodes;
using Dynamo.Graph.Nodes;

#endregion

namespace Wood.NDS
{

    /// <summary>
    ///     AdjustmentFactor
    ///     Category:   Wood.NDS
    /// </summary>
    ///

    [IsDesignScriptCompatible]
    public partial class AdjustmentFactor
    {

        internal AdjustmentFactor()
        {

        }
        [IsVisibleInDynamoLibrary(false)]
        public static AdjustmentFactor ByInputParameters()
        {
            return new AdjustmentFactor();
        }

    }
}

redpajama_set_name: RedPajamaGithub


text:
module CTT::Cli
  class CliError < StandardError
    attr_reader :exit_code

    def initialize(*args)
      @exit_code = 1
      super(*args)
    end

    def self.error_code(code = nil)
      define_method(:error_code) { code }
    end

    def self.exit_code(code = nil)
      define_method(:exit_code) { code }
    end

    error_code(42)
  end

  class UnknownCommand       < CliError; error_code(100); end

end


text:
<!---
  category: Gaming
  samplefwlink: http://go.microsoft.com/fwlink/p/?LinkId=620598
--->

# Direct3D game sample

This sample demonstrates the basic end-to-end implementation of a simple first person 3-D game using DirectX (Direct3D 11.2, Direct2D, Windows.Gaming.Input, and XAudio2) in a C++ app.

Specifically, this sample supports:

- A touch input model
- A mouse and keyboard input model
- A game controller input model
- Stereoscopic 3-D display
- A Direct2D heads-up display
- A persistent game state
- Sound effect playback

There are two versions of this sample:

- **Simple3DGameDX**: Uses DirectX to render game UI and implements its own layout.
- **Simple3DGameXaml**: Uses XAML to render game UI and handle layout.

Both versions share significant amounts of logic: the Common and GameContent folders are identical. In addition, to reduce disk space usage, Simple3DGameXaml references some its assets from the Simple3DGameDX\Cpp\Assets folder.

**Note** The Windows universal samples require Visual Studio 2015 to build and Windows 10 to execute.

To obtain information about Windows 10 development, go to the [Windows Dev Center](http://go.microsoft.com/fwlink/?LinkID=532421)

To obtain information about Microsoft Visual Studio 2015 and the tools for developing Windows apps, go to [Visual Studio 2015](http://go.microsoft.com/fwlink/?LinkID=532422)

## Reference

This sample is written in C++ and requires some experience with graphics programming. A code walkthrough for this sample is available here:

- [Create a simple  game with DirectX](https://msdn.microsoft.com/library/windows/apps/mt210793)

These topics provide info about the APIs used in this sample:

- [DirectX Graphics and Gaming](http://msdn.microsoft.com/library/windows/apps/ee663274)
- [Direct3D 11 Overview](http://msdn.microsoft.com/library/windows/apps/ff476345)
- [Direct3D 11 Reference](http://msdn.microsoft.com/library/windows/apps/ff476147)
- [DXGI reference](http://msdn.microsoft.com/library/windows/apps/bb205169)
- [XAudio2](http://msdn.microsoft.com/library/windows/apps/hh405049)
- [Windows.Gaming.Input](https://msdn.microsoft.com/library/windows/apps/windows.gaming.input.aspx)

## See also

[DirectX marble maze game sample](https://github.com/Microsoft/Windows-appsample-marble-maze)

## System requirements

**Client:** Windows 10

**Server:** Windows Server 2016 Technical Preview

**Phone:** Windows 10

## Build the sample

1. If you download the samples ZIP, be sure to unzip the entire archive, not just the folder with the sample you want to build.
2. Start Microsoft Visual Studio 2015 and select **File** \> **Open** \> **Project/Solution**.
3. Starting in the folder where you unzipped the samples, go to the Samples subfolder, then the subfolder for this specific sample, then the subfolder for your preferred language (C++, C#, or JavaScript). Double-click the Visual Studio 2015 Solution (.sln) file.
4. Press Ctrl+Shift+B, or select **Build** \> **Build Solution**.

## Run the sample

The next steps depend on whether you just want to deploy the sample or you want to both deploy and run it.

### Deploying the sample

- Select Build > Deploy Solution.

### Deploying and running the sample

- To debug the sample and then run it, press F5 or select Debug >  Start Debugging. To run the sample without debugging, press Ctrl+F5 or selectDebug > Start Without Debugging.


text:
require 'marshal_socket/version'

require 'socket'

module MarshalSocket

  module Socket
    def dump(obj)
      write_lock.synchronize do
        Marshal.dump([:obj, obj], self)
      end
    end

    def load
      read_lock.synchronize do
        Marshal.load(self)
      end
    end

    def bye
      write_lock.synchronize do
        Marshal.dump([:bye], self)
      end
    end

    def write_lock
      @write_lock = Mutex.new
    end

    def read_lock
      @read_lock = Mutex.new
    end

    def receive_objects(&block)
      run = true

      while run do
        begin
          msg_type, obj = load
        rescue EOFError
          run = false
          next
        end

        case msg_type
        when :bye
          run = false
          close
        when :obj
          block.call(self, obj)
        else
          $stderr.puts "unknown message type #{msg_type.inspect}"
        end

      end

    end
  end

  class TCPServer < ::TCPServer
    def accept
      super.tap do |socket|
        socket.extend(Socket)
      end
    end
  end

  class TCPSocket < ::TCPSocket
    include Socket
  end

end


text:
package edu.rosehulman.serg.smellbuster.gui;

import java.awt.event.MouseAdapter;
import java.awt.event.MouseEvent;
import java.io.File;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;

import javax.swing.JOptionPane;

import org.apache.commons.io.FileUtils;

import edu.rosehulman.serg.smellbuster.util.MetricDOMObject;

public class TableCellMouseListener extends MouseAdapter {

	private ResultTableGUI resultTableGUI;

	public TableCellMouseListener(ResultTableGUI resultTableGUI) {
		this.resultTableGUI = resultTableGUI;
	}

	public void mouseClicked(MouseEvent e) {

		int row = this.resultTableGUI.getTable().getSelectedRow();
		int column = this.resultTableGUI.getTable().getSelectedColumn();

		final String title = "Metric Detail info";
		final String version = this.resultTableGUI.getColumnNames()[column];
		final String className = this.resultTableGUI.getDataValues()[row][column];
		if (className != null && className.length() > 0) {
			final String message = this.resultTableGUI.getMetricGUI()
					.getDisplayMessage(version, className);
			final String[] options = new String[] { "Ok", "Display Graph",
					"Recommendations" };
			int selectedOption = JOptionPane.showOptionDialog(null, message,
					title, JOptionPane.DEFAULT_OPTION,
					JOptionPane.PLAIN_MESSAGE, null, options, options[0]);
			switch (selectedOption) {
			case 1:
				ArrayList<MetricDOMObject> classList = this.resultTableGUI
						.getResultTableLogic().createClassListMap(className);
				LineChartGUI chart = new LineChartGUI(className, classList,
						this.resultTableGUI.getVersionMap().keySet());
				chart.setSize(500, 500);
				chart.setVisible(true);
				break;
			case 2:
				String filePath = this.getFilePathFor(className, version);
				RecommendationDisplayerGUI recommendGUI = new RecommendationDisplayerGUI(
						filePath, className);
				recommendGUI.setVisible(true);
				break;
			default:
				break;
			}
		}
	}

	@SuppressWarnings("rawtypes")
	private String getFilePathFor(String className, String version) {
		String location = System.getProperty("user.dir") + File.separator
				+ "repo" + File.separator
				+ this.resultTableGUI.getProjectName() + File.separator
				+ this.resultTableGUI.getRevisionNumberForVersion(version);
		File root = new File(location);
		try {
			boolean recursive = true;

			Collection files = FileUtils.listFiles(root, null, recursive);

			for (Iterator iterator = files.iterator(); iterator.hasNext();) {
				File file = (File) iterator.next();
				if (file.isDirectory()
						&& (file.getName().equalsIgnoreCase("src") || file
								.getName().equalsIgnoreCase("source"))) {
					root = file;
					break;
				}
			}

			files = FileUtils.listFiles(root, null, recursive);
			for (Iterator iterator = files.iterator(); iterator.hasNext();) {
				File file = (File) iterator.next();
				if (file.getName().equalsIgnoreCase(className))
					return file.getAbsolutePath();
			}

		} catch (Exception e) {
			e.printStackTrace();
		}
		return "";
	}
}


text:
/*
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.
 *
 * Copyright (c) 2008-2009, The KiWi Project (http://www.kiwi-project.eu)
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are met:
 * - Redistributions of source code must retain the above copyright notice,
 *   this list of conditions and the following disclaimer.
 * - Redistributions in binary form must reproduce the above copyright notice,
 *   this list of conditions and the following disclaimer in the documentation
 *   and/or other materials provided with the distribution.
 * - Neither the name of the KiWi Project nor the names of its contributors
 *   may be used to endorse or promote products derived from this software
 *   without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
 * POSSIBILITY OF SUCH DAMAGE.
 *
 * Contributor(s):
 *
 *
 */

package kiwi.util;

import java.net.HttpURLConnection;
import java.net.MalformedURLException;
import java.net.URL;
import java.util.StringTokenizer;

public final class URLUtils {

    public static boolean exists(String URLName){
        try {
          HttpURLConnection.setFollowRedirects(false);
          // note : you may also need
          //        HttpURLConnection.setInstanceFollowRedirects(false)
          HttpURLConnection con =
             (HttpURLConnection) new URL(URLName).openConnection();
          con.setRequestMethod("HEAD");
          //return (con.getResponseCode() == HttpURLConnection.HTTP_OK);
          boolean exist = (!(""+con.getResponseCode()).trim().startsWith("5") || !(""+con.getResponseCode()).trim().startsWith("4"));
          return exist;
        }
        catch (Exception e) {
           e.printStackTrace();
           return false;
        }
      }

	/**
	 * @param url
	 * @return
	 */
	public static String getURLName(String url){
				try {
					if(!url.contains("http://")){
						url = "http://"+url;
					}
					url = new URL(url).getHost();
				} catch (MalformedURLException e) {
					e.printStackTrace();
				}
				int index = 0;
				if(url.contains("www")){
					index = 1;
				}
				StringTokenizer tempStringTokenizer = new StringTokenizer(url,".");
		        int i = 0;
		        String term = null;
				while (tempStringTokenizer.hasMoreTokens()) {
					term = tempStringTokenizer.nextElement().toString();
		        	if(i==index){
		        		break;
		        	}
		        	i++;
		        }

		return term;
	}

}


text:
import Ember from 'ember';
import NbThemedComponentMixin from 'nullbase-theme-service/mixins/nb-themed-component';
import { module, test } from 'qunit';

module('Unit | Mixin | nb themed component');

// Replace this with your real tests.
test('it works', function(assert) {
  let NbThemedComponentObject = Ember.Object.extend(NbThemedComponentMixin);
  let subject = NbThemedComponentObject.create();
  assert.ok(subject);
});


text:
package no.stelar7.api.r4j.pojo.lol.liveclient;

import java.util.ArrayList;

public class ActiveGameItemList extends ArrayList<ActiveGameItem>
{
}


text:
'use strict';
exports.test = function () {
  // Don't get fooled by e.g. browserify environments.
  return (typeof process !== 'undefined') && !process.browser;
};

exports.install = function (func) {
  return function () {
    process.nextTick(func);
  };
};


text:
ACCEPTED

#### According to
Index Fungorum

#### Published in
Beih. Sydowia 2: 339 (1961)

#### Original name
Meliola speciosa Doidge

### Remarks
null


text:
package me.selinali.tribbble.ui;

import android.os.Bundle;
import android.support.annotation.Nullable;
import android.support.v4.app.Fragment;
import android.support.v4.app.FragmentManager;
import android.support.v7.app.AppCompatActivity;
import android.view.View;
import android.view.animation.AlphaAnimation;
import android.view.animation.Animation;

import com.crashlytics.android.answers.Answers;
import com.crashlytics.android.answers.CustomEvent;

import java.util.HashMap;
import java.util.Map;

import butterknife.BindView;
import butterknife.ButterKnife;
import me.selinali.tribbble.R;
import me.selinali.tribbble.model.Shot;
import me.selinali.tribbble.ui.archive.ArchiveFragment;
import me.selinali.tribbble.ui.common.BinaryBar;
import me.selinali.tribbble.ui.common.BinaryBar.Item;
import me.selinali.tribbble.ui.deck.DeckFragment;
import me.selinali.tribbble.utils.ViewUtils;

public class MainActivity extends AppCompatActivity {

  private static final String TAG_DECK_FRAGMENT = "TAG_DECK_FRAGMENT";
  private static final String TAG_ARCHIVE_FRAGMENT = "TAG_ARCHIVE_FRAGMENT";

  @BindView(R.id.container) View mContainer;
  @BindView(R.id.binary_bar) BinaryBar mBinaryBar;

  private final Map<String, Fragment> mFragments = new HashMap<>(2);
  private final Animation mAnimation = new AlphaAnimation(0, 1);
  private final Item mLeftItem = new Item(R.string.deck, R.drawable.ic_deck, v -> {
    Answers.getInstance().logCustom(new CustomEvent("Deck clicked"));
    swapFragment(TAG_DECK_FRAGMENT);
  });
  private final Item mRightItem = new Item(R.string.archive, R.drawable.ic_archive, v -> {
    Answers.getInstance().logCustom(new CustomEvent("Archive clicked"));
    swapFragment(TAG_ARCHIVE_FRAGMENT);
  });

  {
    mAnimation.setDuration(200);
  }

  @Override
  protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    setContentView(R.layout.activity_main);
    ButterKnife.bind(this);
    getWindow().getDecorView().setSystemUiVisibility(View.SYSTEM_UI_FLAG_LAYOUT_FULLSCREEN |
        View.SYSTEM_UI_FLAG_LAYOUT_HIDE_NAVIGATION);
    setupMargins();

    mFragments.put(TAG_DECK_FRAGMENT, DeckFragment.newInstance());
    mFragments.put(TAG_ARCHIVE_FRAGMENT, ArchiveFragment.newInstance());

    swapFragment(TAG_DECK_FRAGMENT);
    mBinaryBar.addItems(mLeftItem, mRightItem);
  }

  private void swapFragment(String tag) {
    FragmentManager manager = getSupportFragmentManager();
    Fragment targetFragment = manager.findFragmentByTag(tag);
    if (targetFragment != null && targetFragment.isVisible()) {
      return;
    }

    mContainer.setAnimation(mAnimation);
    mAnimation.start();

    String otherTag = tag.equals(TAG_DECK_FRAGMENT) ? TAG_ARCHIVE_FRAGMENT : TAG_DECK_FRAGMENT;
    if (manager.findFragmentByTag(tag) != null) {
      manager.beginTransaction()
          .show(manager.findFragmentByTag(tag))
          .commit();
    } else {
      manager.beginTransaction()
          .add(R.id.container, mFragments.get(tag), tag)
          .commit();
    }
    if (manager.findFragmentByTag(otherTag) != null) {
      manager.beginTransaction()
          .hide(manager.findFragmentByTag(otherTag))
          .commit();
    }
    if (tag.equals(TAG_DECK_FRAGMENT)) showBottomBar(true);
  }

  @Nullable private String getVisibleFragmentTag() {
    FragmentManager manager = getSupportFragmentManager();
    Fragment fragment = manager.findFragmentByTag(TAG_DECK_FRAGMENT);
    if (fragment != null && fragment.isVisible()) {
      return TAG_DECK_FRAGMENT;
    } else if ((fragment = manager.findFragmentByTag(TAG_ARCHIVE_FRAGMENT)) != null &&
        fragment.isVisible()) {
      return TAG_ARCHIVE_FRAGMENT;
    } else {
      return null;
    }
  }

  @Override public void onBackPressed() {
    String visibleFragmentTag = getVisibleFragmentTag();
    if (visibleFragmentTag == null || visibleFragmentTag.equals(TAG_DECK_FRAGMENT)) {
      super.onBackPressed();
    } else {
      mBinaryBar.click(BinaryBar.LEFT);
    }
  }

  private void setupMargins() {
    int navigationBarHeight = ViewUtils.getNavigationBarHeight();
    ViewUtils.setBottomMargin(mBinaryBar, navigationBarHeight + ViewUtils.dpToPx(16));
  }

  public void showBottomBar(boolean show) {
    ViewUtils.fadeView(mBinaryBar, show, 150);
  }

  public void notifyShotArchived(Shot shot) {
    if (getSupportFragmentManager().findFragmentByTag(TAG_ARCHIVE_FRAGMENT) != null) {
      ((ArchiveFragment) mFragments.get(TAG_ARCHIVE_FRAGMENT)).insertFirst(shot);
    }
  }
}


text: Small app to serve as inventory


text:
import React from 'react';
import {INPUT, Fade} from '../../_themes/text.style';
import {DIV, H1} from './input.style';
import firebase from 'firebase';

class TaskInput extends React.Component {
    constructor(props){
        super(props);
        this.state = {
            task: null,
            new_task: null,
        }
        this.handleSubmit = this.handleSubmit.bind(this);
        this.handleChange = this.handleChange.bind(this);
    }
    // componentWillReceiveProps() {
    //     this.setState({
    //         task: this.props.task
    //     });
    // }
    handleSubmit(e){
        e.preventDefault(e);
        let user_id = this.props.userid;
        let db_task = this.state.new_task;
        firebase.database().ref("users/" + user_id + '/').update({day_task: db_task});
    }
    handleChange(e){
        this.setState({
            new_task: e.target.value
        })
    }
    render(){
        return(

Set a task for the day.

                <Fade>
                    <form onSubmit={this.handleSubmit}>
                        <INPUT type="text" onChange={this.handleChange}/>
                    </form>
                </Fade>

        );
    }
}
export default TaskInput;


text:
package org.jnbis.internal;

import org.jnbis.api.model.Nist;
import org.jnbis.api.model.record.*;
import org.jnbis.internal.record.BaseRecord;
import org.jnbis.internal.record.reader.RecordReaderFactory;

/**
 * @author hamed
 * @version 1.0
 * @since Apr 29, 2007
 */
public class NistDecoder {
    private RecordReaderFactory readerFactory;

    public NistDecoder() {
        readerFactory = new RecordReaderFactory();
    }

    public Nist decode(byte[] nist) {
        if (nist == null || nist.length == 0) {
            throw new IllegalArgumentException("data is null or zero length");
        }

        NistHelper.Token token = new NistHelper.Token(nist);
        InternalNist decoded = new InternalNist();
        BaseRecord record = readerFactory.read(token);
        decoded.setTransactionInfo((TransactionInformation) record);

        while (nextRecord(token)) {
            if (token.crt < 2) {
                continue;
            }
            record = readerFactory.read(token);

            if (record instanceof UserDefinedDescriptiveText) {
                decoded.addUserDefinedText((UserDefinedDescriptiveText) record);

            } else if (record instanceof LowResolutionGrayscaleFingerprint) {
                decoded.addLowResGrayscaleFingerPrint((LowResolutionGrayscaleFingerprint) record);

            } else if (record instanceof HighResolutionGrayscaleFingerprint) {
                decoded.addHiResGrayscaleFingerPrint((HighResolutionGrayscaleFingerprint) record);

            } else if (record instanceof LowResolutionBinaryFingerprint) {
                decoded.addLowResBinaryFingerPrint((LowResolutionBinaryFingerprint) record);

            } else if (record instanceof HighResolutionBinaryFingerprint) {
                decoded.addHiResBinaryFingerPrint((HighResolutionBinaryFingerprint) record);

            } else if (record instanceof UserDefinedImage) {
                decoded.addUserDefinedImage((UserDefinedImage) record);

            } else if (record instanceof SignatureImage) {
                decoded.addSignature((SignatureImage) record);

            } else if (record instanceof MinutiaeData) {
                //readMinutiaeData(token, decoded);
                decoded.addMinutiaeData((MinutiaeData) record);

            } else if (record instanceof FacialAndSmtImage) {
                decoded.addFacialSmtImage((FacialAndSmtImage) record);

            } else if (record instanceof VariableResolutionLatentImage) {
                decoded.addVariableResLatentImage((VariableResolutionLatentImage) record);

            } else if (record instanceof VariableResolutionFingerprint) {
                decoded.addVariableResFingerprint((VariableResolutionFingerprint) record);

            } else if (record instanceof VariableResolutionPalmprint) {
                decoded.addVariableResPalmprint((VariableResolutionPalmprint) record);

            } else if (record instanceof UserDefinedTestingImage) {
                decoded.addUserDefinedTestingImage((UserDefinedTestingImage) record);

            } else if (record instanceof IrisImage) {
                decoded.addIrisImage((IrisImage) record);
            }
        }

        return decoded;
    }

    private boolean nextRecord(NistHelper.Token token) {
        if (token.header.length() == 0) {
            return false;
        }

        int rsPos = token.header.indexOf(NistHelper.SEP_RS);
        if (rsPos == -1) {
            rsPos = token.header.length() - 1;
        }

        int usPos = token.header.indexOf(NistHelper.SEP_US);
        token.crt = Integer.parseInt(token.header.substring(0, usPos));
        token.header = token.header.substring(rsPos + 1);

        return true;
    }

}


text:
#include "LIEF/ELF/hash.hpp"

#include "LIEF/ELF/SymbolVersionAuxRequirement.hpp"
#include "ELF/Structures.hpp"

namespace LIEF {
namespace ELF {

SymbolVersionAuxRequirement::SymbolVersionAuxRequirement() = default;

SymbolVersionAuxRequirement::~SymbolVersionAuxRequirement() = default;
SymbolVersionAuxRequirement& SymbolVersionAuxRequirement::operator=(const SymbolVersionAuxRequirement&) = default;
SymbolVersionAuxRequirement::SymbolVersionAuxRequirement(const SymbolVersionAuxRequirement&) = default;

SymbolVersionAuxRequirement::SymbolVersionAuxRequirement(const details::Elf64_Vernaux& header) :
  hash_{header.vna_hash},
  flags_{header.vna_flags},
  other_{header.vna_other}
{}

SymbolVersionAuxRequirement::SymbolVersionAuxRequirement(const details::Elf32_Vernaux& header) :
  hash_{header.vna_hash},
  flags_{header.vna_flags},
  other_{header.vna_other}
{}

uint32_t SymbolVersionAuxRequirement::hash() const {
  return hash_;
}

uint16_t SymbolVersionAuxRequirement::flags() const {
  return flags_;
}

uint16_t SymbolVersionAuxRequirement::other() const {
  return other_;
}

void SymbolVersionAuxRequirement::hash(uint32_t hash) {
  hash_ = hash;
}

void SymbolVersionAuxRequirement::flags(uint16_t flags) {
  flags_ = flags;
}

void SymbolVersionAuxRequirement::other(uint16_t other) {
  other_ = other;
}

void SymbolVersionAuxRequirement::accept(Visitor& visitor) const {
  visitor.visit(*this);
}

bool SymbolVersionAuxRequirement::operator==(const SymbolVersionAuxRequirement& rhs) const {
  if (this == &rhs) {
    return true;
  }
  size_t hash_lhs = Hash::hash(*this);
  size_t hash_rhs = Hash::hash(rhs);
  return hash_lhs == hash_rhs;
}

bool SymbolVersionAuxRequirement::operator!=(const SymbolVersionAuxRequirement& rhs) const {
  return !(*this == rhs);
}

std::ostream& operator<<(std::ostream& os, const SymbolVersionAuxRequirement& symAux) {
  os << symAux.name();
  return os;
}
}
}


text:
namespace ict {

// output string string with 80% functionality and 20X performance over
// std::ostringstream, and easier to spell.
struct osstream {
    osstream() {}
    osstream(const std::string &s) : x(s) {}
    osstream(const osstream &) = delete;
    osstream &operator=(const osstream &) = delete;
    std::string x;
    // Copy the current string
    std::string str() const { return x; }
    // Move the internal string to avoid copying.  The stream is in an undefined
    // state after this.  It is meant to be the last thing you do.  Call clear()
    // after this if you want to use the string again.
    std::string &&take() { return std::move(x); }
    void clear() { x.clear(); }
};

// One weird trick to make sure there are no implicit conversions.
template <typename T> inline osstream &operator<<(osstream &os, T x) = delete;

namespace util {
template <typename S, typename T> S &append(S &os, const T &x) {
    os.x += x;
    return os;
}
template <typename S, typename T> S &append_number(S &os, const T &x) {
    os.x += std::to_string(x);
    return os;
}
} // namespace util

inline osstream &operator<<(osstream &os, char x) {
    return util::append(os, x);
}
inline osstream &operator<<(osstream &os, const std::string &x) {
    return util::append(os, x);
}
inline osstream &operator<<(osstream &os, const char *x) {
    return util::append(os, x);
}
inline osstream &operator<<(osstream &os, int x) {
    return util::append_number(os, x);
}
inline osstream &operator<<(osstream &os, unsigned long int x) {
    return util::append_number(os, x);
}
inline osstream &operator<<(osstream &os, long int x) {
    return util::append_number(os, x);
}
inline osstream &operator<<(osstream &os, long long x) {
    return util::append_number(os, x);
}
#ifdef WIN32
inline osstream &operator<<(osstream &os, size_t x) {
    return util::append_number(os, x);
}
#endif

} // namespace ict


text:
package org.nd4j.linalg.api.memory.pointers;

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;

/**
 * @author raver119@gmail.com
 */
@Data
@NoArgsConstructor
@AllArgsConstructor
public class PointersPair {
    private Long allocationCycle;
    private Long requiredMemory;
    private PagedPointer hostPointer;
    private PagedPointer devicePointer;

    public PointersPair(PagedPointer hostPointer, PagedPointer devicePointer) {
        if (hostPointer == null && devicePointer == null)
            throw new RuntimeException("Both pointers can't be null");

        this.hostPointer = hostPointer;
        this.devicePointer = devicePointer;
    }
}


text:
module Google
  module Cloud
    module Dataplex
      module V1
        # A task represents a user-visible job.
        # @!attribute [r] name
        #   @return [::String]
        #     Output only. The relative resource name of the task, of the form:
        #     projects/\\{project_number}/locations/\\{location_id}/lakes/\\{lake_id}/
        #     tasks/\\{task_id}.
        # @!attribute [r] uid
        #   @return [::String]
        #     Output only. System generated globally unique ID for the task. This ID will be
        #     different if the task is deleted and re-created with the same name.
        # @!attribute [r] create_time
        #   @return [::Google::Protobuf::Timestamp]
        #     Output only. The time when the task was created.
        # @!attribute [r] update_time
        #   @return [::Google::Protobuf::Timestamp]
        #     Output only. The time when the task was last updated.
        # @!attribute [rw] description
        #   @return [::String]
        #     Optional. Description of the task.
        # @!attribute [rw] display_name
        #   @return [::String]
        #     Optional. User friendly display name.
        # @!attribute [r] state
        #   @return [::Google::Cloud::Dataplex::V1::State]
        #     Output only. Current state of the task.
        # @!attribute [rw] labels
        #   @return [::Google::Protobuf::Map{::String => ::String}]
        #     Optional. User-defined labels for the task.
        # @!attribute [rw] trigger_spec
        #   @return [::Google::Cloud::Dataplex::V1::Task::TriggerSpec]
        #     Required. Spec related to how often and when a task should be triggered.
        # @!attribute [rw] execution_spec
        #   @return [::Google::Cloud::Dataplex::V1::Task::ExecutionSpec]
        #     Required. Spec related to how a task is executed.
        # @!attribute [r] execution_status
        #   @return [::Google::Cloud::Dataplex::V1::Task::ExecutionStatus]
        #     Output only. Status of the latest task executions.
        # @!attribute [rw] spark
        #   @return [::Google::Cloud::Dataplex::V1::Task::SparkTaskConfig]
        #     Config related to running custom Spark tasks.
        # @!attribute [rw] notebook
        #   @return [::Google::Cloud::Dataplex::V1::Task::NotebookTaskConfig]
        #     Config related to running scheduled Notebooks.
        class Task
          include ::Google::Protobuf::MessageExts
          extend ::Google::Protobuf::MessageExts::ClassMethods

          # Configuration for the underlying infrastructure used to run workloads.
          # @!attribute [rw] batch
          #   @return [::Google::Cloud::Dataplex::V1::Task::InfrastructureSpec::BatchComputeResources]
          #     Compute resources needed for a Task when using Dataproc Serverless.
          # @!attribute [rw] container_image
          #   @return [::Google::Cloud::Dataplex::V1::Task::InfrastructureSpec::ContainerImageRuntime]
          #     Container Image Runtime Configuration.
          # @!attribute [rw] vpc_network
          #   @return [::Google::Cloud::Dataplex::V1::Task::InfrastructureSpec::VpcNetwork]
          #     Vpc network.
          class InfrastructureSpec
            include ::Google::Protobuf::MessageExts
            extend ::Google::Protobuf::MessageExts::ClassMethods

            # Batch compute resources associated with the task.
            # @!attribute [rw] executors_count
            #   @return [::Integer]
            #     Optional. Total number of job executors.
            #     Executor Count should be between 2 and 100. [Default=2]
            # @!attribute [rw] max_executors_count
            #   @return [::Integer]
            #     Optional. Max configurable executors.
            #     If max_executors_count > executors_count, then auto-scaling is enabled.
            #     Max Executor Count should be between 2 and 1000. [Default=1000]
            class BatchComputeResources
              include ::Google::Protobuf::MessageExts
              extend ::Google::Protobuf::MessageExts::ClassMethods
            end

            # Container Image Runtime Configuration used with Batch execution.
            # @!attribute [rw] image
            #   @return [::String]
            #     Optional. Container image to use.
            # @!attribute [rw] java_jars
            #   @return [::Array<::String>]
            #     Optional. A list of Java JARS to add to the classpath.
            #     Valid input includes Cloud Storage URIs to Jar binaries.
            #     For example, gs://bucket-name/my/path/to/file.jar
            # @!attribute [rw] python_packages
            #   @return [::Array<::String>]
            #     Optional. A list of python packages to be installed.
            #     Valid formats include Cloud Storage URI to a PIP installable library.
            #     For example, gs://bucket-name/my/path/to/lib.tar.gz
            # @!attribute [rw] properties
            #   @return [::Google::Protobuf::Map{::String => ::String}]
            #     Optional. Override to common configuration of open source components installed on
            #     the Dataproc cluster.
            #     The properties to set on daemon config files.
            #     Property keys are specified in `prefix:property` format, for example
            #     `core:hadoop.tmp.dir`.
            #     For more information, see [Cluster
            #     properties](https://cloud.google.com/dataproc/docs/concepts/cluster-properties).
            class ContainerImageRuntime
              include ::Google::Protobuf::MessageExts
              extend ::Google::Protobuf::MessageExts::ClassMethods

              # @!attribute [rw] key
              #   @return [::String]
              # @!attribute [rw] value
              #   @return [::String]
              class PropertiesEntry
                include ::Google::Protobuf::MessageExts
                extend ::Google::Protobuf::MessageExts::ClassMethods
              end
            end

            # Cloud VPC Network used to run the infrastructure.
            # @!attribute [rw] network
            #   @return [::String]
            #     Optional. The Cloud VPC network in which the job is run. By default, the Cloud
            #     VPC network named Default within the project is used.
            # @!attribute [rw] sub_network
            #   @return [::String]
            #     Optional. The Cloud VPC sub-network in which the job is run.
            # @!attribute [rw] network_tags
            #   @return [::Array<::String>]
            #     Optional. List of network tags to apply to the job.
            class VpcNetwork
              include ::Google::Protobuf::MessageExts
              extend ::Google::Protobuf::MessageExts::ClassMethods
            end
          end

          # Task scheduling and trigger settings.
          # @!attribute [rw] type
          #   @return [::Google::Cloud::Dataplex::V1::Task::TriggerSpec::Type]
          #     Required. Immutable. Trigger type of the user-specified Task.
          # @!attribute [rw] start_time
          #   @return [::Google::Protobuf::Timestamp]
          #     Optional. The first run of the task will be after this time.
          #     If not specified, the task will run shortly after being submitted if
          #     ON_DEMAND and based on the schedule if RECURRING.
          # @!attribute [rw] disabled
          #   @return [::Boolean]
          #     Optional. Prevent the task from executing.
          #     This does not cancel already running tasks. It is intended to temporarily
          #     disable RECURRING tasks.
          # @!attribute [rw] max_retries
          #   @return [::Integer]
          #     Optional. Number of retry attempts before aborting.
          #     Set to zero to never attempt to retry a failed task.
          # @!attribute [rw] schedule
          #   @return [::String]
          #     Optional. Cron schedule (https://en.wikipedia.org/wiki/Cron) for running
          #     tasks periodically.
          #     To explicitly set a timezone to the cron tab, apply a prefix in the
          #     cron tab: "CRON_TZ=$\\{IANA_TIME_ZONE}" or "TZ=$\\{IANA_TIME_ZONE}".
          #     The $\\{IANA_TIME_ZONE} may only be a valid string from IANA time zone
          #     database. For example, "CRON_TZ=America/New_York 1 * * * *", or
          #     "TZ=America/New_York 1 * * * *".
          #     This field is required for RECURRING tasks.
          class TriggerSpec
            include ::Google::Protobuf::MessageExts
            extend ::Google::Protobuf::MessageExts::ClassMethods

            # Determines how often and when the job will run.
            module Type
              # Unspecified trigger type.
              TYPE_UNSPECIFIED = 0

              # The task runs one-time shortly after Task Creation.
              ON_DEMAND = 1

              # The task is scheduled to run periodically.
              RECURRING = 2
            end
          end

          # Execution related settings, like retry and service_account.
          # @!attribute [rw] args
          #   @return [::Google::Protobuf::Map{::String => ::String}]
          #     Optional. The arguments to pass to the task.
          #     The args can use placeholders of the format $\\{placeholder} as
          #     part of key/value string. These will be interpolated before passing the
          #     args to the driver. Currently supported placeholders:
          #     - $\\{task_id}
          #     - $\\{job_time}
          #     To pass positional args, set the key as TASK_ARGS. The value should be a
          #     comma-separated string of all the positional arguments. To use a
          #     delimiter other than comma, refer to
          #     https://cloud.google.com/sdk/gcloud/reference/topic/escaping. In case of
          #     other keys being present in the args, then TASK_ARGS will be passed as
          #     the last argument.
          # @!attribute [rw] service_account
          #   @return [::String]
          #     Required. Service account to use to execute a task.
          #     If not provided, the default Compute service account for the project is
          #     used.
          # @!attribute [rw] project
          #   @return [::String]
          #     Optional. The project in which jobs are run. By default, the project containing the
          #     Lake is used. If a project is provided, the
          #     {::Google::Cloud::Dataplex::V1::Task::ExecutionSpec#service_account ExecutionSpec.service_account} must belong to this project.
          # @!attribute [rw] max_job_execution_lifetime
          #   @return [::Google::Protobuf::Duration]
          #     Optional. The maximum duration after which the job execution is expired.
          # @!attribute [rw] kms_key
          #   @return [::String]
          #     Optional. The Cloud KMS key to use for encryption, of the form:
          #     `projects/{project_number}/locations/{location_id}/keyRings/{key-ring-name}/cryptoKeys/{key-name}`.
          class ExecutionSpec
            include ::Google::Protobuf::MessageExts
            extend ::Google::Protobuf::MessageExts::ClassMethods

            # @!attribute [rw] key
            #   @return [::String]
            # @!attribute [rw] value
            #   @return [::String]
            class ArgsEntry
              include ::Google::Protobuf::MessageExts
              extend ::Google::Protobuf::MessageExts::ClassMethods
            end
          end

          # User-specified config for running a Spark task.
          # @!attribute [rw] main_jar_file_uri
          #   @return [::String]
          #     The Cloud Storage URI of the jar file that contains the main class.
          #     The execution args are passed in as a sequence of named process
          #     arguments (`--key=value`).
          # @!attribute [rw] main_class
          #   @return [::String]
          #     The name of the driver's main class. The jar file that contains the
          #     class must be in the default CLASSPATH or specified in
          #     `jar_file_uris`.
          #     The execution args are passed in as a sequence of named process
          #     arguments (`--key=value`).
          # @!attribute [rw] python_script_file
          #   @return [::String]
          #     The Gcloud Storage URI of the main Python file to use as the driver.
          #     Must be a .py file. The execution args are passed in as a sequence of
          #     named process arguments (`--key=value`).
          # @!attribute [rw] sql_script_file
          #   @return [::String]
          #     A reference to a query file. This can be the Cloud Storage URI of the
          #     query file or it can the path to a SqlScript Content. The execution
          #     args are used to declare a set of script variables
          #     (`set key="value";`).
          # @!attribute [rw] sql_script
          #   @return [::String]
          #     The query text.
          #     The execution args are used to declare a set of script variables
          #     (`set key="value";`).
          # @!attribute [rw] file_uris
          #   @return [::Array<::String>]
          #     Optional. Cloud Storage URIs of files to be placed in the working directory of each
          #     executor.
          # @!attribute [rw] archive_uris
          #   @return [::Array<::String>]
          #     Optional. Cloud Storage URIs of archives to be extracted into the working directory
          #     of each executor. Supported file types: .jar, .tar, .tar.gz, .tgz, and
          #     .zip.
          # @!attribute [rw] infrastructure_spec
          #   @return [::Google::Cloud::Dataplex::V1::Task::InfrastructureSpec]
          #     Optional. Infrastructure specification for the execution.
          class SparkTaskConfig
            include ::Google::Protobuf::MessageExts
            extend ::Google::Protobuf::MessageExts::ClassMethods
          end

          # Config for running scheduled notebooks.
          # @!attribute [rw] notebook
          #   @return [::String]
          #     Required. Path to input notebook. This can be the Cloud Storage URI of the notebook
          #     file or the path to a Notebook Content. The execution args are accessible
          #     as environment variables
          #     (`TASK_key=value`).
          # @!attribute [rw] infrastructure_spec
          #   @return [::Google::Cloud::Dataplex::V1::Task::InfrastructureSpec]
          #     Optional. Infrastructure specification for the execution.
          # @!attribute [rw] file_uris
          #   @return [::Array<::String>]
          #     Optional. Cloud Storage URIs of files to be placed in the working directory of each
          #     executor.
          # @!attribute [rw] archive_uris
          #   @return [::Array<::String>]
          #     Optional. Cloud Storage URIs of archives to be extracted into the working directory
          #     of each executor. Supported file types: .jar, .tar, .tar.gz, .tgz, and
          #     .zip.
          class NotebookTaskConfig
            include ::Google::Protobuf::MessageExts
            extend ::Google::Protobuf::MessageExts::ClassMethods
          end

          # Status of the task execution (e.g. Jobs).
          # @!attribute [r] update_time
          #   @return [::Google::Protobuf::Timestamp]
          #     Output only. Last update time of the status.
          # @!attribute [r] latest_job
          #   @return [::Google::Cloud::Dataplex::V1::Job]
          #     Output only. latest job execution
          class ExecutionStatus
            include ::Google::Protobuf::MessageExts
            extend ::Google::Protobuf::MessageExts::ClassMethods
          end

          # @!attribute [rw] key
          #   @return [::String]
          # @!attribute [rw] value
          #   @return [::String]
          class LabelsEntry
            include ::Google::Protobuf::MessageExts
            extend ::Google::Protobuf::MessageExts::ClassMethods
          end
        end

        # A job represents an instance of a task.
        # @!attribute [r] name
        #   @return [::String]
        #     Output only. The relative resource name of the job, of the form:
        #     `projects/{project_number}/locations/{location_id}/lakes/{lake_id}/tasks/{task_id}/jobs/{job_id}`.
        # @!attribute [r] uid
        #   @return [::String]
        #     Output only. System generated globally unique ID for the job.
        # @!attribute [r] start_time
        #   @return [::Google::Protobuf::Timestamp]
        #     Output only. The time when the job was started.
        # @!attribute [r] end_time
        #   @return [::Google::Protobuf::Timestamp]
        #     Output only. The time when the job ended.
        # @!attribute [r] state
        #   @return [::Google::Cloud::Dataplex::V1::Job::State]
        #     Output only. Execution state for the job.
        # @!attribute [r] retry_count
        #   @return [::Integer]
        #     Output only. The number of times the job has been retried (excluding the
        #     initial attempt).
        # @!attribute [r] service
        #   @return [::Google::Cloud::Dataplex::V1::Job::Service]
        #     Output only. The underlying service running a job.
        # @!attribute [r] service_job
        #   @return [::String]
        #     Output only. The full resource name for the job run under a particular service.
        # @!attribute [r] message
        #   @return [::String]
        #     Output only. Additional information about the current state.
        class Job
          include ::Google::Protobuf::MessageExts
          extend ::Google::Protobuf::MessageExts::ClassMethods

          module Service
            # Service used to run the job is unspecified.
            SERVICE_UNSPECIFIED = 0

            # Dataproc service is used to run this job.
            DATAPROC = 1
          end

          module State
            # The job state is unknown.
            STATE_UNSPECIFIED = 0

            # The job is running.
            RUNNING = 1

            # The job is cancelling.
            CANCELLING = 2

            # The job cancellation was successful.
            CANCELLED = 3

            # The job completed successfully.
            SUCCEEDED = 4

            # The job is no longer running due to an error.
            FAILED = 5

            # The job was cancelled outside of Dataplex.
            ABORTED = 6
          end
        end
      end
    end
  end
end


text:
define.class(function(require){
	var Cursor = require('./singlecursor')

	// forward the cursor api
	function makeForward(key, fn){
		this[key] = function(){
			this.delta = 0
			for(var i = 0; i < this.list.length; i++){
				var cursor = this.list[i]
				cursor[key].apply(cursor, arguments)
			}
			this.update()
		}
	}

	for(var key in Cursor.prototype) if(typeof Cursor.prototype[key] == 'function'){
		makeForward.call(this, key, Cursor.prototype[key])
	}

	this.atConstructor = function(editor){
		this.editor = editor
		this.list = [this.newCursor()]
		this.fusing = true
	}

	this.serializeSelection = function(){
		var str = ''
		for(var i = 0; i < this.list.length; i++){
			var cursor = this.list[i]
			str += this.editor.textbuf.serializeText(cursor.lo, cursor.hi)
		}
		return str
	}

	this.newCursor = function(){
		return new Cursor(this)
	}

	this.toArray = function(inp){
		var out = []
		for(var i = 0; i < this.list.length; i++){
			var cursor = this.list[i]
			out.push(cursor.start, cursor.end)
		}
		return out
	}

	this.fromArray = function(inp){
		this.list = []
		for(var i = 0; i < inp.length; i += 2){
			var cur = this.newCursor()
			this.list.push(cur)
			cur.start = inp[i]
			cur.end = inp[i+1]
		}
		this.update()
	}

	this.fuse = function(){

		this.list.sort(function(a,b){ return (a.start<a.end?a.start:a.end) < (b.start<b.end?b.start:b.end)? -1: 1})
		// lets do single pass
		for(var i = 0; i < this.list.length - 1;){
			var cur = this.list[i]
			var nxt = this.list[i + 1]
			// lets figure out the different overlap cases
			if(cur.hi >= nxt.lo){
				if(cur.hi <= nxt.hi){ // we fuse it [cur<]nxt>
					if(nxt.end < nxt.start){
						cur.end = cur.lo
						cur.start = nxt.hi
					}
					else{
						cur.start = cur.lo
						cur.end = nxt.hi
					}
				}
				// remove the nxt
				this.list.splice(i+1, 1)
			}
			else i++
		}
		// lets communicate the position of our first cursor

	}
	/*
	this.markDelta = function(){
		for(var i = 0; i < this.list.length; i++){
			var cursor = this.list[i]
			cursor.mark_start = this.editor.textbuf.charCodeAt(cursor.start - 1)
			cursor.mark_end = this.editor.textbuf.charCodeAt(cursor.end - 1)
		}
	}

	this.markSeek = function(pos, delta, mark){
		pos += delta
		var count = this.editor.textbuf.char_count
		if(pos < 0) pos = 0
		if(pos >= count) pos = count - 1
		// ignore markers that are volatile
		if(mark != 32 && mark != 9 && mark != 10 && mark != 59){
			pos++
			var start = pos
			var max = abs(delta)
			while(pos > 0 && this.editor.textbuf.charCodeAt(pos - 1) != mark){
				if(start - pos > max)break
				pos--
			}
		}
		return pos
	}

	this.moveDelta = function(beyond, delta){
		for(var i = 0; i < this.list.length; i++){
			var cursor = this.list[i]

			if(cursor.start>=beyond)
				cursor.start = this.markSeek(cursor.start, delta, cursor.mark_start)
			if(cursor.end>=beyond){
				cursor.end = this.markSeek(cursor.end, delta, cursor.mark_end)
			//	cursor.max = text_layer.cursorRect(cursor.end).x
			}
		}
		this.update()
	}
	*/
	this.update = function(){
		if(this.editor.cursorsChanged) this.editor.cursorsChanged()
	}

	this.rectSelect = function(x1, y1, x2, y2, clone){
		if(y2 < y1){
			var t = y1
			y1 = y2
			y2 = t
		}
		var new_list = Array.prototype.slice.apply(clone)
		var height = this.editor.textbuf.line_height
		var y = y1
		while(1){
			var cur = this.newCursor()
			new_list.push(cur)
			cur.start = this.editor.textbuf.offsetFromPos(x1,y)
			cur.end = this.editor.textbuf.offsetFromPos(x2,y)
			//console.log(cur.end, x2)
			if(y >= y2) break
			y += height
			if(y > y2) y = y2
		}
		list = new_list
		this.update()
	}

	this.addCursor = function(){
		var cursor = this.newCursor(this)
		cursor.start = cursor.end = 0//this.list.length
		this.list.push(cursor)
		return cursor
	}
})


text:
    {% include components/button-close.html %}

    {{ site.address_for_nav }}

  {% for object in site.data.navigation-links.primary %}

      {{ object.title }}

  {% endfor %}

      join our mailing list

  {% comment %}

  {% endcomment %}


text:
package types

import (
	"github.com/labstack/echo"
)

// IUsersHandler users related methods.
type IUsersHandler interface {
	AddUser(context echo.Context) error
}

// IAuthHandler auth related methods.
type IAuthHandler interface {
	Login(context echo.Context) error
}

// ITodosHandler TODOs related methods.
type ITodosHandler interface {
	AddTodo(context echo.Context) error
}


text:
<?xml version="1.0" encoding="UTF-8"?>
<!--
    Licensed to the Apache Software Foundation (ASF) under one or more
    contributor license agreements.  See the NOTICE file distributed with
    this work for additional information regarding copyright ownership.
    The ASF licenses this file to You under the Apache License, Version 2.0
    (the "License"); you may not use this file except in compliance with
    the License.  You may obtain a copy of the License at

    http://www.apache.org/licenses/LICENSE-2.0

    Unless required by applicable law or agreed to in writing, software
    distributed under the License is distributed on an "AS IS" BASIS,
    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
    See the License for the specific language governing permissions and
    limitations under the License.
-->
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:drools="http://drools.org/schema/drools-spring"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.0.xsd
                           http://drools.org/schema/drools-spring http://drools.org/schema/drools-spring-1.3.0.xsd">

  <drools:grid-node id="node1"/>

  <drools:kbase id="kbase1" node="node1">
    <drools:resources>
      <drools:resource  type="DRL" source="classpath:test.drl"/>
    </drools:resources>
  </drools:kbase>

  <drools:ksession id="ksession1" type="stateless" kbase="kbase1" node="node1"/>

</beans>


text:
package com.rohan.cinemabuff.listing;

import com.rohan.cinemabuff.entities.Movie;

import java.util.List;

import rx.Observable;

/**
 * @author arun
 */
public interface IMoviesListingInteractor
{
    Observable<List<Movie>> fetchMovies();
}


text:
'use strict';

/**
 * @ngdoc function
 * @name greenhouseApp.controller:UserCtrl
 * @description
 * # UserCtrl
 * Controller of the greenhouseApp user page
 */
angular.module('greenhouseApp')
  .controller('UserCtrl', ['$scope', '$stateParams', 'user', function ($scope, $stateParams, user) {

    console.log('userCTRL', $stateParams.uid)
  }
]);


text:
package io.dropwizard.jersey.errors;

import io.dropwizard.jersey.AbstractJerseyTest;
import io.dropwizard.jersey.DropwizardResourceConfig;
import org.junit.jupiter.api.Test;

import javax.ws.rs.WebApplicationException;
import javax.ws.rs.client.Entity;
import javax.ws.rs.core.Application;
import javax.ws.rs.core.MediaType;
import javax.ws.rs.core.Response;
import java.util.Collections;

import static org.assertj.core.api.Assertions.assertThat;
import static org.assertj.core.api.Assertions.catchThrowable;
import static org.assertj.core.api.Assertions.entry;
import static org.assertj.core.api.Assertions.failBecauseExceptionWasNotThrown;

public class LoggingExceptionMapperTest extends AbstractJerseyTest {

    @Override
    protected Application configure() {
        return DropwizardResourceConfig.forTesting()
                .register(DefaultLoggingExceptionMapper.class)
                .register(DefaultJacksonMessageBodyProvider.class)
                .register(ExceptionResource.class);
    }

    @Test
    public void returnsAnErrorMessage() throws Exception {
        try {
            target("/exception/").request(MediaType.APPLICATION_JSON).get(String.class);
            failBecauseExceptionWasNotThrown(WebApplicationException.class);
        } catch (WebApplicationException e) {
            final Response response = e.getResponse();

            assertThat(response.getStatus()).isEqualTo(500);
            assertThat(response.readEntity(String.class)).startsWith("{\"code\":500,\"message\":"
                    + "\"There was an error processing your request. It has been logged (ID ");
        }
    }

    @Test
    public void handlesJsonMappingException() throws Exception {
        try {
            target("/exception/json-mapping-exception").request(MediaType.APPLICATION_JSON).get(String.class);
            failBecauseExceptionWasNotThrown(WebApplicationException.class);
        } catch (WebApplicationException e) {
            final Response response = e.getResponse();

            assertThat(response.getStatus()).isEqualTo(500);
            assertThat(response.readEntity(String.class)).startsWith("{\"code\":500,\"message\":"
                    + "\"There was an error processing your request. It has been logged (ID ");
        }
    }

    @Test
    public void handlesMethodNotAllowedWithHeaders() {
        final Throwable thrown = catchThrowable(() -> target("/exception/json-mapping-exception")
            .request(MediaType.APPLICATION_JSON)
            .post(Entity.json("A"), String.class));
        assertThat(thrown).isInstanceOf(WebApplicationException.class);
        final Response resp = ((WebApplicationException) thrown).getResponse();
        assertThat(resp.getStatus()).isEqualTo(405);
        assertThat(resp.getHeaders()).contains(entry("Allow", Collections.singletonList("GET,OPTIONS")));
        assertThat(resp.readEntity(String.class)).isEqualTo("{\"code\":405,\"message\":\"HTTP 405 Method Not Allowed\"}");
    }

    @Test
    public void formatsWebApplicationException() throws Exception {
        try {
            target("/exception/web-application-exception").request(MediaType.APPLICATION_JSON).get(String.class);
            failBecauseExceptionWasNotThrown(WebApplicationException.class);
        } catch (WebApplicationException e) {
            final Response response = e.getResponse();

            assertThat(response.getStatus()).isEqualTo(400);
            assertThat(response.readEntity(String.class)).isEqualTo("{\"code\":400,\"message\":\"KAPOW\"}");
        }
    }

    @Test
    public void handlesRedirectInWebApplicationException() {
        String responseText = target("/exception/web-application-exception-with-redirect")
            .request(MediaType.APPLICATION_JSON)
            .get(String.class);
        assertThat(responseText).isEqualTo("{\"status\":\"OK\"}");
    }
}


text:
#include <shader_utils.hpp>

#include <iostream>
#include <vector>
using namespace std;

/**
 * Store all the file's contents in memory, useful to pass shaders
 * source code to OpenGL.  Using SDL_RWops for Android asset support.
 */
char* file_read(const char* filename) {
	SDL_RWops *rw = SDL_RWFromFile(filename, "rb");
	if (rw == NULL) return NULL;

	Sint64 res_size = SDL_RWsize(rw);
	char* res = new char[res_size + 1];

	Sint64 nb_read_total = 0, nb_read = 1;
	char* buf = res;
	while (nb_read_total < res_size && nb_read != 0) {
		nb_read = SDL_RWread(rw, buf, 1, (res_size - nb_read_total));
		nb_read_total += nb_read;
		buf += nb_read;
	}
	SDL_RWclose(rw);
	if (nb_read_total != res_size) {
		delete[] res;
		return NULL;
	}

	res[nb_read_total] = '\0';
	return res;
}

/**
 * Display compilation errors from the OpenGL shader compiler
 */
void print_log(GLuint object) {
	GLint log_length = 0;
	if (glIsShader(object)) {
		glGetShaderiv(object, GL_INFO_LOG_LENGTH, &log_length);
	} else if (glIsProgram(object)) {
		glGetProgramiv(object, GL_INFO_LOG_LENGTH, &log_length);
	} else {
		SDL_LogMessage(SDL_LOG_CATEGORY_APPLICATION, SDL_LOG_PRIORITY_ERROR,
					   "printlog: Not a shader or a program");
		return;
	}

	char *log = new char[log_length];

	if (glIsShader(object))
		glGetShaderInfoLog(object, log_length, NULL, log);
	else if (glIsProgram(object))
		glGetProgramInfoLog(object, log_length, NULL, log);

	SDL_LogMessage(SDL_LOG_CATEGORY_APPLICATION, SDL_LOG_PRIORITY_ERROR, "%s\n", log);
}

/**
 * Compile the shader from file 'filename', with error handling
 */
GLuint create_shader(const char* filename, GLenum type) {
	const char* source = file_read(filename);
	if (source == NULL) {
		SDL_LogMessage(SDL_LOG_CATEGORY_APPLICATION, SDL_LOG_PRIORITY_ERROR,
					   "Error opening %s: %s", filename, SDL_GetError());
		return 0;
	}
	GLuint res = glCreateShader(type);
	const GLchar* sources[2] = { "#version 120\n", source };
	glShaderSource(res, 2, sources,NULL);
	delete[] source;

	glCompileShader(res);
	GLint compile_ok = GL_FALSE;
	glGetShaderiv(res, GL_COMPILE_STATUS, &compile_ok);
	if (compile_ok == GL_FALSE) {
		SDL_LogMessage(SDL_LOG_CATEGORY_APPLICATION, SDL_LOG_PRIORITY_ERROR, "%s:\n", filename);
		print_log(res);
		glDeleteShader(res);
		return 0;
	}

	return res;
}

GLuint create_program(const char *vertexfile, const char *fragmentfile) {
	GLuint program = glCreateProgram();
	GLuint shader;

	if(vertexfile) {
		shader = create_shader(vertexfile, GL_VERTEX_SHADER);
		if(!shader)
			return 0;
		glAttachShader(program, shader);
	}

	if(fragmentfile) {
		shader = create_shader(fragmentfile, GL_FRAGMENT_SHADER);
		if(!shader)
			return 0;
		glAttachShader(program, shader);
	}

	glLinkProgram(program);
	GLint link_ok = GL_FALSE;
	glGetProgramiv(program, GL_LINK_STATUS, &link_ok);
	if (!link_ok) {
		SDL_LogMessage(SDL_LOG_CATEGORY_APPLICATION, SDL_LOG_PRIORITY_INFO, "glLinkProgram:");
		print_log(program);
		glDeleteProgram(program);
		return 0;
	}

	return program;
}

GLint get_attrib(GLuint program, const char *name) {
	GLint attribute = glGetAttribLocation(program, name);
	if(attribute == -1)
		SDL_LogMessage(SDL_LOG_CATEGORY_APPLICATION, SDL_LOG_PRIORITY_ERROR,
					   "Could not bind attribute %s", name);
	return attribute;
}

GLint get_uniform(GLuint program, const char *name) {
	GLint uniform = glGetUniformLocation(program, name);
	if(uniform == -1)
		SDL_LogMessage(SDL_LOG_CATEGORY_APPLICATION, SDL_LOG_PRIORITY_ERROR,
					   "Could not bind uniform %s", name);
	return uniform;
}

void print_opengl_info() {
	int major, minor, profile;
	SDL_GL_GetAttribute(SDL_GL_CONTEXT_MAJOR_VERSION, &major);
	SDL_GL_GetAttribute(SDL_GL_CONTEXT_MINOR_VERSION, &minor);
	SDL_GL_GetAttribute(SDL_GL_CONTEXT_PROFILE_MASK, &profile);
	const char* profile_str = "";
	if (profile & SDL_GL_CONTEXT_PROFILE_CORE)
		profile_str = "CORE";
	if (profile & SDL_GL_CONTEXT_PROFILE_COMPATIBILITY)
		profile_str = "COMPATIBILITY";
	if (profile & SDL_GL_CONTEXT_PROFILE_ES)
		profile_str = "ES";

	SDL_LogMessage(SDL_LOG_CATEGORY_APPLICATION, SDL_LOG_PRIORITY_INFO,
				   "OpenGL %d.%d %s", major, minor, profile_str);
}