text:
namespace ispc {
#endif // __cplusplus

struct Volume;
struct TransferFunction;

struct TextureVolume
{
  Texture super;

  const Volume *volume; // instanced Volume

  // Color and opacity transfer function.
  const TransferFunction *transferFunction;

#ifdef __cplusplus
  TextureVolume() : super(true), volume(nullptr), transferFunction(nullptr) {}
};
} // namespace ispc
#else
};
#endif // __cplusplus


text:
namespace absl {
ABSL_NAMESPACE_BEGIN
using string_view = std::string_view;
ABSL_NAMESPACE_END
}  // namespace absl

#else  // ABSL_USES_STD_STRING_VIEW

#if ABSL_HAVE_BUILTIN(__builtin_memcmp) ||        \
    (defined(__GNUC__) && !defined(__clang__)) || \
    (defined(_MSC_VER) && _MSC_VER >= 1928)
#define ABSL_INTERNAL_STRING_VIEW_MEMCMP __builtin_memcmp
#else  // ABSL_HAVE_BUILTIN(__builtin_memcmp)
#define ABSL_INTERNAL_STRING_VIEW_MEMCMP memcmp
#endif  // ABSL_HAVE_BUILTIN(__builtin_memcmp)

#if defined(__cplusplus) && __cplusplus >= 201402L
#define ABSL_INTERNAL_STRING_VIEW_CXX14_CONSTEXPR constexpr
#else
#define ABSL_INTERNAL_STRING_VIEW_CXX14_CONSTEXPR
#endif

namespace absl {
ABSL_NAMESPACE_BEGIN

// absl::string_view
//
// A `string_view` provides a lightweight view into the string data provided by
// a `std::string`, double-quoted string literal, character array, or even
// another `string_view`. A `string_view` does *not* own the string to which it
// points, and that data cannot be modified through the view.
//
// You can use `string_view` as a function or method parameter anywhere a
// parameter can receive a double-quoted string literal, `const char*`,
// `std::string`, or another `absl::string_view` argument with no need to copy
// the string data. Systematic use of `string_view` within function arguments
// reduces data copies and `strlen()` calls.
//
// Because of its small size, prefer passing `string_view` by value:
//
//   void MyFunction(absl::string_view arg);
//
// If circumstances require, you may also pass one by const reference:
//
//   void MyFunction(const absl::string_view& arg);  // not preferred
//
// Passing by value generates slightly smaller code for many architectures.
//
// In either case, the source data of the `string_view` must outlive the
// `string_view` itself.
//
// A `string_view` is also suitable for local variables if you know that the
// lifetime of the underlying object is longer than the lifetime of your
// `string_view` variable. However, beware of binding a `string_view` to a
// temporary value:
//
//   // BAD use of string_view: lifetime problem
//   absl::string_view sv = obj.ReturnAString();
//
//   // GOOD use of string_view: str outlives sv
//   std::string str = obj.ReturnAString();
//   absl::string_view sv = str;
//
// Due to lifetime issues, a `string_view` is sometimes a poor choice for a
// return value and usually a poor choice for a data member. If you do use a
// `string_view` this way, it is your responsibility to ensure that the object
// pointed to by the `string_view` outlives the `string_view`.
//
// A `string_view` may represent a whole string or just part of a string. For
// example, when splitting a string, `std::vector<absl::string_view>` is a
// natural data type for the output.
//
// For another example, a Cord is a non-contiguous, potentially very
// long string-like object.  The Cord class has an interface that iteratively
// provides string_view objects that point to the successive pieces of a Cord
// object.
//
// When constructed from a source which is NUL-terminated, the `string_view`
// itself will not include the NUL-terminator unless a specific size (including
// the NUL) is passed to the constructor. As a result, common idioms that work
// on NUL-terminated strings do not work on `string_view` objects. If you write
// code that scans a `string_view`, you must check its length rather than test
// for nul, for example. Note, however, that nuls may still be embedded within
// a `string_view` explicitly.
//
// You may create a null `string_view` in two ways:
//
//   absl::string_view sv;
//   absl::string_view sv(nullptr, 0);
//
// For the above, `sv.data() == nullptr`, `sv.length() == 0`, and
// `sv.empty() == true`. Also, if you create a `string_view` with a non-null
// pointer then `sv.data() != nullptr`. Thus, you can use `string_view()` to
// signal an undefined value that is different from other `string_view` values
// in a similar fashion to how `const char* p1 = nullptr;` is different from
// `const char* p2 = "";`. However, in practice, it is not recommended to rely
// on this behavior.
//
// Be careful not to confuse a null `string_view` with an empty one. A null
// `string_view` is an empty `string_view`, but some empty `string_view`s are
// not null. Prefer checking for emptiness over checking for null.
//
// There are many ways to create an empty string_view:
//
//   const char* nullcp = nullptr;
//   // string_view.size() will return 0 in all cases.
//   absl::string_view();
//   absl::string_view(nullcp, 0);
//   absl::string_view("");
//   absl::string_view("", 0);
//   absl::string_view("abcdef", 0);
//   absl::string_view("abcdef" + 6, 0);
//
// All empty `string_view` objects whether null or not, are equal:
//
//   absl::string_view() == absl::string_view("", 0)
//   absl::string_view(nullptr, 0) == absl::string_view("abcdef"+6, 0)
class string_view {
 public:
  using traits_type = std::char_traits<char>;
  using value_type = char;
  using pointer = char*;
  using const_pointer = const char*;
  using reference = char&;
  using const_reference = const char&;
  using const_iterator = const char*;
  using iterator = const_iterator;
  using const_reverse_iterator = std::reverse_iterator<const_iterator>;
  using reverse_iterator = const_reverse_iterator;
  using size_type = size_t;
  using difference_type = std::ptrdiff_t;

  static constexpr size_type npos = static_cast<size_type>(-1);

  // Null `string_view` constructor
  constexpr string_view() noexcept : ptr_(nullptr), length_(0) {}

  // Implicit constructors

  template <typename Allocator>
  string_view(  // NOLINT(runtime/explicit)
      const std::basic_string<char, std::char_traits<char>, Allocator>& str
          ABSL_ATTRIBUTE_LIFETIME_BOUND) noexcept
      // This is implemented in terms of `string_view(p, n)` so `str.size()`
      // doesn't need to be reevaluated after `ptr_` is set.
      // The length check is also skipped since it is unnecessary and causes
      // code bloat.
      : string_view(str.data(), str.size(), SkipCheckLengthTag{}) {}

  // Implicit constructor of a `string_view` from NUL-terminated `str`. When
  // accepting possibly null strings, use `absl::NullSafeStringView(str)`
  // instead (see below).
  // The length check is skipped since it is unnecessary and causes code bloat.
  constexpr string_view(const char* str)  // NOLINT(runtime/explicit)
      : ptr_(str), length_(str ? StrlenInternal(str) : 0) {}

  // Implicit constructor of a `string_view` from a `const char*` and length.
  constexpr string_view(const char* data, size_type len)
      : ptr_(data), length_(CheckLengthInternal(len)) {}

  // NOTE: Harmlessly omitted to work around gdb bug.
  //   constexpr string_view(const string_view&) noexcept = default;
  //   string_view& operator=(const string_view&) noexcept = default;

  // Iterators

  // string_view::begin()
  //
  // Returns an iterator pointing to the first character at the beginning of the
  // `string_view`, or `end()` if the `string_view` is empty.
  constexpr const_iterator begin() const noexcept { return ptr_; }

  // string_view::end()
  //
  // Returns an iterator pointing just beyond the last character at the end of
  // the `string_view`. This iterator acts as a placeholder; attempting to
  // access it results in undefined behavior.
  constexpr const_iterator end() const noexcept { return ptr_ + length_; }

  // string_view::cbegin()
  //
  // Returns a const iterator pointing to the first character at the beginning
  // of the `string_view`, or `end()` if the `string_view` is empty.
  constexpr const_iterator cbegin() const noexcept { return begin(); }

  // string_view::cend()
  //
  // Returns a const iterator pointing just beyond the last character at the end
  // of the `string_view`. This pointer acts as a placeholder; attempting to
  // access its element results in undefined behavior.
  constexpr const_iterator cend() const noexcept { return end(); }

  // string_view::rbegin()
  //
  // Returns a reverse iterator pointing to the last character at the end of the
  // `string_view`, or `rend()` if the `string_view` is empty.
  const_reverse_iterator rbegin() const noexcept {
    return const_reverse_iterator(end());
  }

  // string_view::rend()
  //
  // Returns a reverse iterator pointing just before the first character at the
  // beginning of the `string_view`. This pointer acts as a placeholder;
  // attempting to access its element results in undefined behavior.
  const_reverse_iterator rend() const noexcept {
    return const_reverse_iterator(begin());
  }

  // string_view::crbegin()
  //
  // Returns a const reverse iterator pointing to the last character at the end
  // of the `string_view`, or `crend()` if the `string_view` is empty.
  const_reverse_iterator crbegin() const noexcept { return rbegin(); }

  // string_view::crend()
  //
  // Returns a const reverse iterator pointing just before the first character
  // at the beginning of the `string_view`. This pointer acts as a placeholder;
  // attempting to access its element results in undefined behavior.
  const_reverse_iterator crend() const noexcept { return rend(); }

  // Capacity Utilities

  // string_view::size()
  //
  // Returns the number of characters in the `string_view`.
  constexpr size_type size() const noexcept { return length_; }

  // string_view::length()
  //
  // Returns the number of characters in the `string_view`. Alias for `size()`.
  constexpr size_type length() const noexcept { return size(); }

  // string_view::max_size()
  //
  // Returns the maximum number of characters the `string_view` can hold.
  constexpr size_type max_size() const noexcept { return kMaxSize; }

  // string_view::empty()
  //
  // Checks if the `string_view` is empty (refers to no characters).
  constexpr bool empty() const noexcept { return length_ == 0; }

  // string_view::operator[]
  //
  // Returns the ith element of the `string_view` using the array operator.
  // Note that this operator does not perform any bounds checking.
  constexpr const_reference operator[](size_type i) const {
    return ABSL_HARDENING_ASSERT(i < size()), ptr_[i];
  }

  // string_view::at()
  //
  // Returns the ith element of the `string_view`. Bounds checking is performed,
  // and an exception of type `std::out_of_range` will be thrown on invalid
  // access.
  constexpr const_reference at(size_type i) const {
    return ABSL_PREDICT_TRUE(i < size())
               ? ptr_[i]
               : ((void)base_internal::ThrowStdOutOfRange(
                      "absl::string_view::at"),
                  ptr_[i]);
  }

