text:
namespace autofill {

class PasswordAutofillAgent;

// This class is responsible for controlling communication for password
// generation between the browser (which shows the popup and generates
// passwords) and WebKit (shows the generation icon in the password field).
class PasswordGenerationAgent : public content::RenderFrameObserver,
                                public mojom::PasswordGenerationAgent {
 public:
  // Maximum number of characters typed by user while the generation is still
  // offered. When the (kMaximumCharsForGenerationOffer + 1)-th character is
  // typed, the generation becomes unavailable.
  static const size_t kMaximumCharsForGenerationOffer = 5;

  // User can edit the generated password. If the length falls below this value,
  // the password is no longer considered generated.
  static const size_t kMinimumLengthForEditedPassword = 4;

  PasswordGenerationAgent(content::RenderFrame* render_frame,
                          PasswordAutofillAgent* password_agent,
                          blink::AssociatedInterfaceRegistry* registry);

  PasswordGenerationAgent(const PasswordGenerationAgent&) = delete;
  PasswordGenerationAgent& operator=(const PasswordGenerationAgent&) = delete;

  ~PasswordGenerationAgent() override;

  void BindPendingReceiver(
      mojo::PendingAssociatedReceiver<mojom::PasswordGenerationAgent>
          pending_receiver);

  // mojom::PasswordGenerationAgent:
  void GeneratedPasswordAccepted(const std::u16string& password) override;
  void FoundFormEligibleForGeneration(
      const PasswordFormGenerationData& form) override;
  // Sets |generation_element_| to the focused password field and responds back
  // if the generation was triggered successfully.
  void TriggeredGeneratePassword(
      TriggeredGeneratePasswordCallback callback) override;

  // Returns true if the field being changed is one where a generated password
  // is being offered. Updates the state of the popup if necessary.
  bool TextDidChangeInTextField(const blink::WebInputElement& element);

  // Returns true if the newly focused node caused the generation UI to show.
  bool FocusedNodeHasChanged(const blink::WebNode& node);

  // Event forwarded by AutofillAgent from WebAutofillClient, informing that
  // the text field editing has ended, which means that the field is not
  // focused anymore. This is required for Android, where moving focus
  // to a non-focusable element doesn't result in |FocusedNodeHasChanged|
  // being called.
  void DidEndTextFieldEditing(const blink::WebInputElement& element);

  // Called right before PasswordAutofillAgent filled |password_element|.
  void OnFieldAutofilled(const blink::WebInputElement& password_element);

  // Returns true iff the currently handled 'blur' event is fake and should be
  // ignored.
  bool ShouldIgnoreBlur() const;

#if defined(UNIT_TEST)
  // This method requests the mojom::PasswordManagerClient which binds
  // requests the binding if it wasn't bound yet.
  void RequestPasswordManagerClientForTesting() {
    GetPasswordGenerationDriver();
  }
#endif

  bool IsPrerendering() const;

 private:
  class DeferringPasswordGenerationDriver;

  // Contains information about generation status for an element for the
  // lifetime of the possible interaction.
  struct GenerationItemInfo;

  // RenderFrameObserver:
  void DidCommitProvisionalLoad(ui::PageTransition transition) override;
  void DidChangeScrollOffset() override;
  void OnDestruct() override;

  mojom::PasswordManagerDriver& GetPasswordManagerDriver();

  // Callers should not store the returned value longer than a function scope.
  mojom::PasswordGenerationDriver& GetPasswordGenerationDriver();

  // Helper function which takes care of the form processing and collecting the
  // information which is required to show the generation popup. Returns true if
  // all required information is collected.
  bool SetUpTriggeredGeneration();

  // This is called whenever automatic generation could be offered.
  // If manual generation was already requested, automatic generation will
  // not be offered.
  void MaybeOfferAutomaticGeneration();

  // Signals the browser that it should offer automatic password generation
  // as a result of the user focusing a password field eligible for generation.
  void AutomaticGenerationAvailable();

  // Show UI for editing a generated password at |generation_element_|.
  void ShowEditingPopup();

  // Signals the browser that generation was rejected. This happens when the
  // user types more characters than the maximum offer size into the password
  // field. Upon receiving this message, the browser can choose to hide the
  // generation UI or not, depending on the platform.
  void GenerationRejectedByTyping();

  // Stops treating a password as generated.
  void PasswordNoLongerGenerated();

  // Creates |current_generation_item_| for |element| if |element| is a
  // generation enabled element. If |current_generation_item_| is already
  // created for |element| it is not recreated.
  void MaybeCreateCurrentGenerationItem(
      blink::WebInputElement element,
      FieldRendererId confirmation_password_renderer_id);

  void LogMessage(SavePasswordProgressLogger::StringID message_id);
  void LogBoolean(SavePasswordProgressLogger::StringID message_id,
                  bool truth_value);

  // Creates a FormData to presave a generated password. It copies behavior
  // of CreateFromDataFromWebForm/FromUnownedInputElements. If a form
  // creating is failed, returns an empty unique_ptr.
  std::unique_ptr<FormData> CreateFormDataToPresave();

  // Contains the current element where generation is offered at the moment. It
  // can be either automatic or manual password generation.
  std::unique_ptr<GenerationItemInfo> current_generation_item_;

  // Password element that had focus last. Since Javascript could change focused
  // element after the user triggered a generation request, it is better to save
  // the last focused password element.
  blink::WebInputElement last_focused_password_element_;

  // Contains correspondence between generation enabled element and data for
  // generation.
  std::map<FieldRendererId, PasswordFormGenerationData>
      generation_enabled_fields_;

  // True iff the generation element should be marked with special HTML
  // attribute (only for experimental purposes).
  const bool mark_generation_element_;

  // Unowned pointer. Used to notify PassowrdAutofillAgent when values
  // in password fields are updated.
  PasswordAutofillAgent* password_agent_;

  mojo::AssociatedRemote<mojom::PasswordGenerationDriver>
      password_generation_client_;

  // Used for deferring messages while prerendering.
  std::unique_ptr<DeferringPasswordGenerationDriver>
      deferring_password_generation_driver_;

  mojo::AssociatedReceiver<mojom::PasswordGenerationAgent> receiver_{this};
};

}  // namespace autofill

#endif  // COMPONENTS_AUTOFILL_CONTENT_RENDERER_PASSWORD_GENERATION_AGENT_H_


text:
#ifndef _PAGE_H_
#define _PAGE_H_

#include <lib/typedefs.h>

#define PAGE_WIDTH 12
#define PAGE_SIZE  (1 << PAGE_WIDTH)

#define KA2PA(x) (((uintptr_t) (x)) - 0x80000000)
#define PA2KA(x) (((uintptr_t) (x)) + 0x80000000)

static inline uint32_t
sdr1_get(void)
{
	uint32_t sdr1;

	asm volatile (
		"mfsdr1 %[sdr1]\n"
		: [sdr1] "=r" (sdr1)
	);

	return sdr1;
}

typedef struct
{
	unsigned int v        :1;  // Entry valid (V = 1) or invalid (V = 0)
	unsigned int vsid     :24; // Virtual segment ID
	unsigned int h        :1;  // Hash function identifier
	unsigned int api      :6;  // Abbreviated page index
	unsigned int rpn      :20; // Physical page number
	unsigned int reserved0:3;  // Reserved
	unsigned int r        :1;  // Reference bit
	unsigned int c        :1;  // Change bit
	unsigned int wimg     :4;  // Memory/cache control bits
	unsigned int reserved1:1;  // Reserved
	unsigned int pp       :2;  // Page protection bits
} pte_t;

void paging_init(size_t memory_start, size_t memory_end);
void pte_add(void);
void pte_delete(void);
void pte_update(void);

#endif // _PAGE_H_

redpajama_set_name: RedPajamaGithub


text:
namespace Microsoft.Azure.Management.BatchAI.Fluent.ToolTypeSettings.Chainer.Definition
{
    using Microsoft.Azure.Management.ResourceManager.Fluent.Core.ChildResource.Definition;

    /// <summary>
    /// Specifies python script file path to execute the job.
    /// </summary>
    /// <typeparam name="ParentT">The stage of the parent definition to return to after attaching this definition.</typeparam>
    public interface IWithPython<ParentT>
    {
        Microsoft.Azure.Management.BatchAI.Fluent.ToolTypeSettings.Chainer.Definition.IWithAttachAndPythonInterpreter<ParentT> WithPythonScriptFile(string pythonScriptFilePath);
    }

    /// <summary>
    /// The first stage of the Chainer settings definition.
    /// </summary>
    /// <typeparam name="ParentT">The stage of the parent definition to return to after attaching this definition.</typeparam>
    public interface IBlank<ParentT>  :
        Microsoft.Azure.Management.BatchAI.Fluent.ToolTypeSettings.Chainer.Definition.IWithPython<ParentT>
    {
    }

    /// <summary>
    /// The final stage of the Chainer settings definition.
    /// At this stage, any remaining optional settings can be specified, or the Chainer settings definition
    /// can be attached to the parent Batch AI job definition.
    /// </summary>
    /// <typeparam name="ParentT">The stage of the parent definition to return to after attaching this definition.</typeparam>
    public interface IWithAttach<ParentT>  :
        Microsoft.Azure.Management.ResourceManager.Fluent.Core.ChildResource.Definition.IInDefinition<ParentT>,
        Microsoft.Azure.Management.BatchAI.Fluent.ToolTypeSettings.HasCommandLineArgs.Definition.IWithCommandLineArgs<Microsoft.Azure.Management.BatchAI.Fluent.ToolTypeSettings.Chainer.Definition.IWithAttach<ParentT>>,
        Microsoft.Azure.Management.BatchAI.Fluent.ToolTypeSettings.HasProcessCount.Definition.IWithProcessCount<Microsoft.Azure.Management.BatchAI.Fluent.ToolTypeSettings.Chainer.Definition.IWithAttach<ParentT>>
    {
    }

    /// <summary>
    /// Definition of Chainer settings.
    /// </summary>
    /// <typeparam name="ParentT">The stage of the parent definition to return to after attaching this definition.</typeparam>
    public interface IDefinition<ParentT>  :
        Microsoft.Azure.Management.BatchAI.Fluent.ToolTypeSettings.Chainer.Definition.IBlank<ParentT>,
        Microsoft.Azure.Management.BatchAI.Fluent.ToolTypeSettings.Chainer.Definition.IWithAttachAndPythonInterpreter<ParentT>
    {
    }

    public interface IWithAttachAndPythonInterpreter<ParentT>  :
        Microsoft.Azure.Management.BatchAI.Fluent.ToolTypeSettings.Chainer.Definition.IWithAttach<ParentT>,
        Microsoft.Azure.Management.BatchAI.Fluent.ToolTypeSettings.HasPythonInterpreter.Definition.IWithPythonInterpreter<Microsoft.Azure.Management.BatchAI.Fluent.ToolTypeSettings.Chainer.Definition.IWithAttach<ParentT>>
    {
    }
}


text:
package dog

// Task represents a task described in the Dogfile format.
type Task struct {
	// Name of the task.
	Name string

	// Description of the task.
	Description string

	// The code that will be executed.
	Code string

	// Defaults to operating system main shell.
	Runner string

	// Pre-hooks execute other tasks before starting the current one.
	Pre []string

	// Post-hooks are analog to pre-hooks but they are executed after
	// current task finishes its execution.
	Post []string

	// Default values for environment variables can be provided in the Dogfile.
	// They can be modified at execution time.
	Env []string

	// Sets the working directory for the task. Relative paths are
	// considered relative to the location of the Dogfile.
	Workdir string

	// Register stores the output of the task so it can be accessed by
	// other tasks in the task chain.
	//
	// When present, a new environment variable is injected in future
	// task chain runners using the register name as key and the output
	// as value.
	Register string
}


text:
using System;
using System.Collections.Generic;
using System.Reflection;
using Microsoft.SharePoint;
using Microsoft.Office.Server.Search.Administration;

namespace Glyma.SharePoint.Search.UI
{
   public class SearchConfigurationManager
   {
      public readonly static string GlymaDisplayTemplateUrl = "~sitecollection/_catalogs/masterpage/Display Templates/Search/Glyma/Item_Glyma.js";

      SPSite _siteCollection = null;
      SearchServiceApplicationProxy _searchService = null;
      SearchObjectOwner _searchOwner = null;
      ResultItemTypeManager _resultTypeManager = null;

      public SearchConfigurationManager(SPSite siteCollection)
      {
         _siteCollection = siteCollection;

         _searchService = GetSearchServiceApplicationProxy();
         _searchOwner = new SearchObjectOwner(SearchObjectLevel.SPSite, _siteCollection.RootWeb);
         _resultTypeManager = new ResultItemTypeManager(_searchService);
      }