  // string_view::front()
  //
  // Returns the first element of a `string_view`.
  constexpr const_reference front() const {
    return ABSL_HARDENING_ASSERT(!empty()), ptr_[0];
  }

  // string_view::back()
  //
  // Returns the last element of a `string_view`.
  constexpr const_reference back() const {
    return ABSL_HARDENING_ASSERT(!empty()), ptr_[size() - 1];
  }

  // string_view::data()
  //
  // Returns a pointer to the underlying character array (which is of course
  // stored elsewhere). Note that `string_view::data()` may contain embedded nul
  // characters, but the returned buffer may or may not be NUL-terminated;
  // therefore, do not pass `data()` to a routine that expects a NUL-terminated
  // string.
  constexpr const_pointer data() const noexcept { return ptr_; }

  // Modifiers

  // string_view::remove_prefix()
  //
  // Removes the first `n` characters from the `string_view`. Note that the
  // underlying string is not changed, only the view.
  ABSL_INTERNAL_STRING_VIEW_CXX14_CONSTEXPR void remove_prefix(size_type n) {
    ABSL_HARDENING_ASSERT(n <= length_);
    ptr_ += n;
    length_ -= n;
  }

  // string_view::remove_suffix()
  //
  // Removes the last `n` characters from the `string_view`. Note that the
  // underlying string is not changed, only the view.
  ABSL_INTERNAL_STRING_VIEW_CXX14_CONSTEXPR void remove_suffix(size_type n) {
    ABSL_HARDENING_ASSERT(n <= length_);
    length_ -= n;
  }

  // string_view::swap()
  //
  // Swaps this `string_view` with another `string_view`.
  ABSL_INTERNAL_STRING_VIEW_CXX14_CONSTEXPR void swap(string_view& s) noexcept {
    auto t = *this;
    *this = s;
    s = t;
  }

  // Explicit conversion operators

  // Converts to `std::basic_string`.
  template <typename A>
  explicit operator std::basic_string<char, traits_type, A>() const {
    if (!data()) return {};
    return std::basic_string<char, traits_type, A>(data(), size());
  }

  // string_view::copy()
  //
  // Copies the contents of the `string_view` at offset `pos` and length `n`
  // into `buf`.
  size_type copy(char* buf, size_type n, size_type pos = 0) const {
    if (ABSL_PREDICT_FALSE(pos > length_)) {
      base_internal::ThrowStdOutOfRange("absl::string_view::copy");
    }
    size_type rlen = (std::min)(length_ - pos, n);
    if (rlen > 0) {
      const char* start = ptr_ + pos;
      traits_type::copy(buf, start, rlen);
    }
    return rlen;
  }

  // string_view::substr()
  //
  // Returns a "substring" of the `string_view` (at offset `pos` and length
  // `n`) as another string_view. This function throws `std::out_of_bounds` if
  // `pos > size`.
  // Use absl::ClippedSubstr if you need a truncating substr operation.
  constexpr string_view substr(size_type pos = 0, size_type n = npos) const {
    return ABSL_PREDICT_FALSE(pos > length_)
               ? (base_internal::ThrowStdOutOfRange(
                      "absl::string_view::substr"),
                  string_view())
               : string_view(ptr_ + pos, Min(n, length_ - pos));
  }

  // string_view::compare()
  //
  // Performs a lexicographical comparison between this `string_view` and
  // another `string_view` `x`, returning a negative value if `*this` is less
  // than `x`, 0 if `*this` is equal to `x`, and a positive value if `*this`
  // is greater than `x`.
  constexpr int compare(string_view x) const noexcept {
    return CompareImpl(length_, x.length_,
                       Min(length_, x.length_) == 0
                           ? 0
                           : ABSL_INTERNAL_STRING_VIEW_MEMCMP(
                                 ptr_, x.ptr_, Min(length_, x.length_)));
  }

  // Overload of `string_view::compare()` for comparing a substring of the
  // 'string_view` and another `absl::string_view`.
  constexpr int compare(size_type pos1, size_type count1, string_view v) const {
    return substr(pos1, count1).compare(v);
  }

  // Overload of `string_view::compare()` for comparing a substring of the
  // `string_view` and a substring of another `absl::string_view`.
  constexpr int compare(size_type pos1, size_type count1, string_view v,
                        size_type pos2, size_type count2) const {
    return substr(pos1, count1).compare(v.substr(pos2, count2));
  }

  // Overload of `string_view::compare()` for comparing a `string_view` and a
  // a different C-style string `s`.
  constexpr int compare(const char* s) const { return compare(string_view(s)); }

  // Overload of `string_view::compare()` for comparing a substring of the
  // `string_view` and a different string C-style string `s`.
  constexpr int compare(size_type pos1, size_type count1, const char* s) const {
    return substr(pos1, count1).compare(string_view(s));
  }

  // Overload of `string_view::compare()` for comparing a substring of the
  // `string_view` and a substring of a different C-style string `s`.
  constexpr int compare(size_type pos1, size_type count1, const char* s,
                        size_type count2) const {
    return substr(pos1, count1).compare(string_view(s, count2));
  }

  // Find Utilities

  // string_view::find()
  //
  // Finds the first occurrence of the substring `s` within the `string_view`,
  // returning the position of the first character's match, or `npos` if no
  // match was found.
  size_type find(string_view s, size_type pos = 0) const noexcept;

  // Overload of `string_view::find()` for finding the given character `c`
  // within the `string_view`.
  size_type find(char c, size_type pos = 0) const noexcept;

  // Overload of `string_view::find()` for finding a substring of a different
  // C-style string `s` within the `string_view`.
  size_type find(const char* s, size_type pos, size_type count) const {
    return find(string_view(s, count), pos);
  }

  // Overload of `string_view::find()` for finding a different C-style string
  // `s` within the `string_view`.
  size_type find(const char* s, size_type pos = 0) const {
    return find(string_view(s), pos);
  }

  // string_view::rfind()
  //
  // Finds the last occurrence of a substring `s` within the `string_view`,
  // returning the position of the first character's match, or `npos` if no
  // match was found.
  size_type rfind(string_view s, size_type pos = npos) const noexcept;

  // Overload of `string_view::rfind()` for finding the last given character `c`
  // within the `string_view`.
  size_type rfind(char c, size_type pos = npos) const noexcept;

  // Overload of `string_view::rfind()` for finding a substring of a different
  // C-style string `s` within the `string_view`.
  size_type rfind(const char* s, size_type pos, size_type count) const {
    return rfind(string_view(s, count), pos);
  }

  // Overload of `string_view::rfind()` for finding a different C-style string
  // `s` within the `string_view`.
  size_type rfind(const char* s, size_type pos = npos) const {
    return rfind(string_view(s), pos);
  }

  // string_view::find_first_of()
  //
  // Finds the first occurrence of any of the characters in `s` within the
  // `string_view`, returning the start position of the match, or `npos` if no
  // match was found.
  size_type find_first_of(string_view s, size_type pos = 0) const noexcept;

  // Overload of `string_view::find_first_of()` for finding a character `c`
  // within the `string_view`.
  size_type find_first_of(char c, size_type pos = 0) const noexcept {
    return find(c, pos);
  }

  // Overload of `string_view::find_first_of()` for finding a substring of a
  // different C-style string `s` within the `string_view`.
  size_type find_first_of(const char* s, size_type pos,
                                    size_type count) const {
    return find_first_of(string_view(s, count), pos);
  }

  // Overload of `string_view::find_first_of()` for finding a different C-style
  // string `s` within the `string_view`.
  size_type find_first_of(const char* s, size_type pos = 0) const {
    return find_first_of(string_view(s), pos);
  }

  // string_view::find_last_of()
  //
  // Finds the last occurrence of any of the characters in `s` within the
  // `string_view`, returning the start position of the match, or `npos` if no
  // match was found.
  size_type find_last_of(string_view s, size_type pos = npos) const noexcept;

  // Overload of `string_view::find_last_of()` for finding a character `c`
  // within the `string_view`.
  size_type find_last_of(char c, size_type pos = npos) const noexcept {
    return rfind(c, pos);
  }

  // Overload of `string_view::find_last_of()` for finding a substring of a
  // different C-style string `s` within the `string_view`.
  size_type find_last_of(const char* s, size_type pos, size_type count) const {
    return find_last_of(string_view(s, count), pos);
  }

  // Overload of `string_view::find_last_of()` for finding a different C-style
  // string `s` within the `string_view`.
  size_type find_last_of(const char* s, size_type pos = npos) const {
    return find_last_of(string_view(s), pos);
  }

  // string_view::find_first_not_of()
  //
  // Finds the first occurrence of any of the characters not in `s` within the
  // `string_view`, returning the start position of the first non-match, or
  // `npos` if no non-match was found.
  size_type find_first_not_of(string_view s, size_type pos = 0) const noexcept;

  // Overload of `string_view::find_first_not_of()` for finding a character
  // that is not `c` within the `string_view`.
  size_type find_first_not_of(char c, size_type pos = 0) const noexcept;

  // Overload of `string_view::find_first_not_of()` for finding a substring of a
  // different C-style string `s` within the `string_view`.
  size_type find_first_not_of(const char* s, size_type pos,
                              size_type count) const {
    return find_first_not_of(string_view(s, count), pos);
  }

  // Overload of `string_view::find_first_not_of()` for finding a different
  // C-style string `s` within the `string_view`.
  size_type find_first_not_of(const char* s, size_type pos = 0) const {
    return find_first_not_of(string_view(s), pos);
  }

  // string_view::find_last_not_of()
  //
  // Finds the last occurrence of any of the characters not in `s` within the
  // `string_view`, returning the start position of the last non-match, or
  // `npos` if no non-match was found.
  size_type find_last_not_of(string_view s,
                             size_type pos = npos) const noexcept;

  // Overload of `string_view::find_last_not_of()` for finding a character
  // that is not `c` within the `string_view`.
  size_type find_last_not_of(char c, size_type pos = npos) const noexcept;

  // Overload of `string_view::find_last_not_of()` for finding a substring of a
  // different C-style string `s` within the `string_view`.
  size_type find_last_not_of(const char* s, size_type pos,
                             size_type count) const {
    return find_last_not_of(string_view(s, count), pos);
  }

  // Overload of `string_view::find_last_not_of()` for finding a different
  // C-style string `s` within the `string_view`.
  size_type find_last_not_of(const char* s, size_type pos = npos) const {
    return find_last_not_of(string_view(s), pos);
  }

 private:
  // The constructor from std::string delegates to this constructor.
  // See the comment on that constructor for the rationale.
  struct SkipCheckLengthTag {};
  string_view(const char* data, size_type len, SkipCheckLengthTag) noexcept
      : ptr_(data), length_(len) {}

  static constexpr size_type kMaxSize =
      (std::numeric_limits<difference_type>::max)();

  static constexpr size_type CheckLengthInternal(size_type len) {
    return ABSL_HARDENING_ASSERT(len <= kMaxSize), len;
  }

  static constexpr size_type StrlenInternal(const char* str) {
#if defined(_MSC_VER) && _MSC_VER >= 1910 && !defined(__clang__)
    // MSVC 2017+ can evaluate this at compile-time.
    const char* begin = str;
    while (*str != '\0') ++str;
    return str - begin;
#elif ABSL_HAVE_BUILTIN(__builtin_strlen) || \
    (defined(__GNUC__) && !defined(__clang__))
    // GCC has __builtin_strlen according to
    // https://gcc.gnu.org/onlinedocs/gcc-4.7.0/gcc/Other-Builtins.html, but
    // ABSL_HAVE_BUILTIN doesn't detect that, so we use the extra checks above.
    // __builtin_strlen is constexpr.
    return __builtin_strlen(str);
#else
    return str ? strlen(str) : 0;
#endif
  }

  static constexpr size_t Min(size_type length_a, size_type length_b) {
    return length_a < length_b ? length_a : length_b;
  }

  static constexpr int CompareImpl(size_type length_a, size_type length_b,
                                   int compare_result) {
    return compare_result == 0 ? static_cast<int>(length_a > length_b) -
                                     static_cast<int>(length_a < length_b)
                               : (compare_result < 0 ? -1 : 1);
  }

  const char* ptr_;
  size_type length_;
};

// This large function is defined inline so that in a fairly common case where
// one of the arguments is a literal, the compiler can elide a lot of the
// following comparisons.
constexpr bool operator==(string_view x, string_view y) noexcept {
  return x.size() == y.size() &&
         (x.empty() ||
          ABSL_INTERNAL_STRING_VIEW_MEMCMP(x.data(), y.data(), x.size()) == 0);
}

constexpr bool operator!=(string_view x, string_view y) noexcept {
  return !(x == y);
}

constexpr bool operator<(string_view x, string_view y) noexcept {
  return x.compare(y) < 0;
}

constexpr bool operator>(string_view x, string_view y) noexcept {
  return y < x;
}

constexpr bool operator<=(string_view x, string_view y) noexcept {
  return !(y < x);
}

constexpr bool operator>=(string_view x, string_view y) noexcept {
  return !(x < y);
}

// IO Insertion Operator
std::ostream& operator<<(std::ostream& o, string_view piece);

ABSL_NAMESPACE_END
}  // namespace absl

#undef ABSL_INTERNAL_STRING_VIEW_CXX14_CONSTEXPR
#undef ABSL_INTERNAL_STRING_VIEW_MEMCMP

#endif  // ABSL_USES_STD_STRING_VIEW

namespace absl {
ABSL_NAMESPACE_BEGIN

// ClippedSubstr()
//
// Like `s.substr(pos, n)`, but clips `pos` to an upper bound of `s.size()`.
// Provided because std::string_view::substr throws if `pos > size()`
inline string_view ClippedSubstr(string_view s, size_t pos,
                                 size_t n = string_view::npos) {
  pos = (std::min)(pos, static_cast<size_t>(s.size()));
  return s.substr(pos, n);
}

// NullSafeStringView()
//
// Creates an `absl::string_view` from a pointer `p` even if it's null-valued.
// This function should be used where an `absl::string_view` can be created from
// a possibly-null pointer.
constexpr string_view NullSafeStringView(const char* p) {
  return p ? string_view(p) : string_view();
}

ABSL_NAMESPACE_END
}  // namespace absl

#endif  // ABSL_STRINGS_STRING_VIEW_H_

redpajama_set_name: RedPajamaGithub


text:
"""
Find the most frequently occurring repeat of length 6 in all sequences. How many times does it occur in all?
"""

f = open("dna1.fasta", "r")
file = f.readlines()

sequences = []
seq = ""
for f in file:
    if not f.startswith('>'):
        f = f.replace(" ", "")
        f = f.replace("\n", "")
        seq = seq + f
    else:
        sequences.append(seq)
        seq = ""

# Add the last seq
sequences.append(seq)

sequences = sequences[1:]

def get_all_repeats(sequence):
    length = len(sequence)
    repeats = []
    for i in range(length):
        repeats.append(sequence[i:i + 7])
    return repeats

all_six_repearts = []
for i in sequences:
    repeats_list = get_all_repeats(i)
    for j in repeats_list:
        all_six_repearts.append(j)

def most_common(lst):
    return max(set(lst), key=lst.count)

print(most_common(all_six_repearts))
print(all_six_repearts.count(most_common(all_six_repearts)))


text:
#pragma once

#include <Voxie/Data/Slice.hpp>

#include <Voxie/IO/SliceExporter.hpp>

class HDFSliceExporter : public vx::io::SliceExporter {
  Q_OBJECT
  Q_DISABLE_COPY(HDFSliceExporter)
 private:
 public:
  explicit HDFSliceExporter();
  ~HDFSliceExporter();

  virtual void exportGui(vx::Slice* slice) override;

  void exportSlice(QString fileName, vx::Slice* slice, float x, float y,
                   float xMax, float yMax, float sizeX, float sizeY,
                   vx::InterpolationMethod interpolation);
};


text:
package ioke.lang;

import java.util.ArrayList;
import java.util.HashMap;

import ioke.lang.exceptions.ControlFlow;

/**
 *
 * @author Ola Bini
 */
public class Origin {
    public static void init(IokeObject origin) throws ControlFlow {
        final Runtime runtime = origin.runtime;

        origin.setKind("Origin");

        // asText, asRepresentation
        origin.registerMethod(runtime.newNativeMethod("Prints a text representation and a newline to standard output", new NativeMethod.WithNoArguments("println") {
                @Override
                public Object activate(IokeObject method, IokeObject context, IokeObject message, Object on) throws ControlFlow {
                    getArguments().getEvaluatedArguments(context, message, on, new ArrayList<Object>(), new HashMap<String, Object>());
                    Interpreter.send(runtime.printlnMessage, context, Interpreter.send(runtime.outMessage, context, runtime.system), on);
                    return runtime.getNil();
                }
            }));

        origin.registerMethod(runtime.newNativeMethod("Prints a text representation to standard output", new NativeMethod.WithNoArguments("print") {
                @Override
                public Object activate(IokeObject method, IokeObject context, IokeObject message, Object on) throws ControlFlow {
                    getArguments().getEvaluatedArguments(context, message, on, new ArrayList<Object>(), new HashMap<String, Object>());
                    Interpreter.send(runtime.printMessage, context, Interpreter.send(runtime.outMessage, context, runtime.system), on);
                    return runtime.getNil();
                }
            }));
    }
}// Origin


text:
#include "pch/kdrive_pch.h"
#include "kdrive/baos/services/SetServerItem.h"
#include "kdrive/baos/protocols/Protocol.h"
#include "kdrive/baos/core/ServerFunction.h"
#include "kdrive/baos/core/API.h"

using namespace kdrive::connector;
using namespace kdrive::baos;

SetServerItem::SetServerItem(BaosConnector::Ptr connector)

	: ServiceRunner(connector)
{
}

SetServerItem::~SetServerItem()
{
}

void SetServerItem::rpc(unsigned short offset, const Item& item, unsigned long timeout)
{
	Items items;
	items.push_back(item);
	rpc(offset, items, timeout);
}

void SetServerItem::rpc(unsigned short offset, const Items& items, unsigned long timeout)
{
	const unsigned short count = static_cast<unsigned short>(items.size());

	DataRequest::Ptr dataRequest =
	    DataRequestFactory::create(getConnector(), RequestFunctions::SetServerItem, offset, count);

	ProtocolFormatter::encodeSetServerItem_Req(dataRequest, items);

	ServerFunction serverFunction(getConnector());
	DataResponse::Ptr dataResponse = serverFunction.rpc(dataRequest, timeout);
	setDataResponse(dataResponse);
}


text:
// Copyright (c) Microsoft Corporation. All rights reserved.
// Licensed under the MIT License.
// Code generated by Microsoft (R) AutoRest Code Generator.

package com.azure.resourcemanager.postgresql.generated;

import com.azure.core.util.Context;

/** Samples for FirewallRules ListByServer. */
public final class FirewallRulesListByServerSamples {
    /*
     * x-ms-original-file: specification/postgresql/resource-manager/Microsoft.DBforPostgreSQL/stable/2017-12-01/examples/FirewallRuleListByServer.json
     */
    /**
     * Sample code: FirewallRuleList.
     *
     * @param manager Entry point to PostgreSqlManager.
     */
    public static void firewallRuleList(com.azure.resourcemanager.postgresql.PostgreSqlManager manager) {
        manager.firewallRules().listByServer("TestGroup", "testserver", Context.NONE);
    }
}


text:
import logging
import gzip
import pathlib
import sys

def get_formatter():
    return logging.Formatter('>{asctime}\t{levelname}\t{name}\t{message}', datefmt='%Y-%m-%d %H:%M:%S', style='{')

def get_logger(name):
    """Get a logger for a specific purpose. Basic usage is to for each module that needs logging,
    call 'logger = logging.get_logger(__name__)' to set a module-level global logger."""
    return StyleAdapter(logging.getLogger(name))

# Workaround for the fact that by default logging messages must use old-style %-formatting.
# We define a special log message class and LoggerAdapter class to address this.
class FormattedLogMessage:
    def __init__(self, fmt, args):
        self.fmt = fmt
        self.args = args

    def __str__(self):
        return self.fmt.format(*self.args)

class StyleAdapter(logging.LoggerAdapter):
    def __init__(self, logger):
        self.logger = logger

    def log(self, level, msg, *args, **kwargs):
        if self.isEnabledFor(level):
            self.logger._log(level, FormattedLogMessage(msg, args), (), **kwargs)

    def addHandler(self, handler):
        self.logger.addHandler(handler)

    def log_exception(self, preamble):
        exc_info = sys.exc_info()
        self.warn('{} {}', preamble, exc_info[1]) # warn with the basic exception message
        self.debug('Detailed information', exc_info=exc_info) # log traceback at debug level

def gz_log_namer(name):
    return name + '.gz'

def gz_log_rotator(source_name, dest_name):
    source = pathlib.Path(source_name)
    if source.exists():
        with open(source_name, 'rb') as src, gzip.open(dest_name, 'wb') as dst:
            dst.writelines(src)
        source.unlink()