      public void EnsureGlymaResultTypesSynced()
      {
         string displayProperties = GetDisplayTemplateDisplayProperties(GlymaDisplayTemplateUrl);

         foreach (ResultItemType currentResultType in _resultTypeManager.GetResultItemTypes(_searchOwner, false))
         {
            if (currentResultType.DisplayTemplateUrl.Equals(GlymaDisplayTemplateUrl, StringComparison.OrdinalIgnoreCase))
            {
               // Ensure the managed properties of the result type is always in-sync with the display template referenced by the DisplayTemplateUrl property.
               if (!currentResultType.DisplayProperties.Equals(displayProperties, StringComparison.OrdinalIgnoreCase))
               {
                  currentResultType.DisplayProperties = displayProperties;
                  _resultTypeManager.UpdateResultItemType(currentResultType);
               }
            }
         }
      }

      public SearchServiceApplicationProxy GetSearchServiceApplicationProxy()
      {
         SPServiceContext serviceContext = SPServiceContext.GetContext(_siteCollection);
         SearchServiceApplicationProxy defaultProxy = serviceContext.GetDefaultProxy(typeof(SearchServiceApplicationProxy)) as SearchServiceApplicationProxy;
         if (defaultProxy == null)
         {
            throw new ApplicationException("Search service application proxy not found.");
         }
         return defaultProxy;
      }

      public string GetDisplayTemplateDisplayProperties(string displayTemplateUrl)
      {
         string displayProperties = string.Empty;

         SPListItem glymaDisplayTemplateItem = GetDisplayTemplateItem(displayTemplateUrl);
         if (glymaDisplayTemplateItem == null)
         {
            throw new ApplicationException("The display template was not found at the URL: " + displayTemplateUrl + ".");
         }

         string managedPropertyMapping = glymaDisplayTemplateItem["ManagedPropertyMapping"] as string;
         if (managedPropertyMapping == null)
         {
            throw new ApplicationException("Unable to retrieve the managed property mapping for the diplay template: " + glymaDisplayTemplateItem.Url + ".");
         }
         displayProperties = SearchConfigurationManager.ParseManagePropertyMappings(managedPropertyMapping);

         return displayProperties;
      }

      public SPListItem GetDisplayTemplateItem(string displayTemplateUrl)
      {
         SPListItem displayTemplateItem = null;

         // Using the method, GetFileOrFolderObject, provides a more consistent behaviour than GetFile because it doesn't rely on the URL used to create the SPWeb object (according to http://blog.mastykarz.nl/inconvenient-spwebgetfilestring/).
         object foundObject = _siteCollection.RootWeb.GetFileOrFolderObject(displayTemplateUrl.Replace("~sitecollection/", _siteCollection.ServerRelativeUrl.TrimEnd('/') + "/"));
         if (foundObject is SPFile)
         {
            displayTemplateItem = ((SPFile)foundObject).Item;
         }

         return displayTemplateItem;
      }

      private static string ParseManagePropertyMappings(string mappings)
      {
         string[] properties = mappings.Replace("'", "").Replace("\"", "").Split(new char[] { ',' });
         for (int propertyIndex = 0; propertyIndex < properties.Length; propertyIndex++)
         {
            if (properties[propertyIndex].Contains(":"))
            {
               int separatorIndex = properties[propertyIndex].LastIndexOf(':');
               if ((separatorIndex > 0) && (separatorIndex < (properties[propertyIndex].Length - 1)))
               {
                  properties[propertyIndex] = properties[propertyIndex].Substring(separatorIndex + 1);
               }
            }
            properties[propertyIndex] = properties[propertyIndex].Replace(";", ",");
         }
         return string.Join(",", properties);
      }

   }
}


text: from .mainmenu import MainMenu


text:
// Copyright Naked Objects Group Ltd, 45 Station Road, Henley on Thames, UK, RG9 1AT
// Licensed 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.

// ReSharper disable UnusedMember.Global
// ReSharper disable UnusedMember.Local

// ReSharper disable UnusedMethodReturnValue.Local

namespace NakedObjects.SystemTest.PolymorphicAssociations;

public class FixtureEntities {
    #region Injected Services

    public IDomainObjectContainer Container { set; protected get; }

    #endregion

    public void Install() {
        //Create Payments 1 to 11
        for (var i = 1; i <= 11; i++) {
            NewPersisted<PolymorphicPayment>();
        }

        NewPersisted<CustomerAsPayee>();
        NewPersisted<CustomerAsPayee>();

        NewPersisted<InvoiceAsPayableItem>();
        NewPersisted<InvoiceAsPayableItem>();
        NewPersisted<InvoiceAsPayableItem>();
    }

    private T NewPersisted<T>() where T : class, new() {
        var t = Container.NewTransientInstance<T>();
        Container.Persist(ref t);
        return t;
    }
}


text:
#pragma once

#include <atomic>
#include <climits>
#include <functional>
#include <stdexcept>

namespace folly {

typedef std::function<void()> Func;

/// An Executor accepts units of work with add(), which should be
/// threadsafe.
class Executor {
 public:
  virtual ~Executor() = default;

  /// Enqueue a function to executed by this executor. This and all
  /// variants must be threadsafe.
  virtual void add(Func) = 0;

  /// Enqueue a function with a given priority, where 0 is the medium priority
  /// This is up to the implementation to enforce
  virtual void addWithPriority(Func, int8_t priority) {
    throw std::runtime_error(
        "addWithPriority() is not implemented for this Executor");
  }

  virtual uint8_t getNumPriorities() const {
    return 1;
  }

  static const int8_t LO_PRI  = SCHAR_MIN;
  static const int8_t MID_PRI = 0;
  static const int8_t HI_PRI  = SCHAR_MAX;

  /// A convenience function for shared_ptr to legacy functors.
  ///
  /// Sometimes you have a functor that is move-only, and therefore can't be
  /// converted to a std::function (e.g. std::packaged_task). In that case,
  /// wrap it in a shared_ptr (or maybe folly::MoveWrapper) and use this.
  template <class P>
  void addPtr(P fn) {
    this->add([fn]() mutable { (*fn)(); });
  }
};

} // folly


text:
struct test_ctors
{
    static constexpr erichkeane::const_expr_string<char> ctor1 = "asdfasdfasdf";
    static constexpr erichkeane::const_expr_string<char> ctor2 = ctor1;
    constexpr bool operator()() const
    {
        return true;
    }
};

struct test_char_conversion
{
    static constexpr const char root[] = "asdfqefaxdvaqwerasdf";
    static constexpr erichkeane::const_expr_string<char> ctor1 = root;
    static constexpr erichkeane::const_expr_string<char> ctor2 = ctor1;

    static constexpr const char* temp1 = ctor1;
    static constexpr const char* temp2 = ctor2;

    constexpr bool operator()() const
    {
        static_assert(&temp1[0] == &root[0], "test_output failed");
        static_assert(&temp2[0] == &root[0], "test_output failed");

        return true;
    }
};

struct test_sizes
{
    static constexpr const char root[] = "asdfqefaxdvaqwerasdf";
    static constexpr erichkeane::const_expr_string<char> ctor1 = root;

    constexpr bool operator()() const
    {
        static_assert(ctor1.size() == sizeof("asdfqefaxdvaqwerasdf") - 1, "test_sizes failed");
        static_assert(ctor1.length() == sizeof("asdfqefaxdvaqwerasdf") - 1, "test_sizes failed");

        return true;
    }
};

struct test_iterators
{
    static constexpr const char root[] = "asdfqefaxdvaqwerasdf";
    static constexpr erichkeane::const_expr_string<char> ctor1 = root;
    using It = typename erichkeane::const_expr_string<char>::iterator;

    constexpr bool helper(size_t i, It iterator) const
    {
        return iterator < ctor1.end() ?
            (
                *iterator != root[i] ? false : helper(i + 1, iterator + 1)
            )
            : true;
    }
    constexpr bool operator()() const
    {
        static_assert(*(ctor1.begin()) == root[0], "Iterator Begin Failed");
        return ctor1.begin() != ctor1.end() && helper(0, ctor1.begin());
    }
};

struct test_const_iterators
{
    static constexpr const char root[] = "asdfqefaxdvaqwerasdf";
    static constexpr erichkeane::const_expr_string<char> ctor1 = root;
    using It = typename erichkeane::const_expr_string<char>::const_iterator;

    constexpr bool helper(size_t i, It iterator) const
    {
        return iterator < ctor1.cend() ?
            (
                *iterator != root[i] ? false : helper(i + 1, iterator + 1)
            )
            : true;
    }
    constexpr bool operator()() const
    {
        static_assert(*(ctor1.cbegin()) == root[0], "Iterator Begin Failed");
        return ctor1.cbegin() != ctor1.cend() && helper(0, ctor1.cbegin());
    }
};

struct test_index_op
{
    static constexpr const char root[] = "asdfqefaxdvaqwerasdf";
    static constexpr erichkeane::const_expr_string<char> ctor1 = root;

    constexpr bool helper(erichkeane::const_expr_string<char>::size_type i) const
    {
        return i < ctor1.size() ?
            (
                ctor1[i] != root[i] ? false : helper(i+1)
            )
            :true;
    }
    constexpr bool operator()() const
    {
        return helper(0);
    }
};

struct test_at
{
    static constexpr const char root[] = "asdfqefaxdvaqwerasdf";
    static constexpr erichkeane::const_expr_string<char> ctor1 = root;

    constexpr bool helper(erichkeane::const_expr_string<char>::size_type i) const
    {
        return i < ctor1.size() ?
            (
                ctor1.at(i) != root[i] ? false : helper(i+1)
                )
            : true;
    }

    constexpr bool operator()() const
    {
        return helper(0);
    }
};

struct test_data
{
    static constexpr const char root[] = "asdfqefaxdvaqwerasdf";
    static constexpr erichkeane::const_expr_string<char> ctor1 = root;

    constexpr bool operator()() const
    {
        static_assert(ctor1.data() == root, "test_data");
        return true;
    }
};

struct test_base_compare
{
    static constexpr const char root[] = "asdfqefaxdvaqwerasdf";
    static constexpr erichkeane::const_expr_string<char> ctor1 = root;
    static constexpr const char root2[] = "asdfqefaxdvaqwerasdf";
    static constexpr erichkeane::const_expr_string<char> ctor2 = root2;
    static constexpr const char root3[] = "asdfqefaxdvaqwerasds";
    static constexpr erichkeane::const_expr_string<char> ctor3 = root3;
    static constexpr const char root4[] = "asdfqefaxdvaqwerasdc";
    static constexpr erichkeane::const_expr_string<char> ctor4 = root4;
    static constexpr const char root5[] = "qefax";
    static constexpr erichkeane::const_expr_string<char> ctor5 = root5;