def delete_log_rotator(source_name, dest_name):
    source = pathlib.Path(source_name)
    if source.exists():
        source.unlink()


text:
<?php

namespace Phalcon\Version;

/**
 * \Phalcon\Version\VersionAwareTrait
 *
 * @property string $version
 *
 * @package   Phalcon\Version
 * @copyright Copyright (c) 2011-2016 Phalcon Team (team@phalconphp.com)
 * @license   New BSD License
 */
trait VersionAwareTrait
{
    /**
     * Get the string representation of the version
     *
     * @return string
     */
    public function getVersion()
    {
        return $this->version;
    }

    /**
     * Get the string representation of the version
     *
     * @return string
     */
    public function __toString()
    {
        return $this->getVersion();
    }
}


text:
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">
  <modelVersion>4.0.0</modelVersion>

  <parent>
    <groupId>org.jenkins-ci.plugins</groupId>
    <artifactId>plugin</artifactId>
    <version>1.565</version>
  </parent>

  <artifactId>promoted-builds</artifactId>
  <version>2.26-SNAPSHOT</version>
  <packaging>hpi</packaging>

  <name>Jenkins promoted builds plugin</name>
  <url>http://wiki.jenkins-ci.org/display/JENKINS/Promoted+Builds+Plugin</url>

  <properties>
    <findbugs-maven-plugin.version>3.0.1</findbugs-maven-plugin.version>
    <findbugs.failOnError>true</findbugs.failOnError>
  </properties>

  <developers>
    <developer>
      <id>kohsuke</id>
      <name>Kohsuke Kawaguchi</name>
    </developer>
    <developer>
      <id>petehayes</id>
      <name>Peter Hayes</name>
    </developer>
    <developer>
      <id>oleg_nenashev</id>
      <name>Oleg Nenashev</name>
    </developer>
  </developers>

  <scm>
    <connection>scm:git:git://github.com/jenkinsci/${project.artifactId}-plugin.git</connection>
    <developerConnection>scm:git:git@github.com:jenkinsci/${project.artifactId}-plugin.git</developerConnection>
    <url>https://github.com/jenkinsci/${project.artifactId}-plugin</url>
    <tag>HEAD</tag>
  </scm>
  <licenses>
    <license>
      <name>MIT</name>
      <url>http://opensource.org/licenses/MIT</url>
    </license>
  </licenses>

  <repositories>
    <!-- needed unless you have a profile for those -->
    <repository>
      <id>jenkins-releases</id>
      <url>http://repo.jenkins-ci.org/releases/</url>
      <releases>
        <enabled>true</enabled>
      </releases>
      <snapshots>
        <enabled>false</enabled>
      </snapshots>
    </repository>
    <repository>
      <id>repo.jenkins-ci.org</id>
      <url>http://repo.jenkins-ci.org/public/</url>
      <releases>
        <enabled>true</enabled>
      </releases>
      <snapshots>
        <enabled>false</enabled>
      </snapshots>
    </repository>
  </repositories>

  <pluginRepositories>
    <!-- needed unless you have a profile for those -->
    <pluginRepository>
      <id>repo.jenkins-ci.org</id>
      <url>http://repo.jenkins-ci.org/public/</url>
    </pluginRepository>
  </pluginRepositories>

  <dependencies>
    <dependency>
      <groupId>org.jenkins-ci.main</groupId>
      <artifactId>maven-plugin</artifactId>
      <version>2.0</version>
    </dependency>
    <dependency>
      <groupId>com.sonyericsson.hudson.plugins.rebuild</groupId>
      <artifactId>rebuild</artifactId>
      <version>1.22</version>
      <optional>true</optional>
    </dependency>
    <dependency>
      <groupId>org.mockito</groupId>
      <artifactId>mockito-all</artifactId>
      <version>1.8.5</version>
      <scope>test</scope>
    </dependency>
    <dependency>
      <groupId>com.google.code.findbugs</groupId>
      <artifactId>annotations</artifactId>
      <version>3.0.0</version>
      <scope>provided</scope>
    </dependency>
    <dependency>
      <groupId>org.jenkins-ci.plugins</groupId>
      <artifactId>token-macro</artifactId>
      <version>1.10</version>
      <optional>true</optional>
    </dependency>
    <dependency>
      <groupId>hudson.plugins</groupId>
      <artifactId>project-inheritance</artifactId>
      <version>1.5.3</version>
      <optional>true</optional>
    </dependency>
    <dependency>
      <groupId>org.jenkins-ci.plugins</groupId>
      <artifactId>job-dsl</artifactId>
      <version>1.44</version>
      <type>jar</type>
      <optional>true</optional>
    </dependency>
    <dependency>
      <groupId>org.jvnet.hudson</groupId>
      <artifactId>xstream</artifactId>
      <version>1.4.7-jenkins-1</version>
      <optional>true</optional>
    </dependency>
    <dependency>
      <groupId>org.jenkins-ci.plugins</groupId>
      <artifactId>parameterized-trigger</artifactId>
      <version>2.30</version>
      <scope>test</scope>
    </dependency>
  </dependencies>

  <build>
    <plugins>
      <plugin>
        <artifactId>maven-release-plugin</artifactId>
        <version>2.5.1</version>
      </plugin>
      <plugin>
        <groupId>org.codehaus.mojo</groupId>
        <artifactId>findbugs-maven-plugin</artifactId>
        <version>${findbugs-maven-plugin.version}</version>
        <configuration>
          <failOnError>${findbugs.failOnError}</failOnError>
          <xmlOutput>true</xmlOutput>
        </configuration>
        <executions>
          <execution>
            <id>run-findbugs</id>
            <phase>verify</phase>
            <goals>
              <goal>check</goal>
            </goals>
          </execution>
        </executions>
      </plugin>
      <plugin>
        <groupId>org.jenkins-ci.tools</groupId>
        <artifactId>maven-hpi-plugin</artifactId>
        <extensions>true</extensions>
        <configuration>
          <compatibleSinceVersion>2.22</compatibleSinceVersion>
        </configuration>
      </plugin>
    </plugins>
  </build>
</project>


text:
<?php

namespace NetSuite\Classes;

class BillingScheduleRecurrenceMode {
    static $paramtypesmap = array(
    );
    const _dom = "_dom";
    const _dowim = "_dowim";
}


text:
<?php
namespace FOM\CoreBundle\Doctrine;

use Doctrine\Bundle\DoctrineBundle\Registry;
use Doctrine\ORM\EntityManagerInterface;
use Doctrine\ORM\Tools\SchemaTool;
use Symfony\Component\DependencyInjection\ContainerInterface;

/**
 * @author Andriy Oblivantsev <eslider@gmail.com>
 * @deprecated remove in FOM v3.3; never update your schema in a live session. Always use app/console doctrine:schema:update.
 */
class DoctrineHelper
{
    /**
     * Check and create table if not exists
     *
     * @param ContainerInterface $container ContainerInterface Container
     * @param                    $className String  Name of the ORM class
     * @param bool               $force     bool    Force update table
     */
    public static function checkAndCreateTableByEntityName(ContainerInterface $container, $className, $force = false)
    {
        /** @var Registry $doctrine */
        $doctrine      = $container->get('doctrine');
        /** @var EntityManagerInterface $manager */
        $manager       = $doctrine->getManager();
        $schemaTool    = new SchemaTool($manager);
        $schemaManager = $manager->getConnection()->getSchemaManager();
        $classMetadata = $manager->getClassMetadata($className);
        if ($force || !$schemaManager->tablesExist(array($classMetadata->getTableName()))) {
            $schemaTool->updateSchema(array($classMetadata), true);
        }
    }
}


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

/*
This project uses Automatic Package Restore feature of NuGet to resolve Aspose.Tasks for .NET API reference
when the project is build. Please check https:// Docs.nuget.org/consume/nuget-faq for more information.
If you do not wish to use NuGet, you can manually download Aspose.Tasks for .NET API from https://www.nuget.org/packages/Aspose.Tasks/,
install it and then add its reference to this project. For any issues, questions or suggestions
please feel free to contact us using https://forum.aspose.com/c/tasks
*/

namespace Aspose.Tasks.Examples.CSharp.WorkingWithCalendars.CreatingUpdatingAndRemoving
{
    class DefineWeekdaysForCalendar
    {
        public static void Run()
        {
            // ExStart:DefineWeekdaysForCalendar
            // This example shows how Aspose.Tasks API can be used to define a new Calendar, add week days to it and define working times for days
            // Create a project instance
            Project project = new Project();

            // Define Calendar
            Aspose.Tasks.Calendar cal = project.Calendars.Add("Calendar1");

            // Add working days monday through thursday with default timings
            cal.WeekDays.Add(WeekDay.CreateDefaultWorkingDay(DayType.Monday));
            cal.WeekDays.Add(WeekDay.CreateDefaultWorkingDay(DayType.Tuesday));
            cal.WeekDays.Add(WeekDay.CreateDefaultWorkingDay(DayType.Wednesday));
            cal.WeekDays.Add(WeekDay.CreateDefaultWorkingDay(DayType.Thursday));
            cal.WeekDays.Add(new WeekDay(DayType.Saturday));
            cal.WeekDays.Add(new WeekDay(DayType.Sunday));

            // Set friday as short working day
            WeekDay myWeekDay = new WeekDay(DayType.Friday);

            // Sets working time. Only time part of DateTime is important
            WorkingTime wt1 = new WorkingTime();
            wt1.FromTime = new DateTime(1, 1, 1, 9, 0, 0, 0);
            wt1.ToTime = new DateTime(1, 1, 1, 12, 0, 0, 0);
            WorkingTime wt2 = new WorkingTime();
            wt2.FromTime = new DateTime(1, 1, 1, 13, 0, 0, 0);
            wt2.ToTime = new DateTime(1, 1, 1, 16, 0, 0, 0);
            myWeekDay.WorkingTimes.Add(wt1);
            myWeekDay.WorkingTimes.Add(wt2);
            myWeekDay.DayWorking = true;
            cal.WeekDays.Add(myWeekDay);

            // Save the Project
            string dataDir = RunExamples.GetDataDir(System.Reflection.MethodBase.GetCurrentMethod().DeclaringType.FullName);
            project.Save("Project_DefineCalendarWeekdays_out.xml", Aspose.Tasks.Saving.SaveFileFormat.XML);
            // ExEnd:DefineWeekdaysForCalendar
        }
    }
}