    constexpr bool operator()() const
    {
        // Compare-all
        static_assert(ctor1.compare(ctor2) == 0, " failed equal");
        static_assert(ctor1.compare(ctor3) != 0, " failed not equal");
        static_assert(ctor1.compare(ctor3) < 0, " failed lt");
        static_assert(ctor1.compare(ctor3) <= 0, " failed lte");
        static_assert(ctor1.compare(ctor2) <= 0, " failed lte");
        static_assert(ctor1.compare(ctor4) > 0, " failed gt");
        static_assert(ctor1.compare(ctor4) >= 0, " failed gte");
        static_assert(ctor1.compare(ctor2) >= 0, " failed gte");

        // compare first-range-only
        static_assert(ctor1.compare(4, 5, ctor5) == 0, "failed equal");
        static_assert(ctor1.compare(10, 5, ctor5) != 0, "failed not equal");
        static_assert(ctor1.compare(10, 4, ctor5) < 0, "failed lt");
        static_assert(ctor1.compare(10, 4, ctor5) <= 0, "failed lte");
        static_assert(ctor1.compare(10, 7, ctor5) > 0, "failed gt");
        static_assert(ctor1.compare(10, 7, ctor5) >= 0, "failed gte");
        static_assert(ctor1.compare(5, 5, ctor5) < 0, "failed lt");
        static_assert(ctor1.compare(8, 5, ctor5) > 0, "failed gt");

        // compare full ranges
        static_assert(ctor1.compare(4, 5, ctor5, 0, 5) == 0, "failed equal");
        static_assert(ctor1.compare(4, 5, ctor5, 0, 4) > 0, "failed gt");
        static_assert(ctor1.compare(4, 4, ctor5, 0, 5) < 0, "failed lt");
        static_assert(ctor1.compare(6, 3, ctor5, 2, 3) == 0, "failed equal");
        static_assert(ctor1.compare(10, 3, ctor5, 2, 3) != 0, "failed not equal");

        // Compare-all with char ptrs
        static_assert(ctor1.compare("asdfqefaxdvaqwerasdf") == 0, " failed equal");
        static_assert(ctor1.compare("asdfqdfaxdvaqwerasdf") != 0, " failed not equal");
        static_assert(ctor1.compare("asdfqffaxdvaqwerasdf") < 0, " failed lt");
        static_assert(ctor1.compare("asdfqdfaxdvaqwerasdf") > 0, " failed gt");

        // compare first-range-only with char ptrs
        static_assert(ctor1.compare(4, 5, "qefax") == 0, "failed equal");
        static_assert(ctor1.compare(10, 5, "qefax") != 0, "failed not equal");
        static_assert(ctor1.compare(10, 4, "qefax") < 0, "failed lt");
        static_assert(ctor1.compare(10, 4, "qefax") <= 0, "failed lte");
        static_assert(ctor1.compare(10, 7, "qefax") > 0, "failed gt");
        static_assert(ctor1.compare(10, 7, "qefax") >= 0, "failed gte");
        static_assert(ctor1.compare(5, 5, "qefax") < 0, "failed lt");
        static_assert(ctor1.compare(8, 5, "qefax") > 0, "failed gt");

        // compare full ranges with char ptrs
        static_assert(ctor1.compare(4, 5, "qefax", 5) == 0, "failed equal");
        static_assert(ctor1.compare(4, 5, "qefax", 4) > 0, "failed gt");
        static_assert(ctor1.compare(4, 4, "qefax", 5) < 0, "failed lt");
        static_assert(ctor1.compare(6, 3, "fax", 3) == 0, "failed equal");
        static_assert(ctor1.compare(10, 3, "fax", 3) != 0, "failed not equal");
        return true;
    }

};

struct test_compare_operators
{
    static constexpr const char root[] = "asdfqefaxdvaqwerasdf";
    static constexpr erichkeane::const_expr_string<char> ctor1 = root;
    static constexpr const char root2[] = "asdfqefaxdvaqwerasdf";
    static constexpr erichkeane::const_expr_string<char> ctor2 = root2;
    static constexpr const char root3[] = "asdfqefaxdvaqwerasds";
    static constexpr erichkeane::const_expr_string<char> ctor3 = root3;
    static constexpr const char root4[] = "asdfqefaxdvaqwerasdc";
    static constexpr erichkeane::const_expr_string<char> ctor4 = root4;

    constexpr bool operator()() const
    {
        static_assert(ctor1 == ctor2, " failed equal");
        static_assert(ctor1 != ctor3, " failed not equal");
        static_assert(ctor1 < ctor3, " failed lt");
        static_assert(ctor1 <= ctor3, " failed lte");
        static_assert(ctor1 <= ctor2, " failed lte");
        static_assert(ctor1 > ctor4, " failed gt");
        static_assert(ctor1 >= ctor4, " failed gte");
        static_assert(ctor1 >= ctor2, " failed gte");
        return true;
    }
};

struct test_front_back
{
    static constexpr const char root[] = "asdfqefaxdvaqwerasdf";
    static constexpr erichkeane::const_expr_string<char> ctor1 = root;

    constexpr bool operator()() const
    {
        static_assert(ctor1.front() == root[0], "front");
        static_assert(ctor1.back() == root[ctor1.size() - 1], "back");
        static_assert(&ctor1.front() == &root[0], "front addr");
        static_assert(&ctor1.back() == &root[ctor1.size() - 1], "back addr");

        return true;
    }
};

struct test_max_size
{
    static constexpr const char root[] = "asdfqefaxdvaqwerasdf";
    static constexpr erichkeane::const_expr_string<char> ctor1 = root;

    constexpr bool operator()() const
    {
        static_assert(ctor1.max_size() == size_t(-1) - 1, "Failed max size");

        return true;
    }
};

struct test_empty
{
    static constexpr const char root[] = "asdfqefaxdvaqwerasdf";
    static constexpr erichkeane::const_expr_string<char> ctor1 = root;
    static constexpr erichkeane::const_expr_string<char> ctor2 = "";

    constexpr bool operator()() const
    {
        static_assert(!ctor1.empty(), "failed empty");
        static_assert(ctor2.empty(), "failed empty");

        return true;
    }
};

bool test_ostream()
{
    static constexpr const char root[] = "asdfqefaxdvaqwerasdf";
    static constexpr erichkeane::const_expr_string<char> ctor1 = root;

    std::stringstream ss;
    ss << ctor1;
    assert(ss.str() == root);
    return true;
}

struct test_find
{
    static constexpr const char root[] = "asdfqefaxdvaqwerasdf";
    static constexpr erichkeane::const_expr_string<char> ctor1 = root;
    static constexpr const char root2[] = "axd";
    static constexpr erichkeane::const_expr_string<char> ctor2 = root2;
    static constexpr const char root3[] = "df";
    static constexpr erichkeane::const_expr_string<char> ctor3 = root3;

    constexpr bool operator()() const
    {
        static_assert(ctor1.find(ctor2, 2) == 7, "find");
        static_assert(ctor1.find('q', 1) == 4, "find");
        static_assert(ctor1.find("axd", 3) == 7, "find");
        static_assert(ctor1.find("axd", 3, 3) == 7, "find");

        static_assert(ctor1.rfind(ctor3) == 18, "rfind");
        static_assert(ctor1.rfind('d') == 18, "rfind");
        static_assert(ctor1.rfind("df") == 18, "rfind");
        static_assert(ctor1.rfind("dfe", ctor1.size(), 2) == 18, "rfind");

        static_assert(ctor1.find_first_of(ctor2) == 0, "find_first_of");
        static_assert(ctor1.find_first_of(ctor2, 1) == 2, "find_first_of");
        static_assert(ctor1.find_first_of('f') == 3, "find_first_of");
        static_assert(ctor1.find_first_of("efa", 1) == 3, "find_first_of");
        static_assert(ctor1.find_first_of("efa", 1, 2) == 3, "find_first_of");

        static_assert(ctor1.find_last_of(ctor2) == 18, "find_last_of");
        static_assert(ctor1.find_last_of(ctor2, 17) == 16, "find_last_of");
        static_assert(ctor1.find_last_of('f') == 19, "find_last_of");
        static_assert(ctor1.find_last_of("efa", 17) == 16, "find_last_of");
        static_assert(ctor1.find_last_of("efa", 4, 2) == 3, "find_last_of");

        static_assert(ctor1.find_first_not_of(ctor2) == 1, "find_first_not_of");
        static_assert(ctor1.find_first_not_of(ctor2, 2) == 3, "find_first_not_of");
        static_assert(ctor1.find_first_not_of('a') == 1, "find_first_not_of");
        static_assert(ctor1.find_first_not_of("efa", 2) == 2, "find_first_not_of");
        static_assert(ctor1.find_first_not_of("efa", 2, 2) == 2, "find_first_not_of");

        static_assert(ctor1.find_last_not_of(ctor2) == 19, "find_last_not_of");
        static_assert(ctor1.find_last_not_of(ctor2, 16) == 15, "find_last_not_of");
        static_assert(ctor1.find_last_not_of('f') == 18, "find_last_not_of");
        static_assert(ctor1.find_last_not_of("efa", 16) == 15, "find_last_not_of");
        static_assert(ctor1.find_last_not_of("efa", 3, 2) == 2, "find_last_not_of");
        return true;
    }
};

int main()
{
    static_assert(test_ctors{}(), "failed");
    static_assert(test_char_conversion{}(), "failed");
    static_assert(test_sizes{}(), "failed");
    static_assert(test_iterators{}(), "failed");
    static_assert(test_const_iterators{}(), "failed");
    static_assert(test_index_op{}(), "failed");
    static_assert(test_at{}(), "failed");
    static_assert(test_data{}(), "failed");
    static_assert(test_base_compare{}(), "failed");
    static_assert(test_empty{}(), "failed");
    static_assert(test_front_back{}(), "failed");
    static_assert(test_max_size{}(), "failed");
    static_assert(test_compare_operators{}(), "failed");
    assert(test_ostream());
    static_assert(test_find{}(), "failed");
}


text:
Smaller
=======

Summary
-------
Smaller is a small webservice for minification and transcoding sources.
It currently supports coffeescript, closure, uglifyjs, lessjs, typescript,
jshint, eslint, browserify, sweetjs, yuicompressor, ycssmin, csso,
embeddcss and svgo.