text:
#ifndef VP9_DECODER_VP9_DECODFRAME_H_
#define VP9_DECODER_VP9_DECODFRAME_H_

struct VP9Common;
struct VP9Decompressor;

void vp9_init_dequantizer(struct VP9Common *pc);
int vp9_decode_frame(struct VP9Decompressor *cpi, const uint8_t **p_data_end);
vp9_prob vp9_read_prob_diff_update(vp9_reader *r, int oldp);

#endif  // VP9_DECODER_VP9_DECODFRAME_H_


text:
package nl.surfsara.newsreader.pipeline.modules;

import java.io.ByteArrayOutputStream;
import java.io.File;
import java.io.FileOutputStream;
import java.io.InputStream;
import java.util.UUID;

import org.apache.commons.io.IOUtils;
import org.apache.log4j.Logger;

/**
 * An implementation of a the FBK-time Newsreader NLP component.
 *
 * Most Newsreader components run as a run.sh bash script that consumes a NAF
 * text from standard in and outputs the annotated NAF text to standard out. For
 * running on Hadoop two default arguments have been added: the absolute path to
 * the component directory and an absolute path to a directory usable as scratch
 * or temporary storage. In addition FBK-time needs the document to be stored on
 * local scratch and is provided with this file as one of the arguments.
 *
 * This class sets up the input- and outputstreams and calls the run.sh script
 * with the correct arguments. Failures are flagged due to timeout (failure to
 * process in time) or by exceeding a threshold of newlines in the standard
 * error stream (see the PipelineStep class for these settings).
 *
 * @author mathijs.kattenberg@surfsara.nl
 */
public class NAFFileProvidedNewsreaderModule extends SubprocessModule {
	private static final Logger logger = Logger.getLogger(NAFFileProvidedNewsreaderModule.class);

	private PipelineStep pipelineStep;

	public NAFFileProvidedNewsreaderModule(PipelineStep step) {
		this.pipelineStep = step;
	}

	@Override
	public Module call() throws Exception {
		ByteArrayOutputStream bos = new ByteArrayOutputStream();
		ByteArrayOutputStream bes = new ByteArrayOutputStream();

		String filename = UUID.randomUUID().toString();
		File xmlf = new File(getLocalDirectory() + "/" + filename);
		FileOutputStream fos = new FileOutputStream(xmlf);
		InputStream xmlStream = IOUtils.toInputStream(getInputDocument(), "UTF-8");
		IOUtils.copy(xmlStream, fos);
		fos.flush();
		fos.close();
		xmlStream.close();

		File f = new File(pipelineStep.getModulePath() + "/run.sh.hadoop");
		File component = new File(pipelineStep.getModulePath());
		File scratch = new File(getLocalDirectory());

		super.setCommandLine("/bin/bash " + f.getAbsolutePath() + " " + component.getAbsolutePath() + "/ " + scratch.getAbsolutePath() + "/ " + xmlf.getAbsolutePath());

		super.setSubProcessStdIn(IOUtils.toInputStream(getInputDocument()));
		super.setSubProcessStdOut(bos);
		super.setSubProcessStdErr(bes);
		super.runSubprocess();

		String stderr = bes.toString();
		int newlines = stderr.split(System.getProperty("line.separator")).length;
		if (newlines > pipelineStep.getNumErrorLines()) {
			setFailed(true);
		}
		logger.error(stderr);
		bos.flush();
		setOutputDocument(bos.toString());
		bos.close();
		bes.close();
		xmlf.delete();
		return this;
	}
}


text:
<?xml version='1.0' encoding='UTF-8' standalone='no'?>
<doxygen xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:noNamespaceSchemaLocation="compound.xsd" version="1.8.6">
  <compounddef id="namespacestd" kind="namespace">
    <compoundname>std</compoundname>
    <briefdescription>
    </briefdescription>
    <detaileddescription>
    </detaileddescription>
    <location file="/home/glegall/prog_workspace/Robot_car/prog/headers/manager/block.h" line="9" column="1"/>
  </compounddef>
</doxygen>


text:
from sqlalchemy import Boolean, Column, DateTime, ForeignKey
from sqlalchemy import Integer, MetaData, String, Table, Text
from nova import log as logging

meta = MetaData()

# Just for the ForeignKey and column creation to succeed, these are not the
# actual definitions of instances or services.
instances = Table('instances', meta,
        Column('id', Integer(), primary_key=True, nullable=False),
        )

services = Table('services', meta,
        Column('id', Integer(), primary_key=True, nullable=False),
        )

networks = Table('networks', meta,
        Column('id', Integer(), primary_key=True, nullable=False),
        )

volumes = Table('volumes', meta,
        Column('id', Integer(), primary_key=True, nullable=False),
        )

#
# New Tables
#
certificates = Table('certificates', meta,
        Column('created_at', DateTime(timezone=False)),
        Column('updated_at', DateTime(timezone=False)),
        Column('deleted_at', DateTime(timezone=False)),
        Column('deleted', Boolean(create_constraint=True, name=None)),
        Column('id', Integer(), primary_key=True, nullable=False),
        Column('user_id',
               String(length=255, convert_unicode=False, assert_unicode=None,
                      unicode_error=None, _warn_on_bytestring=False)),
        Column('project_id',
               String(length=255, convert_unicode=False, assert_unicode=None,
                      unicode_error=None, _warn_on_bytestring=False)),
        Column('file_name',
               String(length=255, convert_unicode=False, assert_unicode=None,
                      unicode_error=None, _warn_on_bytestring=False)),
        )

consoles = Table('consoles', meta,
        Column('created_at', DateTime(timezone=False)),
        Column('updated_at', DateTime(timezone=False)),
        Column('deleted_at', DateTime(timezone=False)),
        Column('deleted', Boolean(create_constraint=True, name=None)),
        Column('id', Integer(), primary_key=True, nullable=False),
        Column('instance_name',
               String(length=255, convert_unicode=False, assert_unicode=None,
                      unicode_error=None, _warn_on_bytestring=False)),
        Column('instance_id', Integer()),
        Column('password',
               String(length=255, convert_unicode=False, assert_unicode=None,
                      unicode_error=None, _warn_on_bytestring=False)),
        Column('port', Integer(), nullable=True),
        Column('pool_id',
               Integer(),
               ForeignKey('console_pools.id')),
        )

console_pools = Table('console_pools', meta,
        Column('created_at', DateTime(timezone=False)),
        Column('updated_at', DateTime(timezone=False)),
        Column('deleted_at', DateTime(timezone=False)),
        Column('deleted', Boolean(create_constraint=True, name=None)),
        Column('id', Integer(), primary_key=True, nullable=False),
        Column('address',
               String(length=255, convert_unicode=False, assert_unicode=None,
                      unicode_error=None, _warn_on_bytestring=False)),
        Column('username',
               String(length=255, convert_unicode=False, assert_unicode=None,
                      unicode_error=None, _warn_on_bytestring=False)),
        Column('password',
               String(length=255, convert_unicode=False, assert_unicode=None,
                      unicode_error=None, _warn_on_bytestring=False)),
        Column('console_type',
               String(length=255, convert_unicode=False, assert_unicode=None,
                      unicode_error=None, _warn_on_bytestring=False)),
        Column('public_hostname',
               String(length=255, convert_unicode=False, assert_unicode=None,
                      unicode_error=None, _warn_on_bytestring=False)),
        Column('host',
               String(length=255, convert_unicode=False, assert_unicode=None,
                      unicode_error=None, _warn_on_bytestring=False)),
        Column('compute_host',
               String(length=255, convert_unicode=False, assert_unicode=None,
                      unicode_error=None, _warn_on_bytestring=False)),
        )

instance_actions = Table('instance_actions', meta,
        Column('created_at', DateTime(timezone=False)),
        Column('updated_at', DateTime(timezone=False)),
        Column('deleted_at', DateTime(timezone=False)),
        Column('deleted', Boolean(create_constraint=True, name=None)),
        Column('id', Integer(), primary_key=True, nullable=False),
        Column('instance_id',
               Integer(),
               ForeignKey('instances.id')),
        Column('action',
               String(length=255, convert_unicode=False, assert_unicode=None,
                      unicode_error=None, _warn_on_bytestring=False)),
        Column('error',
               Text(length=None, convert_unicode=False, assert_unicode=None,
                    unicode_error=None, _warn_on_bytestring=False)),
        )

iscsi_targets = Table('iscsi_targets', meta,
        Column('created_at', DateTime(timezone=False)),
        Column('updated_at', DateTime(timezone=False)),
        Column('deleted_at', DateTime(timezone=False)),
        Column('deleted', Boolean(create_constraint=True, name=None)),
        Column('id', Integer(), primary_key=True, nullable=False),
        Column('target_num', Integer()),
        Column('host',
               String(length=255, convert_unicode=False, assert_unicode=None,
                      unicode_error=None, _warn_on_bytestring=False)),
        Column('volume_id',
               Integer(),
               ForeignKey('volumes.id'),
               nullable=True),
        )

#
# Tables to alter
#
auth_tokens = Table('auth_tokens', meta,
        Column('created_at', DateTime(timezone=False)),
        Column('updated_at', DateTime(timezone=False)),
        Column('deleted_at', DateTime(timezone=False)),
        Column('deleted', Boolean(create_constraint=True, name=None)),
        Column('token_hash',
               String(length=255, convert_unicode=False, assert_unicode=None,
                      unicode_error=None, _warn_on_bytestring=False),
               primary_key=True,
               nullable=False),
        Column('user_id', Integer()),
        Column('server_manageent_url',
               String(length=255, convert_unicode=False, assert_unicode=None,
                      unicode_error=None, _warn_on_bytestring=False)),
        Column('storage_url',
               String(length=255, convert_unicode=False, assert_unicode=None,
                      unicode_error=None, _warn_on_bytestring=False)),
        Column('cdn_management_url',
               String(length=255, convert_unicode=False, assert_unicode=None,
                      unicode_error=None, _warn_on_bytestring=False)),
        )

instances_availability_zone = Column(
        'availability_zone',
        String(length=255, convert_unicode=False, assert_unicode=None,
               unicode_error=None, _warn_on_bytestring=False))

instances_locked = Column('locked',
                Boolean(create_constraint=True, name=None))

networks_cidr_v6 = Column(
        'cidr_v6',
        String(length=255, convert_unicode=False, assert_unicode=None,
               unicode_error=None, _warn_on_bytestring=False))

networks_ra_server = Column(
        'ra_server',
        String(length=255, convert_unicode=False, assert_unicode=None,
               unicode_error=None, _warn_on_bytestring=False))

services_availability_zone = Column(
        'availability_zone',
        String(length=255, convert_unicode=False, assert_unicode=None,
               unicode_error=None, _warn_on_bytestring=False))

def upgrade(migrate_engine):
    # Upgrade operations go here. Don't create your own engine;
    # bind migrate_engine to your metadata
    meta.bind = migrate_engine

    tables = [certificates, console_pools, consoles, instance_actions,
              iscsi_targets]
    for table in tables:
        try:
            table.create()
        except Exception:
            logging.info(repr(table))
            logging.exception('Exception while creating table')
            meta.drop_all(tables=tables)
            raise

    auth_tokens.c.user_id.alter(type=String(length=255,
                                            convert_unicode=False,
                                            assert_unicode=None,
                                            unicode_error=None,
                                            _warn_on_bytestring=False))

    instances.create_column(instances_availability_zone)
    instances.create_column(instances_locked)
    networks.create_column(networks_cidr_v6)
    networks.create_column(networks_ra_server)
    services.create_column(services_availability_zone)


text:
package org.jmock.api;

public interface ExpectationCollector {
    void add(Expectation expectation);
}


text:
class HelloWorld
	# Prints Hello World
	def helloWorld()
		puts "Hello world!"
	end
end


text:
<?xml version="1.0" encoding="UTF-8"?><concept xmlns="http://www.w3.org/2004/02/skos/core#">
      <prefLabel>PRE-EXISTING CONDITION</prefLabel>
      <definition>A health problem you had before the date that a new insurance policy
         starts.</definition>
   </concept>


text:
package clients

import (
	"encoding/json"
	"fmt"
	"net/http"
	"net/url"
	"regexp"
	"sort"
	"strings"

	"github.com/pivotal-cf-experimental/warrant/internal/server/common"
	"github.com/pivotal-cf-experimental/warrant/internal/server/domain"
)

type listHandler struct {
	clients *domain.Clients
	tokens  *domain.Tokens
}

// TODO: check for client.admin scope
func (h listHandler) ServeHTTP(w http.ResponseWriter, req *http.Request) {
	token := req.Header.Get("Authorization")
	token = strings.TrimPrefix(token, "Bearer ")
	token = strings.TrimPrefix(token, "bearer ")

	if len(token) == 0 {
		common.JSONError(w, http.StatusUnauthorized, "Full authentication is required to access this resource", "unauthorized")
		return
	}
	if ok := h.tokens.Validate(token, domain.Token{
		Authorities: []string{"clients.read"},
		Audiences:   []string{"clients"},
	}); !ok {
		common.JSONError(w, http.StatusUnauthorized, "Full authentication is required to access this resource", "unauthorized")
		return
	}

	query, err := url.ParseQuery(req.URL.RawQuery)
	if err != nil {
		panic(err)
	}

	list := domain.ClientsList{}

	filter := query.Get("filter")
	if filter != "" {
		matches := regexp.MustCompile(`(.*) (.*) ['"](.*)['"]$`).FindStringSubmatch(filter)
		parameter := matches[1]
		operator := matches[2]
		value := matches[3]

		if !validParameter(parameter) {
			common.JSONError(w, http.StatusBadRequest, fmt.Sprintf("Invalid filter expression: [%s]", filter), "scim")
			return
		}

		if !validOperator(operator) {
			common.JSONError(w, http.StatusBadRequest, fmt.Sprintf("Invalid filter expression: [%s]", filter), "scim")
			return
		}

		client, found := h.clients.Get(value)
		if found {
			list = append(list, client)
		}
	} else {
		list = append(list, h.clients.All()...)
	}

	switch by := query.Get("sortBy"); by {
	case "name":
		sort.Sort(domain.ByName(list))
	default:
		sort.Sort(domain.ByID(list))
	}

	response, err := json.Marshal(list.ToDocument())
	if err != nil {
		panic(err)
	}

	w.WriteHeader(http.StatusOK)
	w.Write([]byte(response))
}

func validParameter(parameter string) bool {
	for _, p := range []string{"id"} {
		if strings.ToLower(parameter) == p {
			return true
		}
	}

	return false
}

func validOperator(operator string) bool {
	for _, o := range []string{"eq"} {
		if strings.ToLower(operator) == o {
			return true
		}
	}

	return false
}


text:
using System;
using System.Collections.Generic;
using Eto.Forms;
using Eto.Drawing;

namespace ArbitesEto
{
    partial class UCBoard : Panel
    {
        Label LName;
        Button BtnSave, BtnLoad, BtnAddLayer;
        StackLayout SLMain;
        Scrollable SCMain;
        void InitializeComponent()
        {

            var TLMain = new TableLayout();
            var SLTop = new StackLayout();
            SLTop.Orientation = Orientation.Horizontal;
            SLTop.VerticalContentAlignment = VerticalAlignment.Center;
            SLTop.Padding = 5;
            SLTop.Spacing = 5;
            TLMain.Rows.Add(SLTop);

            LName = new Label();
            LName.Text = "Keyboard Type: NA";
            SLTop.Items.Add(LName);

            BtnAddLayer = new Button();
            BtnAddLayer.Text = "Add New Layer";
            SLTop.Items.Add(BtnAddLayer);

            BtnSave = new Button();
            BtnSave.Text = "Save Layout";
            SLTop.Items.Add(BtnSave);

            BtnLoad = new Button();
            BtnLoad.Text = "Load Layout";
            SLTop.Items.Add(BtnLoad);
            Content = new Label { Text = "Some Content" };

            SCMain = new Scrollable();
            SCMain.Border = BorderType.None;
            TLMain.Rows.Add(SCMain);

            SLMain = new StackLayout();
            SLMain.Orientation = Orientation.Horizontal;
            SCMain.Content = SLMain;

            Content = TLMain;
        }
    }
}


text:
@interface ExpnadTableViewCell : UITableViewCell

@property (weak, nonatomic) IBOutlet UILabel *titleLabel;
@property (weak, nonatomic) IBOutlet UILabel *DescriptionLabel;
@property (weak, nonatomic) IBOutlet UIView *detailContainerView;
@property (weak, nonatomic) IBOutlet UIButton *buttonIcon;
@property (weak, nonatomic) IBOutlet UIImageView *imageIcon;

@property (nonatomic, assign) BOOL withDetails;

- (void)animateOpen;
- (void)animateClosed;

@end


text:
The Echo Nukleus is responsible for echoing data from an inbound stream to the correlated outbound stream.

## Control Commands
The Echo Nukleus is controlled by sending control commands to a memory-mapped file at `[config-dir]/echo/control`.

The following control commands and responses are supported by the Echo Nukleus.

### ERROR response (0x40000000)
Indicates that an error has occurred when attempting to process a command.

```
ERROR
[long] correlation id
```

### CAPTURE command (0x00000001)
Creates, maps and reads streams from a memory-mapped file at `[config-dir]/echo/streams/[source]`.

```
CAPTURE
[long] correlation id
[string] source nukleus name
```

### CAPTURED response (0x40000001)
Indicates that the CAPTURE command completed successfully.

```
CAPTURED
[long] correlation id
```

### UNCAPTURE command (0x00000002)
No longer reads streams from the memory-mapped file at `[config-dir]/echo/streams/[source]`.

```
UNCAPTURE
[long] correlation id
[string] source nukleus name
```

### UNCAPTURED response (0x40000002)
Indicates that the UNCAPTURE command completed successfully.

```
UNCAPTURED
[long] correlation id
```

### ROUTE command (0x00000003)
Maps existing file and writes streams to a memory-mapped file at `[config-dir]/[destination]/streams/echo`.

```
ROUTE
[long] correlation id
[string] destination nukleus name
```

### ROUTED response (0x40000003)
Indicates that the ROUTE command completed successfully.

```
ROUTED
[long] correlation id
```

### UNROUTE command (0x00000004)
Unmaps and no longer writes streams to the memory-mapped file at `[config-dir]/[destination]/streams/echo`.

```
UNROUTE
[long] correlation id
[string] destination nukleus name
```

### UNROUTED response (0x40000004)
Indicates that the UNROUTE command completed successfully.

```
UNROUTED
[long] correlation id
```

### BIND command (0x00000011)
Binds incoming streams to be echoed.

```
BIND
[long] correlation id
[string] source nukleus name
[long] source nukleus reference
```

### BOUND response (0x40000011)
Indicates that the BIND command completed successfully, returning a bind reference.

```
BOUND
[long] correlation id
[long] bind reference
```

### UNBIND command (0x00000012)
No longer binds incoming streams to be echoed for the previously bound source and source reference.

```
UNBIND
[long] correlation id
[long] bind reference
```

### UNBOUND response (0x40000012)
Indicates that the UNBIND command completed successfully.

```
UNBOUND
[long] correlation id
```

### PREPARE command (0x00000013)
Prepares to initiate streams to the specified destination and destination reference.

```
PREPARE
[long] correlation id
[string] destination nukleus name
[long] destination nukleus reference
```

### PREPARED response (0x40000013)
Indicates that the PREPARE command completed successfully, returning a prepare reference.

```
PREPARED
[long] correlation id
[long] prepare reference
```

### UNPREPARE command (0x00000014)
No longer prepares incoming streams from the handler for this prepare reference.

```
UNPREPARE
[long] correlation id
[long] prepare reference
```

### UNPREPARED response (0x40000014)
Indicates that the UNPREPARED command completed successfully.

```
UNPREPARED
[long] correlation id
```

## Stream Events
The Echo Nukleus describes unidirectional streams of data with the following events.

### RESET event (0x00000000)
Resets the stream as an error condition has occurred.

```
RESET
[long] stream id
```

### BEGIN event (0x00000001)
Indicates the beginning of a new stream.

If the stream identifier is odd, then the bind/prepare reference is required as it is initiating a bidirectional connection.
If the stream identifier is even and non-zero, then the correlating stream identifier of the initiating stream is required instead as this stream represents the opposite direction of an already initiated bidirectional connection.

```
BEGIN
[long] stream id
[long] bind/prepare reference | correlating stream id
```

### DATA event (0x00000002)
Indicates data for an existing stream.

```
DATA
[long] stream id
[bytes] payload
```

### END event (0x00000003)
Indicates the end of an existing stream

```
END
[long] stream id
```


text:
@interface MCNavigationView4 : MCViewController

@end


text:
import functools
from corehq.apps.app_manager import id_strings
from dimagi.utils.decorators.memoized import memoized
from corehq.apps.app_manager.util import is_sort_only_column
import langcodes
import commcare_translations
from corehq.apps.app_manager.templatetags.xforms_extras import clean_trans