Starting as server-side only application for build preprocessing Smaller is
now embedded in the [Smaller Development Server](https://github.com/KnisterPeter/smaller-dev-server)
to be used for speed up local development with all the same build tools
used for build preprocessing.

Services
--------
+ Maven Plugin
+ Maven Standalone Plugin
+ Ant Task
+ Ant Standalone Task
+ Webservice Standalone
+ Embeddable Servlet
+ OSGi bundles

Processors
----------

##### For CSS

+ Less
    + **Name**: `lessjs`
    + **Description**: Compiles LESS files to CSS. This is a merge task.
    * **Website**: http://github.com/cloudhead/less.js
    * **Versions**: 1.3.0, 1.3.3, 1.4.0, 1.4.1, 1.4.2, 1.5.0, 1.6.1
+ ycssmin
    + **Name**: `ycssmin`
    + **Description**: Minifies CSS files with ycssmin
    * **Website**: http://github.com/yui/ycssmin
+ csso
    + **Name**: `csso`
    + **Description**: Minifies CSS files with csso
    * **Website**: http://bem.info/tools/optimizers/csso/
+ YUICompressor
    + **Name**: `yuicompressor`
    + **Description**: Minifies CSS files with YUICompressor
    * **Website**: http://github.com/yui/yuicompressor
+ CSSEmbed
    + **Name**: `cssembed`
    + **Description**: Embeds all CSS url() images as Base64 encoded images
    + **Configuration**:
        + max-uri-length=[integer]
        + max-image-size=[integer]
    * **Website**: http://github.com/nzakas/cssembed/

### For JavaScript

+ Merge (default)
    + **Name**: `merge`
    + **Description:**
        Joins all given source files by type (js, css) into one file. If not
        other merge task is in the chain this one is prepended as first one.
+ Coffee-Script
    + **Name**: `coffeeScript`
    + **Description:**
        Compiles all .coffee files into one JavaScript. Needs to be called
        before `merge`. So set merge as second step (e.g. `coffeeScript,merge`)!
        This processors - if configured - operates on all found js files.
    + **Configuration**:
        + bare=[true|false]
        + header=[true|false]
    * **Website**: http://github.com/jashkenas/coffee-script
    * **Versions**: 1.3.3, 1.4.0, 1.5.0, 1.6.3, 1.7.1
+ Typescript
    + **Name**: `typescript`
    + **Description:**
        Compiles all .ts files into one JavaScript. Needs to be called before
        `merge`. So set merge as second step: `typescript,merge`!
    * **Website**: http://www.typescriptlang.org/
+ Closure Compiler
    + **Name**: `closure`
    + **Description:**
        Minifies JavaScript files with Closure Compiler.
    * **Website**: https://code.google.com/p/closure-compiler/
+ UglifyJS
    + **Name**: `uglifyjs`
    + **Description:**
        Minifies JavaScript files with UglifyJS.
    * **Website**: http://github.com/mishoo/UglifyJS
+ JS Hint
    + **Name**: `jshint`
    + **Description:**
        Tests JavaScript files with JS Hint and returns it's output.
    + **Configuration**:
        + Just configure the options from the jshint docs
    * **Website**: http://github.com/jshint/jshint
    * **Versions**: 1.1.0, 2.4.3
+ eslint
    + **Name**: `esint`
    + **Description:**
        Tests JavaScript files with eslint and returns it's output.
    + **Configuration**:
    * **Website**: http://eslint.org/
    * **Versions**: 0.7.4
+ browserify
    + **Name**: `browserify`
    + **Description:**
        Resolves CommonJS modules to be browser ready. This is a merge task.
    + **Configuration**:
        + aliases=["file#alias", "file#alias"]
    * **Website**: http://browserify.org/
+ sweet.js
    + **Name**: `sweetjs`
    + **Description:**
        Sweet.js brings the hygienic macros of languages like Scheme and Rust
        to JavaScript.
        This processors - if configured - operates on all found js files.
    * **Website**: http://sweetjs.org/

### For SVG

+ SVGO
    + **Name**: `svgo`
    + **Description**: Optmimizes SVG images
      This processors - if configured - operates on all found svg files.
    * **Website**: https://github.com/svg/svgo
    * **Versions**: 0.3.7

Configurations
--------------

### General Configuration

A smaller configuration is specified by some information.

* A client configuration for the choosen build-tool (Maven, Ant, Grunt, ...)
* A config file specified by
  [Smaller config](https://github.com/KnisterPeter/smaller-config)

### Maven Plugin

Use the maven plugin to utilize the smaller webservice:

    <plugin>
      <groupId>de.matrixweb.smaller</groupId>
      <artifactId>smaller-maven-plugin</artifactId>
      <version>0.8.0-SNAPSHOT</version>
      <configuration>
        <host>localhost</host>
        <port>1148</port>
        <proxyhost>localhost</proxyhost>
        <proxyport>8080</proxyport>
        <target>target/smaller</target>
        <config-file>${basedir}/smaller.yml</config-file>
      </configuration>
    </plugin>

Or use the standalone maven plugin if you do not want to use the webservice:

    <plugin>
      <groupId>de.matrixweb.smaller</groupId>
      <artifactId>smaller-maven-standalone-plugin</artifactId>
      <version>0.8.0-SNAPSHOT</version>
      <configuration>
        <target>target/smaller</target>
        <config-file>${basedir}/smaller.yml</config-file>
      </configuration>
    </plugin>

### Ant Task

    <taskdef name="smaller" classname="de.matrixweb.smaller.clients.ant.SmallerTask" classpath="../../../../target/classes" />

    <target name="smaller">
      <smaller
          host="localhost"
          port="1148"
          proxyhost="localhost"
          proxyport="8080"
          target="target/smaller"
          configFile="${basedir}/smaller.yml"
          />
    </target>

Or use the standalone ant task if you do not want to use the webservice, just
replace the ant-client jar file with the standalone version.

### Webservice Standalone

Just start the standalone build which has a main method included.
Parameters are port and ip-address to bind to in this order.

### OSGi bundles

Start the osgi-server module with one of the supplied scripts start.sh or start-local.sh.
This either downloads dependencies from maven central or from a local maven repository.

### OSGi client

In this mode smaller scans installed OSGi bundles for matching resources and
builds on that. This is useful if Smaller should be embedded in an OSGi
application during runtime.

The configuration is fetched from a bundle with the header 'Smaller-Config'.
There could be more than one of this bundles. For each environment in the
config files found, one servlet with the target process-address is registered.

For simple [Apache Karaf](http://karaf.apache.org/) deployment execute the following in the shell:

    features:addurl mvn:de.matrixweb.smaller/smaller-osgi/0.8.0/xml/features
    features:install smaller-browserify
    features:install smaller-lessjs
    ...

### Embeddable Servlet

    <servlet>
      <servlet-name>smaller</servlet-name>
      <servlet-class>de.matrixweb.smaller.servlet.SmallerServlet</servlet-class>
      <init-param>
        <param-name>processors</param-name>
        <param-value>closure,lessjs</param-value>
      </init-param>
      <init-param>
        <param-name>includes</param-name>
        <param-value>**/*.js,**/*.less</param-value>
      </init-param>
      <init-param>
        <param-name>excludes</param-name>
        <param-value>**/*.bin</param-value>
      </init-param>
      <init-param>
        <param-name>options</param-name>
        <param-value>output:out-only=true</param-value>
      </init-param>
    </servlet>
    <servlet-mapping>
      <servlet-name>smaller</servlet-name>
      <url-pattern>/css/style.css</url-pattern>
    </servlet-mapping>
    <servlet-mapping>
      <servlet-name>smaller</servlet-name>
      <url-pattern>/js/masic-min.js</url-pattern>
    </servlet-mapping>

The config file format
----------------------

    # Block for build-server options
    build-server:
        output-only: true
        # Defines the environemnts to execute during build server run
        environments:
            - js-prod
            - css

    # Block for development-server options
    dev-server:
        # ip to bind the server to
        ip: 0.0.0.0
        # port to listen on
        port: 12345
        # the proxy to connect to
        proxyhost: localhost
        proxyport: 3000
        #
        debug: false
        # True to enable live-reload injection into the page
        live-reload: true
        # Defines the environemnts to execute during dev server run
        environments:
            - js
            - css
            - templates

    # The environments specify processing instructions
    # It is best to have one environment for each process-url you want
    # to be processed by smaller
    environments:
        js:
            # Defines the url to intercept/process
            process: "/app.js"

            # In case of js testing specify the used framework here
            test-framework: jasmine

            # The files block defines the document-roots and included/excluded
            # files which should be included for processing
            files:
                # Multiple document-roots could be specifed. If there are
                # naming conflicts the first file always wins.
                folder:
                    - "doc-root1"
                    - "doc-root2"
                includes:
                    - "**/*.coffee"
                    - "**/*.js"
                excludes:
                    - "**/*.jpg"

            # The same as the files block but for test-code to separate test
            # and production code
            test-files:
                folder:
                    - "./tests-root1"
                    - "./tests-root2"
                includes:
                excludes:

            # Defines the used processors with all its options.
            # Usually only the first processor needs a 'src' definition since
            # the output of the first is the input of the second (and so on).
            # The last one gives its output to the url specifed in the 'process'
            # block above.
            # The order in this block does not matter, it is specifed in the
            # 'pipeline' list below.
            processors:
                coffeeScript:
                    src: "/main.coffee"
                    options:
                        source-maps: true
                        bare: true
                browserify:
                    options:
                        aliases:
                            "./some-file": library

            # The order in which to execute the processors
            pipeline:
                - coffeeScript
                - browserify

        js-prod:
            # This specifies the base configuration this one is derived from
            inherits: js
            # Folders are overwritten in an inherited configuration
            folder:
                - "doc-root1"
            processors:
                # Processors are added to the inherited configuration
                uglifyjs:
            # The pipeline is as well overwritten to define the order of execution
            # in the current environment
            pipeline:
                - coffeeScript
                - browserify
                - uglifyjs

        css:
            process: "/style.css"
            files:
                folder:
                    - "dir1"
                includes:
                    - "**/*.less"
                excludes:
                    - "**/*.bin"
            processors:
                lessjs:
                    src: "/main.less"
            pipeline:
                - lessjs

        templates:
            templates: handlebars
            files:
                folder:
                    - "dir1"
                    - "dir2"
                includes:
                    - "**/*.hbs"

Developer information
---------------------
[Additional documentation](https://github.com/KnisterPeter/Smaller/wiki)

Credits
-------

Thanks to [SinnerSchrader](http://www.sinnerschrader.com/) for their support
and the time to work on this project.


text:
/**
 * Created by tungtouch on 2/12/15.
 */
var sys = require('sys'),
    http = require('http');
var i=0;
http.createServer(function(req, res) {
    i++;
    res.writeHead(200, {'Content-Type': 'text/html'});
    res.write('
Hello World
',i++);
    console.log("Request server:", i++, req)
    res.end();
}).listen(7878);
console.log("Server running: 7878");


text:
using System.Collections.Generic;

namespace YubicoDotNetClient
{
    public interface IYubicoResponse
    {
        /// <summary>
        /// Get the servers signature of the response.
        /// </summary>
        /// <returns>Base64 of hmac-sha1 of the response concatenated as url</returns>
        string H { get; }

        /// <summary>
        /// Get the servers response of the timestamp.
        /// </summary>
        /// <returns>timestamp in UTC</returns>
        string T { get; }

        /// <summary>
        /// The response status
        /// </summary>
        /// <returns>status of the response</returns>
        YubicoResponseStatus Status { get; }

        /// <summary>
        /// The YubiKey internal timestamp when OTP was generated
        /// </summary>
        /// <returns>YubiKey internal 8hz timestamp</returns>
        int Timestamp { get; }

        /// <summary>
        /// The YubiKey internal sessionCounter
        /// </summary>
        /// <returns>the YubiKey session counter, counting up for each key press</returns>
        int SessionCounter { get; }

        /// <summary>
        /// The YubiKey internal useCounter
        /// </summary>
        /// <returns>the YubiKey use counter, counts up for each powerup</returns>
        int UseCounter { get; }

        /// <summary>
        /// The Syncronization achieved
        /// </summary>
        /// <returns>syncronization achieved in percent</returns>
        string Sync { get; }

        /// <summary>
        /// The OTP asked about
        /// </summary>
        /// <returns>the OTP that the server is returning a result for</returns>
        string Otp { get; }

        /// <summary>
        /// The nonce that was sent in the request
        /// </summary>
        /// <returns>the nonce that was sent to the server in the request</returns>
        string Nonce { get; }

        /// <summary>
        /// A map of all results returned
        /// </summary>
        /// <returns>map of the results returned from the server</returns>
        IEnumerable<KeyValuePair<string, string>> ResponseMap { get; }

        /// <summary>
        /// The publicId of the OTP this response is about
        /// </summary>
        /// <returns>the publicId for the OTP</returns>
        string PublicId { get; }

        /// <summary>
        /// The URL used to get this response
        /// </summary>
        /// <returns>the URL where this response came from</returns>
        string Url { get; }
    }
}


text:
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:tools="http://schemas.android.com/tools"
    xmlns:app="http://schemas.android.com/apk/res-auto"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    android:orientation="vertical"
    tools:context="tk.trocagame.trocagame.view.fragments.InicioFragment">

    <android.support.design.widget.AppBarLayout
        android:id="@+id/appbar"
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:paddingTop="@dimen/appbar_padding_top"
        android:theme="@style/AppTheme.AppBarOverlay">

        <android.support.design.widget.TabLayout
            android:id="@+id/tabs"
            app:tabGravity="fill"
            app:tabMode="scrollable"
            android:layout_width="match_parent"
            android:layout_height="wrap_content" />

    </android.support.design.widget.AppBarLayout>

    <android.support.v4.view.ViewPager
        android:id="@+id/container"
        android:layout_width="match_parent"
        android:layout_height="match_parent"
        app:layout_behavior="@string/appbar_scrolling_view_behavior" />

</LinearLayout>


text:
using System.Diagnostics.CodeAnalysis;
using System.Linq.Expressions;
using System.Reflection;

using IX.StandardExtensions.Contracts;

// ReSharper disable once CheckNamespace
namespace IX.StandardExtensions.Threading;

public partial class AtomicEnumerator<TItem>
{
    /// <summary>
    ///     Creates an atomic enumerator from a collection.
    /// </summary>
    /// <typeparam name="TCollection">The type of the collection.</typeparam>
    /// <param name="collection">The collection.</param>
    /// <param name="readLock">The function to acquire a read lock.</param>
    /// <returns>The created atomic enumerator.</returns>
    /// <exception cref="ArgumentNullException">
    ///     <paramref name="collection" />
    ///     or
    ///     <paramref name="readLock" />
    ///     is <c>null</c> (<c>Nothing</c> in Visual Basic).
    /// </exception>
    [global::System.Diagnostics.CodeAnalysis.SuppressMessage(
        "Performance",
        "HAA0303:Lambda or anonymous method in a generic method allocates a delegate instance",
        Justification = "We need this instance allocated.")]
    [global::System.Diagnostics.CodeAnalysis.SuppressMessage(
        "Design",
        "CA1000:Do not declare static members on generic types",
        Justification = "This is, honestly, a stupid rule.")]
    [global::System.Diagnostics.CodeAnalysis.SuppressMessage(
        "Performance",
        "HAA0401:Possible allocation of reference type enumerator",
        Justification = "Not an issue, since we're returning a class-based atomic enumerator anyway.")]
    [Obsolete("This method will be removed in the next breaking changes release.")]
    [ExcludeFromCodeCoverage]
    public static AtomicEnumerator<TItem> FromCollection<TCollection>(
        TCollection collection,
        Func<ReadOnlySynchronizationLocker> readLock)
        where TCollection : class, IEnumerable<TItem>
    {
        // Validate arguments
        _ = Requires.NotNull(collection);
        _ = Requires.NotNull(readLock);

        Delegate initializer = OldConstructionDelegates.GetOrAdd(
            collection.GetType(),
            static (collectionType) =>
            {
                // Get used types
                MethodInfo getEnumeratorMethodInfo = collectionType.GetMethod(
                    "GetEnumerator",
                    BindingFlags.Public | BindingFlags.Instance)!;

                Type enumeratorType = getEnumeratorMethodInfo.ReturnType;
                Type atomicEnumeratorType = typeof(AtomicEnumerator<,>).MakeGenericType(
                    typeof(TItem),
                    enumeratorType);
                ConstructorInfo atomicEnumeratorConstructorInfo = atomicEnumeratorType.GetConstructors()
                    .Single(
                        p => p.GetParameters()[1]
                              .ParameterType == typeof(Func<ReadOnlySynchronizationLocker>));

                // Prepare parameter expressions
                ParameterExpression parameter1 = Expression.Parameter(collectionType);
                ParameterExpression parameter2 = Expression.Parameter(typeof(Func<ReadOnlySynchronizationLocker>));

                // Prepare expression
                return Expression.Lambda(
                                     Expression.New(
                                         atomicEnumeratorConstructorInfo,
                                         Expression.Call(
                                             parameter1,
                                             getEnumeratorMethodInfo),
                                         parameter2),
                                     parameter1,
                                     parameter2)
                                 .Compile();
            });

        if (initializer is Func<TCollection, Func<ReadOnlySynchronizationLocker>, AtomicEnumerator<TItem>>
            typedInitializer)
        {
            return typedInitializer(
                collection,
                readLock);
        }

        return (AtomicEnumerator<TItem>)initializer.DynamicInvoke(
            collection,
            readLock)!;
    }

    /// <summary>
    ///     Creates an atomic enumerator from an already-existing enumerator.
    /// </summary>
    /// <typeparam name="TEnumerator">The type of the enumerator.</typeparam>
    /// <param name="enumerator">The enumerator.</param>
    /// <param name="readLock">The function to acquire a read lock.</param>
    /// <returns>The created atomic enumerator.</returns>
    /// <exception cref="ArgumentNullException">
    ///     <paramref name="enumerator" />
    ///     or
    ///     <paramref name="readLock" />
    ///     is <c>null</c> (<c>Nothing</c> in Visual Basic).
    /// </exception>
    [global::System.Diagnostics.CodeAnalysis.SuppressMessage(
        "Design",
        "CA1000:Do not declare static members on generic types",
        Justification = "This is, honestly, a stupid rule.")]
    [Obsolete("This method will be removed in the next breaking changes release.")]
    [ExcludeFromCodeCoverage]
    public static AtomicEnumerator<TItem> FromEnumerator<TEnumerator>(
        TEnumerator enumerator,
        Func<ReadOnlySynchronizationLocker> readLock)
        where TEnumerator : IEnumerator<TItem>
    {
        _ = Requires.NotNull(enumerator);
        _ = Requires.NotNull(readLock);

        return new AtomicEnumerator<TItem, TEnumerator>(
            enumerator,
            readLock);
    }
}


text:
// ==========================================================================
//  Squidex Headless CMS
// ==========================================================================
//  Copyright (c) Squidex UG (haftungsbeschränkt)
//  All rights reserved. Licensed under the MIT license.
// ==========================================================================

using System;
using Squidex.Domain.Apps.Events;
using Squidex.Infrastructure.EventSourcing;
using Squidex.Infrastructure.Reflection;

namespace Migrate_01.OldEvents
{
    [EventType(nameof(AppClientChanged))]
    [Obsolete]
    public sealed class AppClientChanged : AppEvent, IMigratedEvent
    {
        public string Id { get; set; }

        public bool IsReader { get; set; }

        public IEvent Migrate()
        {
            var permission = IsReader ? AppClientPermission.Reader : AppClientPermission.Editor;

            return SimpleMapper.Map(this, new AppClientUpdated { Permission = permission });
        }
    }
}


text:
module LetsShopMapper
  module Model
    module Base
      class Facet
        attr_reader :title
        attr_reader :type
        attr_reader :filter
        attr_reader :role
        attr_reader :selected
        attr_reader :nhits
        attr_reader :xml

        def initialize(facet = nil)
          @xml = facet
          @title, @type, @filter, @role, @selected, @nhits = nil
          @selected = false
          parse(facet) if facet
        end

        def parse(facet)
          @title = facet['title'].split(":")[1]
          @type = facet['title'].split(":")[0]
          @filter = Filter::new(facet['title'])
          @role = facet['role']
          if facet['nhits']
            @nhits = facet['nhits']
          end
          if facet['selected']
            @selected = LetsShopMapper.Boolean(facet['selected'])
          end
        end

        def to_s(localtime = true)
          s  = ''
          s += "Title: #{@title}\n"
          s += "Type: #{@type}\n"
          s += "Filter: #{@filter.str_value}\n"
          s += "Role: #{@role}\n"
          s += "Selected: #{@selected}\n"
          s += "nhits: #{@nhits}\n"
          s += "\n"
        end
      end
    end
  end
end


text:
package feature.format

import feature._

/** A record representing the information contained in one line of a file in GTF2.2 feature.format
  * ([[http://mblab.wustl.edu/GTF22.html feature.format specification]])
  *
  * @param line String containing one valid GTF2.2 line with or without trailing newline character
  */
class GTF22Record(private val line: String) extends FeatureBuilderModifier {

  // Remove trailing comment, then trailing whitespace, then final semicolon
  private val trimmed: String = line.split("#")(0).replaceAll("""\s+$""", "").replaceAll(";$", "")

  // Fields are tab-separated
  private val tokens: Array[String] = trimmed.split("\t")

  validate()

  private def validate(): Unit = {
    if (!isComment) {
      // Can't have two tabs in a row
      if (tokens.contains(""))
        throw new IllegalArgumentException(s"Malformed GTF2.2 line. Empty field.\n$line")
      // Must have at least 9 tab-separated fields
      if (tokens.length < 9)
        throw new IllegalArgumentException(s"Invalid GTF2.2 line. Must have at least 9 tab-separated fields.\n$line")
      if (start >= end)
        throw new IllegalArgumentException(s"Invalid GTF2.2 line. Invalid start and end.\n$line")
      if (start < 0)
        throw new IllegalArgumentException(s"Invalid GTF2.2 line. Invalid start position.\n$line")
      if (frame.isDefined && (frame.get < 0 || frame.get > 2))
        throw new IllegalArgumentException(s"Invalid GTF2.2 line. Invalid frame.\n$line")
      // Compute lazy orientation and score so they get validated
      val o = orientation
      val s = score
      if (!ignore) {
        featureType match {
          case _: MatureRNA =>
            // Check for required attributes gene_id and transcript_id
            if (!attributes.contains("gene_id"))
              throw new IllegalArgumentException(s"Invalid GTF2.2 line. Must have gene_id attribute.\n$line")
            if (!attributes.contains("transcript_id"))
              throw new IllegalArgumentException(s"Invalid GTF2.2 line. Must have transcript_id attribute.\n$line")
          case _ => Unit
        }
      }
    }
  }

  /** True if the line represents a comment (starting with '#'), false otherwise. */
  lazy val isComment: Boolean = line.startsWith("#")

  /** True if the line is to be ignored, either because it is a comment or because
    * the feature type is not supported (see [[http://mblab.wustl.edu/GTF22.html feature.format specification]]).
    */
  lazy val ignore: Boolean = isComment || featureType == Ignore

  /** The chromosome or reference sequence name. */
  lazy val chr: String = tokens(0).replaceFirst("^chr", "")

  /** The annotation source (see [[http://mblab.wustl.edu/GTF22.html feature.format specification]]). */
  lazy val source: String = tokens(1)

  /** The feature type. For valid values see [[http://mblab.wustl.edu/GTF22.html feature.format specification]]. */
  lazy val featureType: FeatureType = FeatureType.forLabel(tokens(2))

  /** Zero-based start position in reference coordinates, inclusive.
    *
    * GTF2.2 feature.format uses 1-based positions. This library uses 0-based positions.
    * Therefore, this value has been converted to a 0-based position. The start position
    * is the first position that is included in the feature.
    */
  lazy val start: Int = Utils.zeroBasedInclusiveStart(tokens(3).toInt)

  /** Zero-based end position in reference coordinates, exclusive.
    *
    * GTF2.2 feature.format uses 1-based positions, and furthermore, uses fully closed
    * intervals so the end position is the last position included in the feature.
    * This library uses 0-based positions and half open intervals, so the end
    * position is the position after the last position included in the feature.
    * Therefore, this value is equal to the integer in the GTF2.2 file, because
    * it is theoretically converted twice for these two differences.
    *
    */
  lazy val end: Int = Utils.zeroBasedExclusiveEnd(tokens(4).toInt)

  /** The floating point score, or None if '.' is specified in the line. */
  lazy val score: Option[Float] = tokens(5) match {
    case "." => None
    case s: String => {
      try {
        Some(s.toFloat)
      } catch {
        case n: NumberFormatException => throw new IllegalArgumentException(s"Invalid GTF2 line. Invalid score.\n$line")
      }
    }
  }

  /** The [[Orientation]].
    *
    * This value is equal to [[Plus]] if '+' is specified in the file or [[Minus]] if
    * '-' is specified.
    *
    */
  lazy val orientation: Orientation = tokens(6) match {
    case "+" => Plus
    case "-" => Minus
    case _ => throw new IllegalArgumentException(s"Invalid GTF2 orientation.\n$line")
  }

  /** The frame, or None if '.' is specified in the file. */
  lazy val frame: Option[Int] = tokens(7) match {
    case "." => None
    case s: String => Some(s.toInt)
  }

  /** Map of attribute name to value.
    *
    * Empty attributes (having value "") are not included in this map.
    *
    * See [[http://mblab.wustl.edu/GTF22.html feature.format specification]] for details on GTF2.2 attributes.
    *
    */
  lazy val attributes: Map[String, String] = {
    // Map of attribute name to attribute value
    val as = new scala.collection.mutable.HashMap[String, String]
    // Attribute key/value pairs are separated by semicolons
    tokens(8).split("; ").foreach(s => {
      // Key and value are separated by a single space
      val ss: Array[String] = s.split(" ")
      if(ss.length < 2) throw new IllegalArgumentException(s"Invalid GTF2 attribute: $s\n$line")
      val k: String = ss.head
      // There can only be one value between double quotes
      if(ss.tail.mkString(" ").split("\"").length > 2)
        throw new IllegalArgumentException(s"Invalid GTF2 attribute spacing:\n$line")
      val v: String = ss.tail.mkString(" ").replace("\"", "") // String values are between double quotes
      if(k == "" || k.startsWith(" ")) throw new IllegalArgumentException(s"Invalid GTF2 attribute spacing: $s\n$line")
      if(v.startsWith(" ")) throw new IllegalArgumentException(s"Invalid GTF2 attribute spacing:\n$line")
      // Skip empty string attribute values
      if(v != "") as.put(k, v)
    })
    // Convert to an immutable map
    as.toMap
  }

  /** Transcript ID, or None if attribute value is "" */
  lazy val transcriptId: Option[String] = attributes.get("transcript_id")

  /** Gene ID, or None if attribute value is "" */
  lazy val geneId: Option[String] = attributes.get("gene_id")

  /** Returns a new [[FeatureBuilder]] consisting of the passed [[FeatureBuilder]] with
    * the information in this [[GTF22Record]] added to it.
    *
    * The feature type must not be one of the CNS types (see [[http://mblab.wustl.edu/GTF22.html feature.format specification]])
    * as these features are specified on a single GTF2.2 line and should not be incorporated into an existing
    * [[FeatureBuilder]]. The feature type must also not be an ignored type.
    *
    * @param fb Original [[FeatureBuilder]] with the same transcript ID and gene ID as this record
    * @return New [[FeatureBuilder]] with additional information from this record incorporated
    */
  override def op(fb: FeatureBuilder): FeatureBuilder = {

    // Only operate on the FeatureBuilder if it has the same transcript ID and gene ID as this record
    if(transcriptId != fb.featureId)
      throw new IllegalArgumentException(s"Transcript ID ($transcriptId) must be equal to existing feature ID (${fb.featureId})")

    if(geneId != fb.geneId)
      throw new IllegalArgumentException(s"Gene ID ($geneId) must be equal to existing gene ID (${fb.geneId})")

    // Create the block for this record
    val blk = Block(chr, start, end, orientation)

    featureType match {
      // Assume the CDS will be specified so don't do anything special with start codon, 5'-UTR, 3'-UTR
      case Exon | StartCodon | UTR5 | UTR3 => fb.addBlock(blk)
      // Include the stop codon in our CDS
      case CDS | StopCodon =>
        fb.addBlock(blk).setCdsStart(Utils.updateCdsStart(fb, start)).setCdsEnd(Utils.updateCdsEnd(fb, end))
      // These feature types must have only one block
      case Intergenic | IntergenicCNS | IntronicCNS | Ignore =>
        throw new IllegalArgumentException("Only feature types representing parts of transcripts can be used" +
          s"to update a ${classOf[FeatureBuilder].getName}. GTF2.2 line:\n$line")
    }

  }

}

private object Utils {

  /*
   Update CDS start after encountering a new block.
   Replace existing start if new start is less, or add new start if doesn't exist yet
    */
  def updateCdsStart(fb: FeatureBuilder, ns: Int): Int = if(fb.cdsStart.isDefined) math.min(ns, fb.cdsStart.get) else ns

  /*
   Update CDS end after encountering a new block.
   Replace existing end if new end is greater, or add new end if doesn't exist yet
    */
  def updateCdsEnd(fb: FeatureBuilder, ne: Int): Int = if(fb.cdsEnd.isDefined) math.max(ne, fb.cdsEnd.get) else ne

  def zeroBasedInclusiveStart(gtf2start: Int): Int = gtf2start - 1

  def zeroBasedExclusiveEnd(gtf2end: Int): Int = gtf2end

}

/** A GTF2.2 feature type */
sealed trait FeatureType {val name: String}

/** A GTF2.2 feature type that represents part of a mature RNA transcript */
sealed trait MatureRNA extends FeatureType

/** GTF2.2 CDS feature type */
case object CDS extends MatureRNA {val name = "CDS"}

/** GTF2.2 start codon feature type */
case object StartCodon extends MatureRNA {val name = "start_codon"}

/** GTF2.2 stop codon feature type */
case object StopCodon extends MatureRNA {val name = "stop_codon"}

/** GTF2.2 5'-UTR feature type */
case object UTR5 extends MatureRNA {val name = "5UTR"}

/** GTF2.2 3'-UTR feature type */
case object UTR3 extends MatureRNA {val name = "3UTR"}

/** GTF2.2 intergenic feature type */
case object Intergenic extends FeatureType {val name = "inter"}

/** GTF2.2 intergenic CNS feature type */
case object IntergenicCNS extends FeatureType {val name = "inter_CNS"}

/** GTF2.2 intronic CNS feature type */
case object IntronicCNS extends FeatureType {val name = "intron_CNS"}

/** GTF2.2 exon feature type */
case object Exon extends MatureRNA {val name = "exon"}

/** Nonstandard feature type. See [[http://mblab.wustl.edu/GTF22.html feature.format specification]] for details. */
case object Ignore extends FeatureType {val name = "ignore"}

/** Utilities for GTF2.2 [[FeatureType]]s */
object FeatureType {

  /** Returns the [[FeatureType]] specified by the GTF2.2 value
    *
    * @param label GTF2.2 feature type label
    */
  def forLabel(label: String): FeatureType = {
    label match {
      case Exon.name => Exon
      case CDS.name => CDS
      case StartCodon.name => StartCodon
      case StopCodon.name => StopCodon
      case UTR5.name => UTR5
      case UTR3.name => UTR3
      case Intergenic.name => Intergenic
      case IntergenicCNS.name => IntergenicCNS
      case IntronicCNS.name => IntronicCNS
      case _ => Ignore
    }
  }
}


text:
package com.reucon.commons.operation;

import org.junit.Before;
import org.junit.Test;

import javax.sql.DataSource;
import java.sql.Connection;
import java.sql.DatabaseMetaData;
import java.sql.SQLException;
import java.util.Properties;

import static org.hamcrest.MatcherAssert.assertThat;
import static org.hamcrest.Matchers.is;
import static org.hamcrest.Matchers.nullValue;
import static org.mockito.Mockito.*;

public class OperationalEnvironmentBuilderTest
{
    private Properties systemProperties;
    private DataSource dataSource;
    private Connection connection;
    private DatabaseMetaData meta;
    private OperationalEnvironmentBuilder builder;

    @Before
    public void setUp() throws Exception
    {
        systemProperties = new Properties();
        dataSource = mock(DataSource.class);
        connection = mock(Connection.class);
        meta = mock(DatabaseMetaData.class);
        when(dataSource.getConnection()).thenReturn(connection);
        when(connection.getMetaData()).thenReturn(meta);

        builder = new OperationalEnvironmentBuilder();
    }

    @Test
    public void testBuild() throws Exception
    {
        systemProperties.put("java.vendor", "Oracle Corporation");
        systemProperties.put("java.version", "1.7.0_02");
        systemProperties.put("os.name", "Linux");
        systemProperties.put("os.version", "3.0.0-16-generic");

        when(meta.getDatabaseProductName()).thenReturn("MySQL");
        when(meta.getDatabaseMajorVersion()).thenReturn(1);
        when(meta.getDatabaseMinorVersion()).thenReturn(2);
        when(meta.getDriverMajorVersion()).thenReturn(3);
        when(meta.getDriverMinorVersion()).thenReturn(4);

        final OperationalEnvironment env = builder.build(systemProperties, dataSource);

        assertThat(env.getJvmVendor(), is("Oracle Corporation"));
        assertThat(env.getJvmVersion(), is("1.7.0_02"));
        assertThat(env.getOsName(), is("Linux"));
        assertThat(env.getOsVersion(), is("3.0.0-16-generic"));

        assertThat(env.getDatabaseProductName(), is("MySQL"));
        assertThat(env.getDatabaseMajorVersion(), is(1));
        assertThat(env.getDatabaseMinorVersion(), is(2));
        assertThat(env.getJdbcDriverMajorVersion(), is(3));
        assertThat(env.getJdbcDriverMinorVersion(), is(4));

        verify(connection).close();
    }

    @Test
    public void testBuildWithoutDataSource() throws Exception
    {
        systemProperties.put("java.vendor", "Oracle Corporation");
        systemProperties.put("java.version", "1.7.0_02");
        systemProperties.put("os.name", "Linux");
        systemProperties.put("os.version", "3.0.0-16-generic");

        final OperationalEnvironment env = builder.build(systemProperties, null);

        assertThat(env.getJvmVendor(), is("Oracle Corporation"));
        assertThat(env.getJvmVersion(), is("1.7.0_02"));
        assertThat(env.getOsName(), is("Linux"));
        assertThat(env.getOsVersion(), is("3.0.0-16-generic"));

        assertThat(env.getDatabaseProductName(), is(nullValue()));
        assertThat(env.getDatabaseMajorVersion(), is(nullValue()));
        assertThat(env.getDatabaseMinorVersion(), is(nullValue()));
        assertThat(env.getJdbcDriverMajorVersion(), is(nullValue()));
        assertThat(env.getJdbcDriverMinorVersion(), is(nullValue()));
    }

    @Test
    public void testBuildWithSqlException() throws Exception
    {
        systemProperties.put("java.vendor", "Oracle Corporation");
        when(meta.getDatabaseProductName()).thenThrow(new SQLException("Error when retrieving database product name"));

        final OperationalEnvironment env = builder.build(systemProperties, dataSource);

        assertThat(env.getJvmVendor(), is("Oracle Corporation"));

        assertThat(env.getDatabaseProductName(), is(nullValue()));
        assertThat(env.getDatabaseMajorVersion(), is(nullValue()));
        assertThat(env.getDatabaseMinorVersion(), is(nullValue()));
        assertThat(env.getJdbcDriverMajorVersion(), is(nullValue()));
        assertThat(env.getJdbcDriverMinorVersion(), is(nullValue()));

        verify(connection).close();
    }
}


text:
<?xml version="1.0" encoding="utf-8"?>
<layout xmlns:android="http://schemas.android.com/apk/res/android">

    <data>

        <variable
            name="text"
            type="String" />
        <variable
            name="onClick"
            type="android.view.View.OnClickListener" />

    </data>

    <LinearLayout
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:orientation="vertical">

        <TextView
            android:layout_width="match_parent"
            android:layout_height="wrap_content"
            android:padding="20dp"
            android:onClick="@{onClick}"
            android:text="@{text}"
            android:background="?attr/selectableItemBackground"/>
        <View
            android:layout_width="match_parent"
            android:layout_height="1dp"
            android:background="#80000000"/>
    </LinearLayout>

</layout>


text:
import java.util.Arrays;
import java.util.List;

public class Main {
  private static String test(List<String> list) {
    return list == null ? null : list.stream().filter(str -> str.contains("x")).find<caret>First().orElse(null);
  }

  public static void main(String[] args) {
    System.out.println(test(Arrays.asList("a", "b", "syz")));
  }
}


text:
title: Hope Sabbath School Outline
date: 30/07/2021
---

### Outline #5	The Invitation of Jesus: "Come to Me"

*  The promise of Jesus to give rest for our souls
    * Matthew 11:28 What is necessary on our part in order to receive rest for our souls from Jesus?
    * The verb "Come" is an imperative—a command or earnest appeal. Why is this invitation of Jesus so urgent?
    * Anyone can offer rest. How can we be certain Jesus is able to fulfill His promise? Matthew 11:27
    * What hinders people from coming to Jesus and finding rest for their souls? Matthew 11:21-24, Romans 10:14
    * What burdens might Satan tempt us to pick up in an attempt to disrupt our rest in Jesus?

*  The yoke Jesus offers
    * Matthew 11:29-30 What is a yoke? What does Jesus mean when He says, "Take My yoke upon you"?
    * A disciple is a learner. What lessons do we need to "learn" from Jesus?
    * When did Jesus call you to become His disciple (to learn from Him)? How has your life changed since you responded to His invitation?

*  Modeling gentleness and meekness
    * Matthew 11:29 What does it mean to be gentle and lowly in heart?
    * The apostle Paul speaks of the "meekness and gentleness of Christ" (2 Corinthians 10:1). Give examples of Jesus modeling meekness and gentleness.
    * Why is the characteristic of meekness so important for a disciple of Jesus? Matthew 5:5, Isaiah 57:15

*  The pleasant yoke
    * Matthew 11:30 Why is the yoke Jesus offers us "easy" or "pleasant"?
    * The New Testament speaks of trying to save ourselves by our own good works as a yoke of bondage (Galatians 5:1). When did you come to the realization that salvation comes through connecting with Jesus as your loving and merciful Savior?

*  The light burden
    * Matthew 11:30 What is the light burden Jesus offers in exchange for our heavy burdens? (see Luke 10:2)
    * Review the life of Jesus. Where do you see evidences of His burden for the lost? Luke 19:10
    * Why is His burden light? Hebrews 12:1-3
    * How does caring for the lost fulfill the law of Christ? Galatians 6:2
    * Share a time when you felt a burden for those who don't know Jesus. How did you respond?

Hope Sabbath School Outline is provided by Hope Channel. Learn more here: https://www.hopetv.org/hopess/


text:
package fee

import (
	"net/http"

	stripe "github.com/stripe/stripe-go"
	"github.com/stripe/stripe-go/form"
)

// Client is used to invoke application_fees APIs.
type Client struct {
	B   stripe.Backend
	Key string
}

// Get returns the details of an application fee.
func Get(id string, params *stripe.ApplicationFeeParams) (*stripe.ApplicationFee, error) {
	return getC().Get(id, params)
}

// Get returns the details of an application fee.
func (c Client) Get(id string, params *stripe.ApplicationFeeParams) (*stripe.ApplicationFee, error) {
	path := stripe.FormatURLPath("/v1/application_fees/%s", id)
	fee := &stripe.ApplicationFee{}
	err := c.B.Call(http.MethodGet, path, c.Key, params, fee)
	return fee, err
}

// List returns a list of application fees.
func List(params *stripe.ApplicationFeeListParams) *Iter {
	return getC().List(params)
}

// List returns a list of application fees.
func (c Client) List(listParams *stripe.ApplicationFeeListParams) *Iter {
	return &Iter{stripe.GetIter(listParams, func(p *stripe.Params, b *form.Values) ([]interface{}, stripe.ListMeta, error) {
		list := &stripe.ApplicationFeeList{}
		err := c.B.CallRaw(http.MethodGet, "/v1/application_fees", c.Key, b, p, list)

		ret := make([]interface{}, len(list.Data))
		for i, v := range list.Data {
			ret[i] = v
		}

		return ret, list.ListMeta, err
	})}
}

// Iter is an iterator for application fees.
type Iter struct {
	*stripe.Iter
}

// ApplicationFee returns the application fee which the iterator is currently pointing to.
func (i *Iter) ApplicationFee() *stripe.ApplicationFee {
	return i.Current().(*stripe.ApplicationFee)
}

func getC() Client {
	return Client{stripe.GetBackend(stripe.APIBackend), stripe.Key}
}


text:
package com.ghub.utils.jafw.filewatcher.core;

import java.io.File;
import java.util.HashMap;

import com.ghub.utils.jafw.filewatcher.event.FileEventType;

public abstract class AbstractFileListAdapter {

    /**
     * Gets the file.lastModified() from java.io.File
     *
     * @param file
     * @return long
     */
    protected abstract long getLastModified(File file);

    /**
     * Set a preinitialized map.
     *
     * @param masterFileMap
     */
    protected abstract void setMap(HashMap<File, Long> masterFileMap);

    /**
     * Compare the File in parameter to the one in the Map. and makes a decision
     * if its created or modified. Delete is unimplemented at this time.
     *
     * @param inProcessFile
     * @return
     */
    protected abstract FileEventType compareToMasterFile(File inProcessFile);

    /**
     * Add a file to the map.
     *
     * @param file
     */
    protected abstract void add(File file);

    /**
     * Put a file in the map with the lastModified time. This will offcourse be
     * overwritten the first time an update operation is checked.
     * if(lastModified < inComing.lastModified())
     *
     * @param file
     * @param lastModified
     */
    protected abstract void add(File file, Long lastModified);

}


text:
import MapProvider from "./mapbox";
import MapActions from "./actions";

let MapAPI = {
  /**
   * Setup the map on an element
   * @param el
   */
  launch: function(el) {
    this.mapProvider = new MapProvider({
      el: el
    });
    const map = this.mapProvider.launch();
    map.on("load", () => {
      MapActions.initMap();
    });
  },
  /**
   * Destroy the map
   */
  kill: function() {
    this.mapProvider.kill();
  },
  /**
   * Redraw the map with a new list of POIS
   * @param {Array} pois
   */
  redraw: function(pois) {
    this.plot(pois);
  },
  /**
   * Plots out an array of POIs
   * @param {Array} pois
   */
  plot: function(pois) {
    this.mapProvider.addMarkers(pois);
  },

};

export default MapAPI;


text:
package org.hibernate.proxy.pojo.javassist;
import java.io.Serializable;
import java.lang.reflect.Method;

import org.hibernate.HibernateException;
import org.hibernate.proxy.AbstractSerializableProxy;
import org.hibernate.proxy.HibernateProxy;
import org.hibernate.type.CompositeType;

/**
 * Serializable placeholder for Javassist proxies
 */
public final class SerializableProxy extends AbstractSerializableProxy {

	private Class persistentClass;
	private Class[] interfaces;
	private Class getIdentifierMethodClass;
	private Class setIdentifierMethodClass;
	private String getIdentifierMethodName;
	private String setIdentifierMethodName;
	private Class[] setIdentifierMethodParams;
	private CompositeType componentIdType;

	public SerializableProxy() {
	}

	public SerializableProxy(
			final String entityName,
			final Class persistentClass,
			final Class[] interfaces,
			final Serializable id,
			final Boolean readOnly,
			final Method getIdentifierMethod,
			final Method setIdentifierMethod,
			CompositeType componentIdType) {
		super( entityName, id, readOnly );
		this.persistentClass = persistentClass;
		this.interfaces = interfaces;
		if (getIdentifierMethod!=null) {
			getIdentifierMethodClass = getIdentifierMethod.getDeclaringClass();
			getIdentifierMethodName = getIdentifierMethod.getName();
		}
		if (setIdentifierMethod!=null) {
			setIdentifierMethodClass = setIdentifierMethod.getDeclaringClass();
			setIdentifierMethodName = setIdentifierMethod.getName();
			setIdentifierMethodParams = setIdentifierMethod.getParameterTypes();
		}
		this.componentIdType = componentIdType;
	}

	private Object readResolve() {
		try {
			HibernateProxy proxy = JavassistLazyInitializer.getProxy(
				getEntityName(),
				persistentClass,
				interfaces,
				getIdentifierMethodName==null
						? null
						: getIdentifierMethodClass.getDeclaredMethod( getIdentifierMethodName, (Class[]) null ),
				setIdentifierMethodName==null
						? null
						: setIdentifierMethodClass.getDeclaredMethod(setIdentifierMethodName, setIdentifierMethodParams),
				componentIdType,
				getId(),
				null
			);
			setReadOnlyBeforeAttachedToSession( ( JavassistLazyInitializer ) proxy.getHibernateLazyInitializer() );
			return proxy;
		}
		catch (NoSuchMethodException nsme) {
			throw new HibernateException("could not create proxy for entity: " + getEntityName(), nsme);
		}
	}
}


text:
@interface Example2ViewController : UIViewController

@end


text:
**EfficientNet** is a convolutional neural network architecture and scaling method that uniformly scales all dimensions of depth/width/resolution using a *compound coefficient*. Unlike conventional practice that arbitrary scales  these factors, the EfficientNet scaling method uniformly scales network width, depth, and resolution with a set of fixed scaling coefficients. For example, if we want to use $2^N$ times more computational resources, then we can simply increase the network depth by $\alpha ^ N$,  width by $\beta ^ N$, and image size by $\gamma ^ N$, where $\alpha, \beta, \gamma$ are constant coefficients determined by a small grid search on the original small model. EfficientNet uses a compound coefficient $\phi$ to uniformly scales network width, depth, and resolution in a  principled way.

The compound scaling method is justified by the intuition that if the input image is bigger, then the network needs more layers to increase the receptive field and more channels to capture more fine-grained patterns on the bigger image.

The base EfficientNet-B0 network is based on the inverted bottleneck residual blocks of [MobileNetV2](https://paperswithcode.com/method/mobilenetv2), in addition to [squeeze-and-excitation blocks](https://paperswithcode.com/method/squeeze-and-excitation-block).

The weights from this model were ported from [Tensorflow/TPU](https://github.com/tensorflow/tpu).

{% include 'code_snippets.md' %}

## How do I train this model?

You can follow the [timm recipe scripts](https://rwightman.github.io/pytorch-image-models/scripts/) for training a new model afresh.

## Citation

```BibTeX
@misc{tan2020efficientnet,
      title={EfficientNet: Rethinking Model Scaling for Convolutional Neural Networks},
      author={Mingxing Tan and Quoc V. Le},
      year={2020},
      eprint={1905.11946},
      archivePrefix={arXiv},
      primaryClass={cs.LG}
}
```

<!--
Type: model-index
Collections:
- Name: TF EfficientNet
  Paper:
    Title: 'EfficientNet: Rethinking Model Scaling for Convolutional Neural Networks'
    URL: https://paperswithcode.com/paper/efficientnet-rethinking-model-scaling-for
Models:
- Name: tf_efficientnet_b0
  In Collection: TF EfficientNet
  Metadata:
    FLOPs: 488688572
    Parameters: 5290000
    File Size: 21383997
    Architecture:
    - 1x1 Convolution
    - Average Pooling
    - Batch Normalization
    - Convolution
    - Dense Connections
    - Dropout
    - Inverted Residual Block
    - Squeeze-and-Excitation Block
    - Swish
    Tasks:
    - Image Classification
    Training Techniques:
    - AutoAugment
    - Label Smoothing
    - RMSProp
    - Stochastic Depth
    - Weight Decay
    Training Data:
    - ImageNet
    Training Resources: TPUv3 Cloud TPU
    ID: tf_efficientnet_b0
    LR: 0.256
    Epochs: 350
    Crop Pct: '0.875'
    Momentum: 0.9
    Batch Size: 2048
    Image Size: '224'
    Weight Decay: 1.0e-05
    Interpolation: bicubic
    RMSProp Decay: 0.9
    Label Smoothing: 0.1
    BatchNorm Momentum: 0.99
  Code: https://github.com/rwightman/pytorch-image-models/blob/9a25fdf3ad0414b4d66da443fe60ae0aa14edc84/timm/models/efficientnet.py#L1241
  Weights: https://github.com/rwightman/pytorch-image-models/releases/download/v0.1-weights/tf_efficientnet_b0_aa-827b6e33.pth
  Results:
  - Task: Image Classification
    Dataset: ImageNet
    Metrics:
      Top 1 Accuracy: 76.85%
      Top 5 Accuracy: 93.23%
- Name: tf_efficientnet_b1
  In Collection: TF EfficientNet
  Metadata:
    FLOPs: 883633200
    Parameters: 7790000
    File Size: 31512534
    Architecture:
    - 1x1 Convolution
    - Average Pooling
    - Batch Normalization
    - Convolution
    - Dense Connections
    - Dropout
    - Inverted Residual Block
    - Squeeze-and-Excitation Block
    - Swish
    Tasks:
    - Image Classification
    Training Techniques:
    - AutoAugment
    - Label Smoothing
    - RMSProp
    - Stochastic Depth
    - Weight Decay
    Training Data:
    - ImageNet
    ID: tf_efficientnet_b1
    LR: 0.256
    Epochs: 350
    Crop Pct: '0.882'
    Momentum: 0.9
    Batch Size: 2048
    Image Size: '240'
    Weight Decay: 1.0e-05
    Interpolation: bicubic
    RMSProp Decay: 0.9
    Label Smoothing: 0.1
    BatchNorm Momentum: 0.99
  Code: https://github.com/rwightman/pytorch-image-models/blob/9a25fdf3ad0414b4d66da443fe60ae0aa14edc84/timm/models/efficientnet.py#L1251
  Weights: https://github.com/rwightman/pytorch-image-models/releases/download/v0.1-weights/tf_efficientnet_b1_aa-ea7a6ee0.pth
  Results:
  - Task: Image Classification
    Dataset: ImageNet
    Metrics:
      Top 1 Accuracy: 78.84%
      Top 5 Accuracy: 94.2%
- Name: tf_efficientnet_b2
  In Collection: TF EfficientNet
  Metadata:
    FLOPs: 1234321170
    Parameters: 9110000
    File Size: 36797929
    Architecture:
    - 1x1 Convolution
    - Average Pooling
    - Batch Normalization
    - Convolution
    - Dense Connections
    - Dropout
    - Inverted Residual Block
    - Squeeze-and-Excitation Block
    - Swish
    Tasks:
    - Image Classification
    Training Techniques:
    - AutoAugment
    - Label Smoothing
    - RMSProp
    - Stochastic Depth
    - Weight Decay
    Training Data:
    - ImageNet
    ID: tf_efficientnet_b2
    LR: 0.256
    Epochs: 350
    Crop Pct: '0.89'
    Momentum: 0.9
    Batch Size: 2048
    Image Size: '260'
    Weight Decay: 1.0e-05
    Interpolation: bicubic
    RMSProp Decay: 0.9
    Label Smoothing: 0.1
    BatchNorm Momentum: 0.99
  Code: https://github.com/rwightman/pytorch-image-models/blob/9a25fdf3ad0414b4d66da443fe60ae0aa14edc84/timm/models/efficientnet.py#L1261
  Weights: https://github.com/rwightman/pytorch-image-models/releases/download/v0.1-weights/tf_efficientnet_b2_aa-60c94f97.pth
  Results:
  - Task: Image Classification
    Dataset: ImageNet
    Metrics:
      Top 1 Accuracy: 80.07%
      Top 5 Accuracy: 94.9%
- Name: tf_efficientnet_b3
  In Collection: TF EfficientNet
  Metadata:
    FLOPs: 2275247568
    Parameters: 12230000
    File Size: 49381362
    Architecture:
    - 1x1 Convolution
    - Average Pooling
    - Batch Normalization
    - Convolution
    - Dense Connections
    - Dropout
    - Inverted Residual Block
    - Squeeze-and-Excitation Block
    - Swish
    Tasks:
    - Image Classification
    Training Techniques:
    - AutoAugment
    - Label Smoothing
    - RMSProp
    - Stochastic Depth
    - Weight Decay
    Training Data:
    - ImageNet
    ID: tf_efficientnet_b3
    LR: 0.256
    Epochs: 350
    Crop Pct: '0.904'
    Momentum: 0.9
    Batch Size: 2048
    Image Size: '300'
    Weight Decay: 1.0e-05
    Interpolation: bicubic
    RMSProp Decay: 0.9
    Label Smoothing: 0.1
    BatchNorm Momentum: 0.99
  Code: https://github.com/rwightman/pytorch-image-models/blob/9a25fdf3ad0414b4d66da443fe60ae0aa14edc84/timm/models/efficientnet.py#L1271
  Weights: https://github.com/rwightman/pytorch-image-models/releases/download/v0.1-weights/tf_efficientnet_b3_aa-84b4657e.pth
  Results:
  - Task: Image Classification
    Dataset: ImageNet
    Metrics:
      Top 1 Accuracy: 81.65%
      Top 5 Accuracy: 95.72%
- Name: tf_efficientnet_b4
  In Collection: TF EfficientNet
  Metadata:
    FLOPs: 5749638672
    Parameters: 19340000
    File Size: 77989689
    Architecture:
    - 1x1 Convolution
    - Average Pooling
    - Batch Normalization
    - Convolution
    - Dense Connections
    - Dropout
    - Inverted Residual Block
    - Squeeze-and-Excitation Block
    - Swish
    Tasks:
    - Image Classification
    Training Techniques:
    - AutoAugment
    - Label Smoothing
    - RMSProp
    - Stochastic Depth
    - Weight Decay
    Training Data:
    - ImageNet
    Training Resources: TPUv3 Cloud TPU
    ID: tf_efficientnet_b4
    LR: 0.256
    Epochs: 350
    Crop Pct: '0.922'
    Momentum: 0.9
    Batch Size: 2048
    Image Size: '380'
    Weight Decay: 1.0e-05
    Interpolation: bicubic
    RMSProp Decay: 0.9
    Label Smoothing: 0.1
    BatchNorm Momentum: 0.99
  Code: https://github.com/rwightman/pytorch-image-models/blob/9a25fdf3ad0414b4d66da443fe60ae0aa14edc84/timm/models/efficientnet.py#L1281
  Weights: https://github.com/rwightman/pytorch-image-models/releases/download/v0.1-weights/tf_efficientnet_b4_aa-818f208c.pth
  Results:
  - Task: Image Classification
    Dataset: ImageNet
    Metrics:
      Top 1 Accuracy: 83.03%
      Top 5 Accuracy: 96.3%
- Name: tf_efficientnet_b5
  In Collection: TF EfficientNet
  Metadata:
    FLOPs: 13176501888
    Parameters: 30390000
    File Size: 122403150
    Architecture:
    - 1x1 Convolution
    - Average Pooling
    - Batch Normalization
    - Convolution
    - Dense Connections
    - Dropout
    - Inverted Residual Block
    - Squeeze-and-Excitation Block
    - Swish
    Tasks:
    - Image Classification
    Training Techniques:
    - AutoAugment
    - Label Smoothing
    - RMSProp
    - Stochastic Depth
    - Weight Decay
    Training Data:
    - ImageNet
    ID: tf_efficientnet_b5
    LR: 0.256
    Epochs: 350
    Crop Pct: '0.934'
    Momentum: 0.9
    Batch Size: 2048
    Image Size: '456'
    Weight Decay: 1.0e-05
    Interpolation: bicubic
    RMSProp Decay: 0.9
    Label Smoothing: 0.1
    BatchNorm Momentum: 0.99
  Code: https://github.com/rwightman/pytorch-image-models/blob/9a25fdf3ad0414b4d66da443fe60ae0aa14edc84/timm/models/efficientnet.py#L1291
  Weights: https://github.com/rwightman/pytorch-image-models/releases/download/v0.1-weights/tf_efficientnet_b5_ra-9a3e5369.pth
  Results:
  - Task: Image Classification
    Dataset: ImageNet
    Metrics:
      Top 1 Accuracy: 83.81%
      Top 5 Accuracy: 96.75%
- Name: tf_efficientnet_b6
  In Collection: TF EfficientNet
  Metadata:
    FLOPs: 24180518488
    Parameters: 43040000
    File Size: 173232007
    Architecture:
    - 1x1 Convolution
    - Average Pooling
    - Batch Normalization
    - Convolution
    - Dense Connections
    - Dropout
    - Inverted Residual Block
    - Squeeze-and-Excitation Block
    - Swish
    Tasks:
    - Image Classification
    Training Techniques:
    - AutoAugment
    - Label Smoothing
    - RMSProp
    - Stochastic Depth
    - Weight Decay
    Training Data:
    - ImageNet
    ID: tf_efficientnet_b6
    LR: 0.256
    Epochs: 350
    Crop Pct: '0.942'
    Momentum: 0.9
    Batch Size: 2048
    Image Size: '528'
    Weight Decay: 1.0e-05
    Interpolation: bicubic
    RMSProp Decay: 0.9
    Label Smoothing: 0.1
    BatchNorm Momentum: 0.99
  Code: https://github.com/rwightman/pytorch-image-models/blob/9a25fdf3ad0414b4d66da443fe60ae0aa14edc84/timm/models/efficientnet.py#L1301
  Weights: https://github.com/rwightman/pytorch-image-models/releases/download/v0.1-weights/tf_efficientnet_b6_aa-80ba17e4.pth
  Results:
  - Task: Image Classification
    Dataset: ImageNet
    Metrics:
      Top 1 Accuracy: 84.11%
      Top 5 Accuracy: 96.89%
- Name: tf_efficientnet_b7
  In Collection: TF EfficientNet
  Metadata:
    FLOPs: 48205304880
    Parameters: 66349999
    File Size: 266850607
    Architecture:
    - 1x1 Convolution
    - Average Pooling
    - Batch Normalization
    - Convolution
    - Dense Connections
    - Dropout
    - Inverted Residual Block
    - Squeeze-and-Excitation Block
    - Swish
    Tasks:
    - Image Classification
    Training Techniques:
    - AutoAugment
    - Label Smoothing
    - RMSProp
    - Stochastic Depth
    - Weight Decay
    Training Data:
    - ImageNet
    ID: tf_efficientnet_b7
    LR: 0.256
    Epochs: 350
    Crop Pct: '0.949'
    Momentum: 0.9
    Batch Size: 2048
    Image Size: '600'
    Weight Decay: 1.0e-05
    Interpolation: bicubic
    RMSProp Decay: 0.9
    Label Smoothing: 0.1
    BatchNorm Momentum: 0.99
  Code: https://github.com/rwightman/pytorch-image-models/blob/9a25fdf3ad0414b4d66da443fe60ae0aa14edc84/timm/models/efficientnet.py#L1312
  Weights: https://github.com/rwightman/pytorch-image-models/releases/download/v0.1-weights/tf_efficientnet_b7_ra-6c08e654.pth
  Results:
  - Task: Image Classification
    Dataset: ImageNet
    Metrics:
      Top 1 Accuracy: 84.93%
      Top 5 Accuracy: 97.2%
- Name: tf_efficientnet_b8
  In Collection: TF EfficientNet
  Metadata:
    FLOPs: 80962956270
    Parameters: 87410000
    File Size: 351379853
    Architecture:
    - 1x1 Convolution
    - Average Pooling
    - Batch Normalization
    - Convolution
    - Dense Connections
    - Dropout
    - Inverted Residual Block
    - Squeeze-and-Excitation Block
    - Swish
    Tasks:
    - Image Classification
    Training Techniques:
    - AutoAugment
    - Label Smoothing
    - RMSProp
    - Stochastic Depth
    - Weight Decay
    Training Data:
    - ImageNet
    ID: tf_efficientnet_b8
    LR: 0.256
    Epochs: 350
    Crop Pct: '0.954'
    Momentum: 0.9
    Batch Size: 2048
    Image Size: '672'
    Weight Decay: 1.0e-05
    Interpolation: bicubic
    RMSProp Decay: 0.9
    Label Smoothing: 0.1
    BatchNorm Momentum: 0.99
  Code: https://github.com/rwightman/pytorch-image-models/blob/9a25fdf3ad0414b4d66da443fe60ae0aa14edc84/timm/models/efficientnet.py#L1323
  Weights: https://github.com/rwightman/pytorch-image-models/releases/download/v0.1-weights/tf_efficientnet_b8_ra-572d5dd9.pth
  Results:
  - Task: Image Classification
    Dataset: ImageNet
    Metrics:
      Top 1 Accuracy: 85.35%
      Top 5 Accuracy: 97.39%
- Name: tf_efficientnet_el
  In Collection: TF EfficientNet
  Metadata:
    FLOPs: 9356616096
    Parameters: 10590000
    File Size: 42800271
    Architecture:
    - 1x1 Convolution
    - Average Pooling
    - Batch Normalization
    - Convolution
    - Dense Connections
    - Dropout
    - Inverted Residual Block
    - Squeeze-and-Excitation Block
    - Swish
    Tasks:
    - Image Classification
    Training Data:
    - ImageNet
    ID: tf_efficientnet_el
    Crop Pct: '0.904'
    Image Size: '300'
    Interpolation: bicubic
  Code: https://github.com/rwightman/pytorch-image-models/blob/9a25fdf3ad0414b4d66da443fe60ae0aa14edc84/timm/models/efficientnet.py#L1551
  Weights: https://github.com/rwightman/pytorch-image-models/releases/download/v0.1-weights/tf_efficientnet_el-5143854e.pth
  Results:
  - Task: Image Classification
    Dataset: ImageNet
    Metrics:
      Top 1 Accuracy: 80.45%
      Top 5 Accuracy: 95.17%
- Name: tf_efficientnet_em
  In Collection: TF EfficientNet
  Metadata:
    FLOPs: 3636607040
    Parameters: 6900000
    File Size: 27933644
    Architecture:
    - 1x1 Convolution
    - Average Pooling
    - Batch Normalization
    - Convolution
    - Dense Connections
    - Dropout
    - Inverted Residual Block
    - Squeeze-and-Excitation Block
    - Swish
    Tasks:
    - Image Classification
    Training Data:
    - ImageNet
    ID: tf_efficientnet_em
    Crop Pct: '0.882'
    Image Size: '240'
    Interpolation: bicubic
  Code: https://github.com/rwightman/pytorch-image-models/blob/9a25fdf3ad0414b4d66da443fe60ae0aa14edc84/timm/models/efficientnet.py#L1541
  Weights: https://github.com/rwightman/pytorch-image-models/releases/download/v0.1-weights/tf_efficientnet_em-e78cfe58.pth
  Results:
  - Task: Image Classification
    Dataset: ImageNet
    Metrics:
      Top 1 Accuracy: 78.71%
      Top 5 Accuracy: 94.33%
- Name: tf_efficientnet_es
  In Collection: TF EfficientNet
  Metadata:
    FLOPs: 2057577472
    Parameters: 5440000
    File Size: 22008479
    Architecture:
    - 1x1 Convolution
    - Average Pooling
    - Batch Normalization
    - Convolution
    - Dense Connections
    - Dropout
    - Inverted Residual Block
    - Squeeze-and-Excitation Block
    - Swish
    Tasks:
    - Image Classification
    Training Data:
    - ImageNet
    ID: tf_efficientnet_es
    Crop Pct: '0.875'
    Image Size: '224'
    Interpolation: bicubic
  Code: https://github.com/rwightman/pytorch-image-models/blob/9a25fdf3ad0414b4d66da443fe60ae0aa14edc84/timm/models/efficientnet.py#L1531
  Weights: https://github.com/rwightman/pytorch-image-models/releases/download/v0.1-weights/tf_efficientnet_es-ca1afbfe.pth
  Results:
  - Task: Image Classification
    Dataset: ImageNet
    Metrics:
      Top 1 Accuracy: 77.28%
      Top 5 Accuracy: 93.6%
- Name: tf_efficientnet_l2_ns_475
  In Collection: TF EfficientNet
  Metadata:
    FLOPs: 217795669644
    Parameters: 480310000
    File Size: 1925950424
    Architecture:
    - 1x1 Convolution
    - Average Pooling
    - Batch Normalization
    - Convolution
    - Dense Connections
    - Dropout
    - Inverted Residual Block
    - Squeeze-and-Excitation Block
    - Swish
    Tasks:
    - Image Classification
    Training Techniques:
    - AutoAugment
    - FixRes
    - Label Smoothing
    - Noisy Student
    - RMSProp
    - RandAugment
    - Weight Decay
    Training Data:
    - ImageNet
    - JFT-300M
    Training Resources: TPUv3 Cloud TPU
    ID: tf_efficientnet_l2_ns_475
    LR: 0.128
    Epochs: 350
    Dropout: 0.5
    Crop Pct: '0.936'
    Momentum: 0.9
    Batch Size: 2048
    Image Size: '475'
    Weight Decay: 1.0e-05
    Interpolation: bicubic
    RMSProp Decay: 0.9
    Label Smoothing: 0.1
    BatchNorm Momentum: 0.99
    Stochastic Depth Survival: 0.8
  Code: https://github.com/rwightman/pytorch-image-models/blob/9a25fdf3ad0414b4d66da443fe60ae0aa14edc84/timm/models/efficientnet.py#L1509
  Weights: https://github.com/rwightman/pytorch-image-models/releases/download/v0.1-weights/tf_efficientnet_l2_ns_475-bebbd00a.pth
  Results:
  - Task: Image Classification
    Dataset: ImageNet
    Metrics:
      Top 1 Accuracy: 88.24%
      Top 5 Accuracy: 98.55%
-->