def non_empty_only(dct):
    return dict([(key, value) for key, value in dct.items() if value])

def _create_custom_app_strings(app, lang):

    def trans(d):
        return clean_trans(d, langs)

    def maybe_add_index(text):
        if app.build_version >= '2.8':
            numeric_nav_on = app.profile.get('properties', {}).get('cc-entry-mode') == 'cc-entry-review'
            if app.profile.get('features', {}).get('sense') == 'true' or numeric_nav_on:
                text = "${0} %s" % (text,) if not (text and text[0].isdigit()) else text
        return text

    langs = [lang] + app.langs
    yield id_strings.homescreen_title(), app.name
    yield id_strings.app_display_name(), app.name

    yield 'cchq.case', "Case"
    yield 'cchq.referral', "Referral"

    # include language code names
    for lc in app.langs:
        name = langcodes.get_name(lc) or lc
        if name:
            yield lc, name

    for module in app.get_modules():
        for detail_type, detail, _ in module.get_details():
            if detail_type.startswith('case'):
                label = trans(module.case_label)
            else:
                label = trans(module.referral_label)
            yield id_strings.detail_title_locale(module, detail_type), label

            for column in detail.get_columns():
                if not is_sort_only_column(column):
                    yield id_strings.detail_column_header_locale(module, detail_type, column), trans(column.header)

                if column.format in ('enum', 'enum-image'):
                    for item in column.enum:
                        yield id_strings.detail_column_enum_variable(module, detail_type, column, item.key), trans(item.value)

        yield id_strings.module_locale(module), maybe_add_index(trans(module.name))
        if hasattr(module, 'case_list'):
            if module.case_list.show:
                yield id_strings.case_list_locale(module), trans(module.case_list.label) or "Case List"
        if hasattr(module, 'referral_list'):
            if module.referral_list.show:
                yield id_strings.referral_list_locale(module), trans(module.referral_list.label)
        for form in module.get_forms():
            form_name = trans(form.name) + ('${0}' if form.show_count else '')
            yield id_strings.form_locale(form), maybe_add_index(form_name)

class AppStringsBase(object):

    def __init__(self, load_translations):
        self._load_translations = load_translations

    @memoized
    def get_default_translations(self, lang):
        return self._load_translations(lang)

    def create_custom_app_strings(self, app, lang, for_default=False):
        custom = dict(_create_custom_app_strings(app, lang))
        if not for_default:
            custom = non_empty_only(custom)
        return custom

    def create_app_strings(self, app, lang, for_default=False):
        messages = {}
        for part in self.app_strings_parts(app, lang, for_default=for_default):
            messages.update(part)
        return commcare_translations.dumps(messages).encode('utf-8')

    def app_strings_parts(self, app, lang, for_default=False):
        raise NotImplementedError()

    def create_default_app_strings(self, app):
        messages = {}

        for lc in reversed(app.langs):
            if lc == "default":
                continue
            new_messages = commcare_translations.loads(
                self.create_app_strings(app, lc, for_default=True)
            )

            for key, val in new_messages.items():
                # do not overwrite a real trans with a blank trans
                if not (val == '' and key in messages):
                    messages[key] = val

        if 'case_sharing.exactly_one_group' not in messages:
            messages['case_sharing.exactly_one_group'] = \
                (u'The case sharing settings for your user are incorrect. '
                 u'This user must be in exactly one case sharing group. Please contact your supervisor.')

        if 'case_autoload.fixture.exactly_one_fixture' not in messages:
            messages['case_autoload.fixture.exactly_one_fixture'] = \
                (u'The lookup table settings for your user are incorrect. '
                    u'This user must have access to exactly one lookup table row for the table: ${0}')

        from corehq.apps.app_manager.models import AUTO_SELECT_CASE, AUTO_SELECT_FIXTURE, AUTO_SELECT_USER

        mode_text = {
            AUTO_SELECT_FIXTURE: u'lookup table field',
            AUTO_SELECT_USER: u'user data key',
            AUTO_SELECT_CASE: u'case index'
        }

        for mode in [AUTO_SELECT_FIXTURE, AUTO_SELECT_CASE, AUTO_SELECT_USER]:
            key = 'case_autoload.{0}.property_missing'.format(mode)
            if key not in messages:
                messages[key] = (u'The {} specified for case auto-selecting '
                                 u'could not be found: ${{0}}').format(mode_text[mode])

        for mode in [AUTO_SELECT_FIXTURE, AUTO_SELECT_CASE, AUTO_SELECT_USER]:
            key = 'case_autoload.{0}.case_missing'.format(mode)
            if key not in messages:
                messages[key] = u'Unable to find case referenced by auto-select case ID.'

        return commcare_translations.dumps(messages).encode('utf-8')

class DumpKnownAppStrings(AppStringsBase):

    def app_strings_parts(self, app, lang, for_default=False):
        yield self.create_custom_app_strings(app, lang, for_default=for_default)
        yield self.get_default_translations(lang)
        yield non_empty_only(app.translations.get(lang, {}))

class SimpleAppStrings(AppStringsBase):

    def app_strings_parts(self, app, lang, for_default=False):
        yield self.create_custom_app_strings(app, lang, for_default=for_default)
        if not for_default:
            yield non_empty_only(app.translations.get(lang, {}))

class SelectKnownAppStrings(AppStringsBase):

    def get_app_translation_keys(self, app):
        return set.union(set(), *(
            set(t.keys()) for t in app.translations.values()
        ))

    def app_strings_parts(self, app, lang, for_default=False):
        yield self.create_custom_app_strings(app, lang,
                                             for_default=for_default)
        cc_trans = self.get_default_translations(lang)
        yield dict((key, cc_trans[key])
                   for key in self.get_app_translation_keys(app)
                   if key in cc_trans)
        yield non_empty_only(app.translations.get(lang, {}))

CHOICES = {
    'dump-known': DumpKnownAppStrings(commcare_translations.load_translations),
    'simple': SimpleAppStrings(None),
    'select-known': SelectKnownAppStrings(
        functools.partial(commcare_translations.load_translations, version=2)
    ),
}


text:
id: 6144e818fd5ea704fe56081d
title: Step 28
challengeType: 0
dashedName: step-28
---

# --description--

Give each `fieldset` an adaquate `name` attribute. Then, give both unordered lists a `class` of `answers-list`.

Finally, add use the `legend` to caption the content of the `fieldset`, by placing a true/false question as the text content.

# --hints--

You should give the first `fieldset` an adaquate `name` attribute. _Hint: I would use `html-question-one`_

```js
assert.notEmpty(document.querySelectorAll('fieldset')?.[0]?.name);
```

You should give the second `fieldset` an adaquate `name` attribute. _Hint: I would use `html-question-two`_

```js
assert.notEmpty(document.querySelectorAll('fieldset')?.[1]?.name);
```

You should give the first `ul` element a `class` of `answers-list`.

```js
assert.equal(document.querySelectorAll('fieldset > ul')?.[0]?.className, 'answers-list');
```

You should give the second `ul` element a `class` of `answers-list`.

```js
assert.equal(document.querySelectorAll('fieldset > ul')?.[1]?.className, 'answers-list');
```

You should give the first `legend` element text content.

```js
assert.notEmpty(document.querySelectorAll('legend')?.[0]?.textContent);
```

You should give the second `legend` element text content.

```js
assert.notEmpty(document.querySelectorAll('legend')?.[1]?.textContent);
```

You should not use the same text content for both `legend` elements.

```js
assert.notEqual(document.querySelectorAll('legend')?.[0]?.textContent, document.querySelectorAll('legend')?.[1]?.textContent);
```

# --seed--

## --seed-contents--

```html
<!DOCTYPE html>
<html lang="en">
  <head>
    <meta charset="UTF-8" />
    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
    <meta name="description" content="freeCodeCamp Accessibility Quiz practice project" />
    <title>freeCodeCamp: Accessibility Quiz</title>
    <link rel="stylesheet" href="styles.css" />
  </head>
  <body>
    <header>
      <img id="logo" src="https://cdn.freecodecamp.org/platform/universal/fcc_primary.svg">
      <h1>HTML/CSS Quiz</h1>
      <nav>
        <ul>
          <li><a href="#student-info">INFO</a></li>
          <li><a href="#html-questions">HTML</a></li>
          <li><a href="#css-questions">CSS</a></li>
			  </ul>
      </nav>
    </header>
    <main>
      <form method="post" action="https://freecodecamp.org/practice-project/accessibility-quiz">
        <section role="region" aria-labelledby="student-info">
          <h2 id="student-info">Student Info</h2>
          <div class="info">
            <label for="student-name">Name:</label>
            <input type="text" name="student-name" id="student-name" />
          </div>
          <div class="info">
            <label for="student-email">Email:</label>
            <input type="email" name="student-email" id="student-email" />
          </div>
          <div class="info">
            <label for="birth-date">D.O.B.<span class="sr-only">(Date of Birth)</span></label>
            <input type="date" name="birth-date" id="birth-date" />
          </div>
        </section>
--fcc-editable-region--
        <section role="region" aria-labelledby="html-questions">
          <h2 id="html-questions">HTML</h2>
          <div class="question-block">
            <p>1</p>
            <fieldset class="question">
              <legend></legend>
              <ul>
                <li></li>
                <li></li>
              </ul>
            </fieldset>
          </div>
          <div class="question-block">
            <p>2</p>
            <fieldset class="question">
              <legend></legend>
              <ul>
                <li></li>
                <li></li>
              </ul>
            </fieldset>
          </div>
        </section>
--fcc-editable-region--
        <section role="region" aria-labelledby="css-questions">
          <h2 id="css-questions">CSS</h2>
        </section>
      </form>
    </main>
  </body>
</html>

```

```css
body {
  background: #f5f6f7;
	color: #1b1b32;
	font-family: Helvetica;
	margin: 0;
}

header {
  width: 100%;
	height: 50px;
	background-color: #1b1b32;
	display: flex;
}

#logo {
  width: max(100px, 18vw);
	background-color: #0a0a23;
  aspect-ratio: 35 / 4;
	padding: 0.4rem;
}

h1 {
  color: #f1be32;
	font-size: min(5vw, 1.2em);
}

nav {
  width: 50%;
	max-width: 300px;
	height: 50px;
}

nav > ul {
  display: flex;
	justify-content: space-evenly;
}

h1,
h2 {
  font-family: Verdana, Tahoma;
}

h2 {
  border-bottom: 4px solid #dfdfe2;
}

.sr-only {
	position: absolute;
	width: 1px;
	height: 1px;
	padding: 0;
	margin: -1px;
	overflow: hidden;
	clip: rect(0, 0, 0, 0);
	white-space: nowrap;
	border: 0;
}

```


text:
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE AndroidXML>
<!--
This software is subject to the license described in the License.txt file
included with this software distribution. You may not use this file except in compliance
with this license.

Copyright (c) Dynastream Innovations Inc. 2013
All rights reserved.
-->
<ScrollView xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:tools="http://schemas.android.com/tools"
    android:id="@+id/scrollView1"
    android:layout_width="match_parent"
    android:layout_height="wrap_content" >

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

        <RelativeLayout
            android:layout_width="match_parent"
            android:layout_height="wrap_content"
            android:background="#D7D7D7"
            android:paddingBottom="3dp"
            android:paddingLeft="5dp"
            android:paddingRight="10dp"
            android:paddingTop="3dp" >

            <TextView
                android:layout_width="wrap_content"
                android:layout_height="wrap_content"
                android:layout_alignParentLeft="true"
                android:layout_centerVertical="true"
                android:layout_marginRight="5dp"
                android:text="Name:" />

            <EditText
                android:id="@+id/editText_FriendlyName"
                android:layout_width="wrap_content"
                android:layout_height="wrap_content"
                android:layout_alignParentRight="true"
                android:layout_centerVertical="true"
                android:gravity="center"
                android:inputType="textCapWords"
                android:text="New User" />

        </RelativeLayout>

        <RelativeLayout
            android:layout_width="match_parent"
            android:layout_height="wrap_content"
            android:background="#EBEBEB"
            android:paddingBottom="3dp"
            android:paddingLeft="5dp"
            android:paddingRight="10dp"
            android:paddingTop="3dp" >

            <TextView
                android:layout_width="wrap_content"
                android:layout_height="wrap_content"
                android:layout_alignParentLeft="true"
                android:layout_centerVertical="true"
                android:layout_marginRight="5dp"
                android:text="Gender:" />

            <RadioGroup
            android:layout_width="wrap_content"
            android:layout_height="wrap_content"
            android:layout_alignParentRight="true"
            android:background="#EBEBEB"
            android:orientation="horizontal"
            android:paddingBottom="3dp"
            android:paddingLeft="5dp"
            android:paddingRight="10dp"
            android:paddingTop="3dp" >

            <RadioButton
                android:id="@+id/radioButton_Female"
                android:layout_width="wrap_content"
                android:layout_height="wrap_content"
                android:layout_marginRight="10dp"
                android:layout_gravity="center_vertical"
                android:checked="true"
                android:text="Female" />

            <RadioButton
                android:id="@+id/radioButton_Male"
                android:layout_width="wrap_content"
                android:layout_height="wrap_content"
                android:layout_gravity="center_vertical"
                android:text="Male" />

        </RadioGroup>

        </RelativeLayout>

        <RelativeLayout
            android:layout_width="match_parent"
            android:layout_height="wrap_content"
            android:background="#D7D7D7"
            android:paddingBottom="3dp"
            android:paddingLeft="5dp"
            android:paddingRight="10dp"
            android:paddingTop="3dp" >

            <TextView
                android:layout_width="wrap_content"
                android:layout_height="wrap_content"
                android:layout_alignParentLeft="true"
                android:layout_centerVertical="true"
                android:layout_marginRight="5dp"
                android:text="Age:" />

            <EditText
                android:id="@+id/editText_Age"
                android:layout_width="wrap_content"
                android:layout_height="wrap_content"
                android:layout_alignParentRight="true"
                android:layout_centerVertical="true"
                android:gravity="center"
                android:inputType="number"
                android:maxLength="3"
                android:minWidth="125dp"
                android:text="28"
                tools:ignore="TextFields" />

        </RelativeLayout>

        <RelativeLayout
            android:layout_width="match_parent"
            android:layout_height="wrap_content"
            android:background="#EBEBEB"
            android:paddingBottom="3dp"
            android:paddingLeft="5dp"
            android:paddingRight="10dp"
            android:paddingTop="3dp" >

            <TextView
                android:layout_width="wrap_content"
                android:layout_height="wrap_content"
                android:layout_alignParentLeft="true"
                android:layout_centerVertical="true"
                android:layout_marginRight="5dp"
                android:text="Height (cm):" />

            <EditText
                android:id="@+id/editText_Height"
                android:layout_width="wrap_content"
                android:layout_height="wrap_content"
                android:layout_alignParentRight="true"
                android:layout_centerVertical="true"
                android:gravity="center"
                android:inputType="number"
                android:maxLength="3"
                android:minWidth="125dp"
                android:text="165" />

        </RelativeLayout>

        <RelativeLayout
            android:layout_width="match_parent"
            android:layout_height="wrap_content"
            android:background="#D7D7D7"
            android:paddingBottom="3dp"
            android:paddingLeft="5dp"
            android:paddingRight="10dp"
            android:paddingTop="3dp" >

            <TextView
                android:layout_width="wrap_content"
                android:layout_height="wrap_content"
                android:layout_alignParentLeft="true"
                android:layout_centerVertical="true"
                android:layout_marginRight="5dp"
                android:text="Weight (kg):" />

            <EditText
                android:id="@+id/editText_Weight"
                android:layout_width="wrap_content"
                android:layout_height="wrap_content"
                android:layout_alignParentRight="true"
                android:layout_centerVertical="true"
                android:gravity="center"
                android:inputType="number|numberDecimal"
                android:maxLength="5"
                android:minWidth="125dp"
                android:text="54.3" />

        </RelativeLayout>

        <RelativeLayout
            android:layout_width="match_parent"
            android:layout_height="wrap_content"
            android:background="#EBEBEB"
            android:paddingBottom="3dp"
            android:paddingLeft="5dp"
            android:paddingRight="10dp"
            android:paddingTop="3dp" >

            <TextView
                android:layout_width="wrap_content"
                android:layout_height="wrap_content"
                android:layout_alignParentLeft="true"
                android:layout_centerVertical="true"
                android:layout_marginRight="5dp"
                android:text="Include workout file:" />

            <CheckBox
                android:id="@+id/checkBox_Workout"
                android:layout_width="wrap_content"
                android:layout_height="wrap_content"
                android:layout_alignParentRight="true"
                android:layout_centerVertical="true"
                android:gravity="center" />

        </RelativeLayout>

    </LinearLayout>

</ScrollView>


text:
open-conference-data
====================

Open Conference Data

This work is released under MIT license


text:
require File.expand_path(File.dirname(__FILE__) + '/spec_helper')

describe "Fingerjam" do
end


text:
package io.apibuilder.validation

import org.scalatest.matchers.should.Matchers
import org.scalatest.funspec.AnyFunSpec
import play.api.libs.json.{JsObject, Json}

class EnumValuesSpec extends AnyFunSpec with Matchers with helpers.Helpers {

  def makeFraudReview(riskEvaluation: String = "Pending"): JsObject = {
    Json.obj(
      "description" -> "lorem ipsum tmwHAn",
      "attributes" -> Json.obj(),
      "status_updated_at" -> "2019-11-04T20:22:31.861Z",
      "id" -> "lorem ipsum sRVdId",
      "order" -> Json.obj(
        "id" -> "lorem ipsum KllOf0",
        "number" -> "lorem ipsum KTjUpR"
      ),
      "status" -> "pending",
      "responsible_party" -> "flow",
      "liability" -> "flow",
      "organization_id" -> "lorem ipsum XlUr8X",
      "risk_evaluation" -> riskEvaluation
    )
  }

  it("serialize enums with values") {
    val fraudReview = flowMultiService.findType(
      "io.flow.internal.v0", "fraud_review"
    ).get

    def assertValid(value: String) = {
      rightOrErrors {
        flowMultiService.upcast(fraudReview, makeFraudReview(value))
      }
    }
    assertValid("Low-Risk") // use enum_value.value
    assertValid("low")      // use enum_value.name
  }

}


text:
/** \brief PLC Operating System Interface
 **
 ** PLC Operating System Interface
 **
 **/

/** \addtogroup CIAA_Firmware CIAA Firmware
 ** @{ */
/** \addtogroup PLC PLC Module
 ** @{ */

/*
 * Initials     Name
 * ---------------------------
 * ErPe         Eric Pernia
 *
 */

/*
 * modification history (new versions first)
 * -----------------------------------------------------------
 * 20140911 v0.0.1 ErPe initial version
 * 20150502 v0.0.1 ErPe rewrite for CIAA Firmware compatibility
 */

/*==================[inclusions]=============================================*/
#include "PLC_ElementaryDataTypes.h"
#include "PLC_OperatingSystem.h"

/*==================[macros and definitions]=================================*/

/*==================[internal data declaration]==============================*/

/** \brief PLC_TimersTime is a variable that counts time in milliseconds for PLC Timers. */
uint64_t PLC_TimersTime = 0;

/*==================[internal functions declaration]=========================*/

/*==================[internal data definition]===============================*/

/*==================[external data definition]===============================*/

/*==================[internal functions definition]==========================*/

/*==================[external functions definition]==========================*/

/** \brief It returns the PLC_TimersTime variable. */
uint64_t PLC_GetTimersTime(void)
{
   return PLC_TimersTime;
}

/** @} doxygen end group definition */
/** @} doxygen end group definition */
/*==================[end of file]============================================*/


text:
import {browser, by, element, ExpectedConditions, protractor} from 'protractor';

import {verifyNoBrowserErrors} from '../../../../e2e_util/e2e_util';

const URL = '/';

describe('MessageBroker', function() {
  afterEach(() => {
    verifyNoBrowserErrors();
    browser.ignoreSynchronization = false;
  });

  it('should bootstrap', () => {
    // This test can't wait for Angular as Testability is not available when using WebWorker
    browser.ignoreSynchronization = true;
    browser.get(URL);
    waitForBootstrap();
    expect(element(by.css('app h1')).getText()).toEqual('WebWorker MessageBroker Test');
  });

  it('should echo messages', () => {
    const VALUE = 'Hi There';
    // This test can't wait for Angular as Testability is not available when using WebWorker
    browser.ignoreSynchronization = true;
    browser.get(URL);
    waitForBootstrap();

    const input = element.all(by.css('#echo_input')).first();
    input.sendKeys(VALUE);
    element(by.css('#send_echo')).click();
    const area = element(by.css('#echo_result'));
    browser.wait(ExpectedConditions.textToBePresentInElement(area, VALUE), 5000);
    expect(area.getText()).toEqual(VALUE);
  });
});

function waitForBootstrap(): void {
  browser.wait(protractor.until.elementLocated(by.css('app h1')), 15000);
}