text:
<?php
defined('BASEPATH') OR exit('No direct script access allowed');

/*
| -------------------------------------------------------------------------
| URI ROUTING
| -------------------------------------------------------------------------
| This file lets you re-map URI requests to specific controller functions.
|
| Typically there is a one-to-one relationship between a URL string
| and its corresponding controller class/method. The segments in a
| URL normally follow this pattern:
|
|	example.com/class/method/id/
|
| In some instances, however, you may want to remap this relationship
| so that a different class/function is called than the one
| corresponding to the URL.
|
| Please see the user guide for complete details:
|
|	https://codeigniter.com/user_guide/general/routing.html
|
| -------------------------------------------------------------------------
| RESERVED ROUTES
| -------------------------------------------------------------------------
|
| There are three reserved routes:
|
|	$route['default_controller'] = 'welcome';
|
| This route indicates which controller class should be loaded if the
| URI contains no data. In the above example, the "welcome" class
| would be loaded.
|
|	$route['404_override'] = 'errors/page_missing';
|
| This route will tell the Router which controller/method to use if those
| provided in the URL cannot be matched to a valid route.
|
|	$route['translate_uri_dashes'] = FALSE;
|
| This is not exactly a route, but allows you to automatically route
| controller and method names that contain dashes. '-' isn't a valid
| class or method name character, so it requires translation.
| When you set this option to TRUE, it will replace ALL dashes in the
| controller and method URI segments.
|
| Examples:	my-controller/index	-> my_controller/index
|		my-controller/my-method	-> my_controller/my_method
*/
$route['default_controller'] = 'main';
$route['404_override'] = '';
$route['translate_uri_dashes'] = FALSE;

// Route for our service
$route['artworks/(:num)'] = 'artworks/detail/$1';
$route['artworks/upload'] = 'artworks/edit';
$route['artworks/(:num)/edit'] = 'artworks/edit/$1';
$route['artworks/(:num)/delete'] = 'artworks/delete/$1';

$route['places/(:num)'] = 'places/detail/$1';
$route['places/upload'] = 'places/edit';
$route['places/(:num)/edit'] = 'places/edit/$1';
$route['places/(:num)/delete'] = 'places/delete/$1';
$route['places/(:num)/exhibitions'] = 'places/exhibitions/$1';

$route['exhibitions/(:num)/apply'] = 'exhibitions/apply/$1';

$route['users/(:any)'] = 'users/detail/$1';
$route['users/(:any)/picks'] = 'users/picks';
$route['users/(:any)/apply_status'] = 'users/apply_status';

$route['api/comments'] = 'commentApi';
$route['api/comments/delete'] = 'commentApi/delete';
$route['api/comments/insert'] = 'commentApi/insert';
$route['api/comments/update'] = 'commentApi/update';

$route['api/contents/list'] = 'main/api';
$route['api/contents/change_comment_option'] = 'contentsApi/change_comment_option';
$route['api/contents/delete_extra_images']['POST'] = 'contentsApi/delete_extra_images';

$route['api/pick']['POST'] = 'pickApi';

$route['api/login']['POST'] = 'usersApi/login';
$route['api/users/register']['POST'] = 'usersApi/register';
$route['api/users/verify'] = 'usersApi/verify';
$route['api/users/check_username'] = 'usersApi/check_username';
$route['api/users/check_email'] = 'usersApi/check_email';
$route['api/users/update_image']['POST'] = 'usersApi/update_profile_image';
$route['api/users/change_password']['POST'] = 'usersApi/change_password';
$route['api/users/reset_password']['POST'] = 'usersApi/reset_password';

$route['api/exhibition/accept']['POST'] = 'exhibitionApi/accept';
$route['api/exhibition/apply']['POST'] = 'exhibitionApi/apply';
$route['api/exhibition/cancel_apply']['POST'] = 'exhibitionApi/cancel_apply';
$route['api/exhibition/create']['POST'] = 'exhibitionApi/create';
$route['api/exhibition/delete']['POST'] = 'exhibitionApi/delete';
$route['api/exhibition/update']['POST'] = 'exhibitionApi/update';


text:
class AddNewCategories < ActiveRecord::Migration
  def up
    execute "
    INSERT INTO categories (name_pt, name_en, created_at, updated_at) VALUES ('Mobilidade e Transporte', 'Mobility & Transportation', now(), now());
    INSERT INTO categories (name_pt, name_en, created_at, updated_at) VALUES ('Meio Ambiente', 'Environment', now(), now());
    INSERT INTO categories (name_pt, name_en, created_at, updated_at) VALUES ('Negócios Sociais', 'Social Business', now(), now());
    INSERT INTO categories (name_pt, name_en, created_at, updated_at) VALUES ('Educação', 'Education', now(), now());
    INSERT INTO categories (name_pt, name_en, created_at, updated_at) VALUES ('Filmes de Ficção', 'Fiction Films', now(), now());
    INSERT INTO categories (name_pt, name_en, created_at, updated_at) VALUES ('Filmes Documentários', 'Documentary Films', now(), now());
    INSERT INTO categories (name_pt, name_en, created_at, updated_at) VALUES ('Filmes Universitários', 'Experimental Films', now(), now());
    "
  end

  def down
    execute "
    DELETE FROM categories WHERE name_pt = 'Mobilidade e Transporte';
    DELETE FROM categories WHERE name_pt = 'Meio Ambiente';
    DELETE FROM categories WHERE name_pt = 'Negócios Sociais';
    DELETE FROM categories WHERE name_pt = 'Educação';
    DELETE FROM categories WHERE name_pt = 'Filmes de Ficção';
    DELETE FROM categories WHERE name_pt = 'Filmes Documentários';
    DELETE FROM categories WHERE name_pt = 'Filmes Universitários';
    "
  end
end

redpajama_set_name: RedPajamaGithub


text:
``` diff
+namespace System.Xaml {
+    public class AmbientPropertyValue {
+        public AmbientPropertyValue(XamlMember property, object value);
+        public XamlMember RetrievedProperty { get; }
+        public object Value { get; }
+    }
+    public class AttachableMemberIdentifier : IEquatable<AttachableMemberIdentifier> {
+        public AttachableMemberIdentifier(Type declaringType, string memberName);
+        public Type DeclaringType { get; }
+        public string MemberName { get; }
+        public override bool Equals(object obj);
+        public bool Equals(AttachableMemberIdentifier other);
+        public override int GetHashCode();
+        public static bool operator ==(AttachableMemberIdentifier left, AttachableMemberIdentifier right);
+        public static bool operator !=(AttachableMemberIdentifier left, AttachableMemberIdentifier right);
+        public override string ToString();
+    }
+    public static class AttachablePropertyServices {
+        public static void CopyPropertiesTo(object instance, KeyValuePair<AttachableMemberIdentifier, object>[] array, int index);
+        public static int GetAttachedPropertyCount(object instance);
+        public static bool RemoveProperty(object instance, AttachableMemberIdentifier name);
+        public static void SetProperty(object instance, AttachableMemberIdentifier name, object value);
+        public static bool TryGetProperty(object instance, AttachableMemberIdentifier name, out object value);
+        public static bool TryGetProperty<T>(object instance, AttachableMemberIdentifier name, out T value);
+    }
+    public interface IAmbientProvider {
+        IEnumerable<AmbientPropertyValue> GetAllAmbientValues(IEnumerable<XamlType> ceilingTypes, bool searchLiveStackOnly, IEnumerable<XamlType> types, params XamlMember[] properties);
+        IEnumerable<AmbientPropertyValue> GetAllAmbientValues(IEnumerable<XamlType> ceilingTypes, params XamlMember[] properties);
+        IEnumerable<object> GetAllAmbientValues(params XamlType[] types);
+        AmbientPropertyValue GetFirstAmbientValue(IEnumerable<XamlType> ceilingTypes, params XamlMember[] properties);
+        object GetFirstAmbientValue(params XamlType[] types);
+    }
+    public interface IAttachedPropertyStore {
+        int PropertyCount { get; }
+        void CopyPropertiesTo(KeyValuePair<AttachableMemberIdentifier, object>[] array, int index);
+        bool RemoveProperty(AttachableMemberIdentifier attachableMemberIdentifier);
+        void SetProperty(AttachableMemberIdentifier attachableMemberIdentifier, object value);
+        bool TryGetProperty(AttachableMemberIdentifier attachableMemberIdentifier, out object value);
+    }
+    public interface IDestinationTypeProvider {
+        Type GetDestinationType();
+    }
+    public interface INamespacePrefixLookup {
+        string LookupPrefix(string ns);
+    }
+    public interface IRootObjectProvider {
+        object RootObject { get; }
+    }
+    public interface IXamlIndexingReader {
+        int Count { get; }
+        int CurrentIndex { get; set; }
+    }
+    public interface IXamlLineInfo {
+        bool HasLineInfo { get; }
+        int LineNumber { get; }
+        int LinePosition { get; }
+    }
+    public interface IXamlLineInfoConsumer {
+        bool ShouldProvideLineInfo { get; }
+        void SetLineInfo(int lineNumber, int linePosition);
+    }
+    public interface IXamlNameProvider {
+        string GetName(object value);
+    }
+    public interface IXamlNameResolver {
+        bool IsFixupTokenAvailable { get; }
+        event EventHandler OnNameScopeInitializationComplete;
+        IEnumerable<KeyValuePair<string, object>> GetAllNamesAndValuesInScope();
+        object GetFixupToken(IEnumerable<string> names);
+        object GetFixupToken(IEnumerable<string> names, bool canAssignDirectly);
+        object Resolve(string name);
+        object Resolve(string name, out bool isFullyInitialized);
+    }
+    public interface IXamlNamespaceResolver {
+        string GetNamespace(string prefix);
+        IEnumerable<NamespaceDeclaration> GetNamespacePrefixes();
+    }
+    public interface IXamlObjectWriterFactory {
+        XamlObjectWriterSettings GetParentSettings();
+        XamlObjectWriter GetXamlObjectWriter(XamlObjectWriterSettings settings);
+    }
+    public interface IXamlSchemaContextProvider {
+        XamlSchemaContext SchemaContext { get; }
+    }
+    public class NamespaceDeclaration {
+        public NamespaceDeclaration(string ns, string prefix);
+        public string Namespace { get; }
+        public string Prefix { get; }
+    }
+    public class XamlBackgroundReader : XamlReader, IXamlLineInfo {
+        public XamlBackgroundReader(XamlReader wrappedReader);
+        public bool HasLineInfo { get; }
+        public override bool IsEof { get; }
+        public int LineNumber { get; }
+        public int LinePosition { get; }
+        public override XamlMember Member { get; }
+        public override NamespaceDeclaration Namespace { get; }
+        public override XamlNodeType NodeType { get; }
+        public override XamlSchemaContext SchemaContext { get; }
+        public override XamlType Type { get; }
+        public override object Value { get; }
+        protected override void Dispose(bool disposing);
+        public override bool Read();
+        public void StartThread();
+        public void StartThread(string threadName);
+    }
+    public abstract class XamlDeferringLoader {
+        protected XamlDeferringLoader();
+        public abstract object Load(XamlReader xamlReader, IServiceProvider serviceProvider);
+        public abstract XamlReader Save(object value, IServiceProvider serviceProvider);
+    }
+    public class XamlDirective : XamlMember {
+        public XamlDirective(IEnumerable<string> xamlNamespaces, string name, XamlType xamlType, XamlValueConverter<TypeConverter> typeConverter, AllowedMemberLocations allowedLocation);
+        public XamlDirective(string xamlNamespace, string name);
+        public AllowedMemberLocations AllowedLocation { get; }
+        public override int GetHashCode();
+        public override IList<string> GetXamlNamespaces();
+        protected sealed override ICustomAttributeProvider LookupCustomAttributeProvider();
+        protected sealed override XamlValueConverter<XamlDeferringLoader> LookupDeferringLoader();
+        protected sealed override IList<XamlMember> LookupDependsOn();
+        protected sealed override XamlMemberInvoker LookupInvoker();
+        protected sealed override bool LookupIsAmbient();
+        protected sealed override bool LookupIsEvent();
+        protected sealed override bool LookupIsReadOnly();
+        protected sealed override bool LookupIsReadPublic();
+        protected sealed override bool LookupIsUnknown();
+        protected sealed override bool LookupIsWriteOnly();
+        protected sealed override bool LookupIsWritePublic();
+        protected sealed override XamlType LookupTargetType();
+        protected sealed override XamlType LookupType();
+        protected sealed override XamlValueConverter<TypeConverter> LookupTypeConverter();
+        protected sealed override MethodInfo LookupUnderlyingGetter();
+        protected sealed override MemberInfo LookupUnderlyingMember();
+        protected sealed override MethodInfo LookupUnderlyingSetter();
+        public override string ToString();
+    }
+    public class XamlDuplicateMemberException : XamlException {
+        public XamlDuplicateMemberException();
+        protected XamlDuplicateMemberException(SerializationInfo info, StreamingContext context);
+        public XamlDuplicateMemberException(string message);
+        public XamlDuplicateMemberException(string message, Exception innerException);
+        public XamlDuplicateMemberException(XamlMember member, XamlType type);
+        public XamlMember DuplicateMember { get; set; }
+        public XamlType ParentType { get; set; }
+        public override void GetObjectData(SerializationInfo info, StreamingContext context);
+    }
+    public class XamlException : Exception {
+        public XamlException();
+        protected XamlException(SerializationInfo info, StreamingContext context);
+        public XamlException(string message);
+        public XamlException(string message, Exception innerException);
+        public XamlException(string message, Exception innerException, int lineNumber, int linePosition);
+        public int LineNumber { get; protected set; }
+        public int LinePosition { get; protected set; }
+        public override string Message { get; }
+        public override void GetObjectData(SerializationInfo info, StreamingContext context);
+    }
+    public class XamlInternalException : XamlException {
+        public XamlInternalException();
+        protected XamlInternalException(SerializationInfo info, StreamingContext context);
+        public XamlInternalException(string message);
+        public XamlInternalException(string message, Exception innerException);
+    }
+    public static class XamlLanguage {
+        public const string Xaml2006Namespace = "http://schemas.microsoft.com/winfx/2006/xaml";
+        public const string Xml1998Namespace = "http://www.w3.org/XML/1998/namespace";
+        public static ReadOnlyCollection<XamlDirective> AllDirectives { get; }
+        public static ReadOnlyCollection<XamlType> AllTypes { get; }
+        public static XamlDirective Arguments { get; }
+        public static XamlType Array { get; }
+        public static XamlDirective AsyncRecords { get; }
+        public static XamlDirective Base { get; }
+        public static XamlType Boolean { get; }
+        public static XamlType Byte { get; }
+        public static XamlType Char { get; }
+        public static XamlDirective Class { get; }
+        public static XamlDirective ClassAttributes { get; }
+        public static XamlDirective ClassModifier { get; }
+        public static XamlDirective Code { get; }
+        public static XamlDirective ConnectionId { get; }
+        public static XamlType Decimal { get; }
+        public static XamlType Double { get; }
+        public static XamlDirective FactoryMethod { get; }
+        public static XamlDirective FieldModifier { get; }
+        public static XamlDirective Initialization { get; }
+        public static XamlType Int16 { get; }
+        public static XamlType Int32 { get; }
+        public static XamlType Int64 { get; }
+        public static XamlDirective Items { get; }
+        public static XamlDirective Key { get; }
+        public static XamlDirective Lang { get; }
+        public static XamlType Member { get; }
+        public static XamlDirective Members { get; }
+        public static XamlDirective Name { get; }
+        public static XamlType Null { get; }
+        public static XamlType Object { get; }
+        public static XamlDirective PositionalParameters { get; }
+        public static XamlType Property { get; }
+        public static XamlType Reference { get; }
+        public static XamlDirective Shared { get; }
+        public static XamlType Single { get; }
+        public static XamlDirective Space { get; }
+        public static XamlType Static { get; }
+        public static XamlType String { get; }
+        public static XamlDirective Subclass { get; }
+        public static XamlDirective SynchronousMode { get; }
+        public static XamlType TimeSpan { get; }
+        public static XamlType Type { get; }
+        public static XamlDirective TypeArguments { get; }
+        public static XamlDirective Uid { get; }
+        public static XamlDirective UnknownContent { get; }
+        public static XamlType Uri { get; }
+        public static IList<string> XamlNamespaces { get; }
+        public static XamlType XData { get; }
+        public static IList<string> XmlNamespaces { get; }
+    }
+    public class XamlMember : IEquatable<XamlMember> {
+        public XamlMember(EventInfo eventInfo, XamlSchemaContext schemaContext);
+        public XamlMember(EventInfo eventInfo, XamlSchemaContext schemaContext, XamlMemberInvoker invoker);
+        public XamlMember(PropertyInfo propertyInfo, XamlSchemaContext schemaContext);
+        public XamlMember(PropertyInfo propertyInfo, XamlSchemaContext schemaContext, XamlMemberInvoker invoker);
+        public XamlMember(string attachablePropertyName, MethodInfo getter, MethodInfo setter, XamlSchemaContext schemaContext);
+        public XamlMember(string attachablePropertyName, MethodInfo getter, MethodInfo setter, XamlSchemaContext schemaContext, XamlMemberInvoker invoker);
+        public XamlMember(string attachableEventName, MethodInfo adder, XamlSchemaContext schemaContext);
+        public XamlMember(string attachableEventName, MethodInfo adder, XamlSchemaContext schemaContext, XamlMemberInvoker invoker);
+        public XamlMember(string name, XamlType declaringType, bool isAttachable);
+        public XamlType DeclaringType { get; }
+        public XamlValueConverter<XamlDeferringLoader> DeferringLoader { get; }
+        public IList<XamlMember> DependsOn { get; }
+        public XamlMemberInvoker Invoker { get; }
+        public bool IsAmbient { get; }
+        public bool IsAttachable { get; }
+        public bool IsDirective { get; }
+        public bool IsEvent { get; }
+        public bool IsNameValid { get; }
+        public bool IsReadOnly { get; }
+        public bool IsReadPublic { get; }
+        public bool IsUnknown { get; }
+        public bool IsWriteOnly { get; }
+        public bool IsWritePublic { get; }
+        public string Name { get; }
+        public string PreferredXamlNamespace { get; }
+        public DesignerSerializationVisibility SerializationVisibility { get; }
+        public XamlType TargetType { get; }
+        public XamlType Type { get; }
+        public XamlValueConverter<TypeConverter> TypeConverter { get; }
+        public MemberInfo UnderlyingMember { get; }
+        public XamlValueConverter<ValueSerializer> ValueSerializer { get; }
+        public override bool Equals(object obj);
+        public bool Equals(XamlMember other);
+        public override int GetHashCode();
+        public virtual IList<string> GetXamlNamespaces();
+        protected virtual ICustomAttributeProvider LookupCustomAttributeProvider();
+        protected virtual XamlValueConverter<XamlDeferringLoader> LookupDeferringLoader();
+        protected virtual IList<XamlMember> LookupDependsOn();
+        protected virtual XamlMemberInvoker LookupInvoker();
+        protected virtual bool LookupIsAmbient();
+        protected virtual bool LookupIsEvent();
+        protected virtual bool LookupIsReadOnly();
+        protected virtual bool LookupIsReadPublic();
+        protected virtual bool LookupIsUnknown();
+        protected virtual bool LookupIsWriteOnly();
+        protected virtual bool LookupIsWritePublic();
+        protected virtual XamlType LookupTargetType();
+        protected virtual XamlType LookupType();
+        protected virtual XamlValueConverter<TypeConverter> LookupTypeConverter();
+        protected virtual MethodInfo LookupUnderlyingGetter();
+        protected virtual MemberInfo LookupUnderlyingMember();
+        protected virtual MethodInfo LookupUnderlyingSetter();
+        protected virtual XamlValueConverter<ValueSerializer> LookupValueSerializer();
+        public static bool operator ==(XamlMember xamlMember1, XamlMember xamlMember2);
+        public static bool operator !=(XamlMember xamlMember1, XamlMember xamlMember2);
+        public override string ToString();
+    }
+    public class XamlNodeList {
+        public XamlNodeList(XamlSchemaContext schemaContext);
+        public XamlNodeList(XamlSchemaContext schemaContext, int size);
+        public int Count { get; }
+        public XamlWriter Writer { get; }
+        public void Clear();
+        public XamlReader GetReader();
+    }
+    public class XamlNodeQueue {
+        public XamlNodeQueue(XamlSchemaContext schemaContext);
+        public int Count { get; }
+        public bool IsEmpty { get; }
+        public XamlReader Reader { get; }
+        public XamlWriter Writer { get; }
+    }
+    public enum XamlNodeType : byte {
+        EndMember = (byte)5,
+        EndObject = (byte)3,
+        GetObject = (byte)2,
+        NamespaceDeclaration = (byte)7,
+        None = (byte)0,
+        StartMember = (byte)4,
+        StartObject = (byte)1,
+        Value = (byte)6,
+    }
+    public class XamlObjectEventArgs : EventArgs {
+        public XamlObjectEventArgs(object instance);
+        public int ElementLineNumber { get; private set; }
+        public int ElementLinePosition { get; private set; }
+        public object Instance { get; private set; }
+        public Uri SourceBamlUri { get; private set; }
+    }
+    public class XamlObjectReader : XamlReader {
+        public XamlObjectReader(object instance);
+        public XamlObjectReader(object instance, XamlObjectReaderSettings settings);
+        public XamlObjectReader(object instance, XamlSchemaContext schemaContext);
+        public XamlObjectReader(object instance, XamlSchemaContext schemaContext, XamlObjectReaderSettings settings);
+        public virtual object Instance { get; }
+        public override bool IsEof { get; }
+        public override XamlMember Member { get; }
+        public override NamespaceDeclaration Namespace { get; }
+        public override XamlNodeType NodeType { get; }
+        public override XamlSchemaContext SchemaContext { get; }
+        public override XamlType Type { get; }
+        public override object Value { get; }
+        public override bool Read();
+    }
+    public class XamlObjectReaderException : XamlException {
+        public XamlObjectReaderException();
+        protected XamlObjectReaderException(SerializationInfo info, StreamingContext context);
+        public XamlObjectReaderException(string message);
+        public XamlObjectReaderException(string message, Exception innerException);
+    }
+    public class XamlObjectReaderSettings : XamlReaderSettings {
+        public XamlObjectReaderSettings();
+        public bool RequireExplicitContentVisibility { get; set; }
+    }
+    public class XamlObjectWriter : XamlWriter, IXamlLineInfoConsumer {
+        public XamlObjectWriter(XamlSchemaContext schemaContext);
+        public XamlObjectWriter(XamlSchemaContext schemaContext, XamlObjectWriterSettings settings);
+        public virtual object Result { get; }
+        public INameScope RootNameScope { get; }
+        public override XamlSchemaContext SchemaContext { get; }
+        public bool ShouldProvideLineInfo { get; }
+        public void Clear();
+        protected override void Dispose(bool disposing);
+        protected virtual void OnAfterBeginInit(object value);
+        protected virtual void OnAfterEndInit(object value);
+        protected virtual void OnAfterProperties(object value);
+        protected virtual void OnBeforeProperties(object value);
+        protected virtual bool OnSetValue(object eventSender, XamlMember member, object value);
+        public void SetLineInfo(int lineNumber, int linePosition);
+        public override void WriteEndMember();
+        public override void WriteEndObject();
+        public override void WriteGetObject();
+        public override void WriteNamespace(NamespaceDeclaration namespaceDeclaration);
+        public override void WriteStartMember(XamlMember property);
+        public override void WriteStartObject(XamlType xamlType);
+        public override void WriteValue(object value);
+    }
+    public class XamlObjectWriterException : XamlException {
+        public XamlObjectWriterException();
+        protected XamlObjectWriterException(SerializationInfo info, StreamingContext context);
+        public XamlObjectWriterException(string message);
+        public XamlObjectWriterException(string message, Exception innerException);
+    }
+    public class XamlObjectWriterSettings : XamlWriterSettings {
+        public XamlObjectWriterSettings();
+        public XamlObjectWriterSettings(XamlObjectWriterSettings settings);
+        public XamlAccessLevel AccessLevel { get; set; }
+        public EventHandler<XamlObjectEventArgs> AfterBeginInitHandler { get; set; }
+        public EventHandler<XamlObjectEventArgs> AfterEndInitHandler { get; set; }
+        public EventHandler<XamlObjectEventArgs> AfterPropertiesHandler { get; set; }
+        public EventHandler<XamlObjectEventArgs> BeforePropertiesHandler { get; set; }
+        public INameScope ExternalNameScope { get; set; }
+        public bool IgnoreCanConvert { get; set; }
+        public bool PreferUnconvertedDictionaryKeys { get; set; }
+        public bool RegisterNamesOnExternalNamescope { get; set; }
+        public object RootObjectInstance { get; set; }
+        public bool SkipDuplicatePropertyCheck { get; set; }
+        public bool SkipProvideValueOnRoot { get; set; }
+        public Uri SourceBamlUri { get; set; }
+        public EventHandler<XamlSetValueEventArgs> XamlSetValueHandler { get; set; }
+    }
+    public class XamlParseException : XamlException {
+        public XamlParseException();
+        protected XamlParseException(SerializationInfo info, StreamingContext context);
+        public XamlParseException(string message);
+        public XamlParseException(string message, Exception innerException);
+    }
+    public abstract class XamlReader : IDisposable {
+        protected XamlReader();
+        protected bool IsDisposed { get; private set; }
+        public abstract bool IsEof { get; }
+        public abstract XamlMember Member { get; }
+        public abstract NamespaceDeclaration Namespace { get; }
+        public abstract XamlNodeType NodeType { get; }
+        public abstract XamlSchemaContext SchemaContext { get; }
+        public abstract XamlType Type { get; }
+        public abstract object Value { get; }
+        public void Close();
+        protected virtual void Dispose(bool disposing);
+        public abstract bool Read();
+        public virtual XamlReader ReadSubtree();
+        public virtual void Skip();
+        void System.IDisposable.Dispose();
+    }
+    public class XamlReaderSettings {
+        public XamlReaderSettings();
+        public XamlReaderSettings(XamlReaderSettings settings);
+        public bool AllowProtectedMembersOnRoot { get; set; }
+        public Uri BaseUri { get; set; }
+        public bool IgnoreUidsOnPropertyElements { get; set; }
+        public Assembly LocalAssembly { get; set; }
+        public bool ProvideLineInfo { get; set; }
+        public bool ValuesMustBeString { get; set; }
+    }
+    public class XamlSchemaContext {
+        public XamlSchemaContext();
+        public XamlSchemaContext(IEnumerable<Assembly> referenceAssemblies);
+        public XamlSchemaContext(IEnumerable<Assembly> referenceAssemblies, XamlSchemaContextSettings settings);
+        public XamlSchemaContext(XamlSchemaContextSettings settings);
+        public bool FullyQualifyAssemblyNamesInClrNamespaces { get; }
+        public IList<Assembly> ReferenceAssemblies { get; }
+        public bool SupportMarkupExtensionsWithDuplicateArity { get; }
+        ~XamlSchemaContext();
+        public virtual IEnumerable<string> GetAllXamlNamespaces();
+        public virtual ICollection<XamlType> GetAllXamlTypes(string xamlNamespace);
+        public virtual string GetPreferredPrefix(string xmlns);
+        protected internal XamlValueConverter<TConverterBase> GetValueConverter<TConverterBase>(Type converterType, XamlType targetType) where TConverterBase : class;
+        public virtual XamlDirective GetXamlDirective(string xamlNamespace, string name);
+        protected internal virtual XamlType GetXamlType(string xamlNamespace, string name, params XamlType[] typeArguments);
+        public virtual XamlType GetXamlType(Type type);
+        public XamlType GetXamlType(XamlTypeName xamlTypeName);
+        protected internal virtual Assembly OnAssemblyResolve(string assemblyName);
+        public virtual bool TryGetCompatibleXamlNamespace(string xamlNamespace, out string compatibleNamespace);
+    }
+    public class XamlSchemaContextSettings {
+        public XamlSchemaContextSettings();
+        public XamlSchemaContextSettings(XamlSchemaContextSettings settings);
+        public bool FullyQualifyAssemblyNamesInClrNamespaces { get; set; }
+        public bool SupportMarkupExtensionsWithDuplicateArity { get; set; }
+    }
+    public class XamlSchemaException : XamlException {
+        public XamlSchemaException();
+        protected XamlSchemaException(SerializationInfo info, StreamingContext context);
+        public XamlSchemaException(string message);
+        public XamlSchemaException(string message, Exception innerException);
+    }
+    public static class XamlServices {
+        public static object Load(Stream stream);
+        public static object Load(TextReader textReader);
+        public static object Load(string fileName);
+        public static object Load(XamlReader xamlReader);
+        public static object Load(XmlReader xmlReader);
+        public static object Parse(string xaml);
+        public static void Save(Stream stream, object instance);
+        public static void Save(TextWriter writer, object instance);
+        public static string Save(object instance);
+        public static void Save(string fileName, object instance);
+        public static void Save(XamlWriter writer, object instance);
+        public static void Save(XmlWriter writer, object instance);
+        public static void Transform(XamlReader xamlReader, XamlWriter xamlWriter);
+        public static void Transform(XamlReader xamlReader, XamlWriter xamlWriter, bool closeWriter);
+    }
+    public class XamlType : IEquatable<XamlType> {
+        protected XamlType(string typeName, IList<XamlType> typeArguments, XamlSchemaContext schemaContext);
+        public XamlType(string unknownTypeNamespace, string unknownTypeName, IList<XamlType> typeArguments, XamlSchemaContext schemaContext);
+        public XamlType(Type underlyingType, XamlSchemaContext schemaContext);
+        public XamlType(Type underlyingType, XamlSchemaContext schemaContext, XamlTypeInvoker invoker);
+        public IList<XamlType> AllowedContentTypes { get; }
+        public XamlType BaseType { get; }
+        public bool ConstructionRequiresArguments { get; }
+        public XamlMember ContentProperty { get; }
+        public IList<XamlType> ContentWrappers { get; }
+        public XamlValueConverter<XamlDeferringLoader> DeferringLoader { get; }
+        public XamlTypeInvoker Invoker { get; }
+        public bool IsAmbient { get; }
+        public bool IsArray { get; }
+        public bool IsCollection { get; }
+        public bool IsConstructible { get; }
+        public bool IsDictionary { get; }
+        public bool IsGeneric { get; }
+        public bool IsMarkupExtension { get; }
+        public bool IsNameScope { get; }
+        public bool IsNameValid { get; }
+        public bool IsNullable { get; }
+        public bool IsPublic { get; }
+        public bool IsUnknown { get; }
+        public bool IsUsableDuringInitialization { get; }
+        public bool IsWhitespaceSignificantCollection { get; }
+        public bool IsXData { get; }
+        public XamlType ItemType { get; }
+        public XamlType KeyType { get; }
+        public XamlType MarkupExtensionReturnType { get; }
+        public string Name { get; }
+        public string PreferredXamlNamespace { get; }
+        public XamlSchemaContext SchemaContext { get; }
+        public bool TrimSurroundingWhitespace { get; }
+        public IList<XamlType> TypeArguments { get; }
+        public XamlValueConverter<TypeConverter> TypeConverter { get; }
+        public Type UnderlyingType { get; }
+        public XamlValueConverter<ValueSerializer> ValueSerializer { get; }
+        public virtual bool CanAssignTo(XamlType xamlType);
+        public override bool Equals(object obj);
+        public bool Equals(XamlType other);
+        public XamlMember GetAliasedProperty(XamlDirective directive);
+        public ICollection<XamlMember> GetAllAttachableMembers();
+        public ICollection<XamlMember> GetAllMembers();
+        public XamlMember GetAttachableMember(string name);
+        public override int GetHashCode();
+        public XamlMember GetMember(string name);
+        public IList<XamlType> GetPositionalParameters(int parameterCount);
+        public virtual IList<string> GetXamlNamespaces();
+        protected virtual XamlMember LookupAliasedProperty(XamlDirective directive);
+        protected virtual IEnumerable<XamlMember> LookupAllAttachableMembers();
+        protected virtual IEnumerable<XamlMember> LookupAllMembers();
+        protected virtual IList<XamlType> LookupAllowedContentTypes();
+        protected virtual XamlMember LookupAttachableMember(string name);
+        protected virtual XamlType LookupBaseType();
+        protected virtual XamlCollectionKind LookupCollectionKind();
+        protected virtual bool LookupConstructionRequiresArguments();
+        protected virtual XamlMember LookupContentProperty();
+        protected virtual IList<XamlType> LookupContentWrappers();
+        protected virtual ICustomAttributeProvider LookupCustomAttributeProvider();
+        protected virtual XamlValueConverter<XamlDeferringLoader> LookupDeferringLoader();
+        protected virtual XamlTypeInvoker LookupInvoker();
+        protected virtual bool LookupIsAmbient();
+        protected virtual bool LookupIsConstructible();
+        protected virtual bool LookupIsMarkupExtension();
+        protected virtual bool LookupIsNameScope();
+        protected virtual bool LookupIsNullable();
+        protected virtual bool LookupIsPublic();
+        protected virtual bool LookupIsUnknown();
+        protected virtual bool LookupIsWhitespaceSignificantCollection();
+        protected virtual bool LookupIsXData();
+        protected virtual XamlType LookupItemType();
+        protected virtual XamlType LookupKeyType();
+        protected virtual XamlType LookupMarkupExtensionReturnType();
+        protected virtual XamlMember LookupMember(string name, bool skipReadOnlyCheck);
+        protected virtual IList<XamlType> LookupPositionalParameters(int parameterCount);
+        protected virtual EventHandler<XamlSetMarkupExtensionEventArgs> LookupSetMarkupExtensionHandler();
+        protected virtual EventHandler<XamlSetTypeConverterEventArgs> LookupSetTypeConverterHandler();
+        protected virtual bool LookupTrimSurroundingWhitespace();
+        protected virtual XamlValueConverter<TypeConverter> LookupTypeConverter();
+        protected virtual Type LookupUnderlyingType();
+        protected virtual bool LookupUsableDuringInitialization();
+        protected virtual XamlValueConverter<ValueSerializer> LookupValueSerializer();
+        public static bool operator ==(XamlType xamlType1, XamlType xamlType2);
+        public static bool operator !=(XamlType xamlType1, XamlType xamlType2);
+        public override string ToString();
+    }
+    public abstract class XamlWriter : IDisposable {
+        protected XamlWriter();
+        protected bool IsDisposed { get; private set; }
+        public abstract XamlSchemaContext SchemaContext { get; }
+        public void Close();
+        protected virtual void Dispose(bool disposing);
+        void System.IDisposable.Dispose();
+        public abstract void WriteEndMember();
+        public abstract void WriteEndObject();
+        public abstract void WriteGetObject();
+        public abstract void WriteNamespace(NamespaceDeclaration namespaceDeclaration);
+        public void WriteNode(XamlReader reader);
+        public abstract void WriteStartMember(XamlMember xamlMember);
+        public abstract void WriteStartObject(XamlType type);
+        public abstract void WriteValue(object value);
+    }
+    public class XamlWriterSettings {
+        public XamlWriterSettings();
+        public XamlWriterSettings(XamlWriterSettings settings);
+    }
+    public class XamlXmlReader : XamlReader, IXamlLineInfo {
+        public XamlXmlReader(Stream stream);
+        public XamlXmlReader(Stream stream, XamlSchemaContext schemaContext);
+        public XamlXmlReader(Stream stream, XamlSchemaContext schemaContext, XamlXmlReaderSettings settings);
+        public XamlXmlReader(Stream stream, XamlXmlReaderSettings settings);
+        public XamlXmlReader(TextReader textReader);
+        public XamlXmlReader(TextReader textReader, XamlSchemaContext schemaContext);
+        public XamlXmlReader(TextReader textReader, XamlSchemaContext schemaContext, XamlXmlReaderSettings settings);
+        public XamlXmlReader(TextReader textReader, XamlXmlReaderSettings settings);
+        public XamlXmlReader(string fileName);
+        public XamlXmlReader(string fileName, XamlSchemaContext schemaContext);
+        public XamlXmlReader(string fileName, XamlSchemaContext schemaContext, XamlXmlReaderSettings settings);
+        public XamlXmlReader(string fileName, XamlXmlReaderSettings settings);
+        public XamlXmlReader(XmlReader xmlReader);
+        public XamlXmlReader(XmlReader xmlReader, XamlSchemaContext schemaContext);
+        public XamlXmlReader(XmlReader xmlReader, XamlSchemaContext schemaContext, XamlXmlReaderSettings settings);
+        public XamlXmlReader(XmlReader xmlReader, XamlXmlReaderSettings settings);
+        public bool HasLineInfo { get; }
+        public override bool IsEof { get; }
+        public int LineNumber { get; }
+        public int LinePosition { get; }
+        public override XamlMember Member { get; }
+        public override NamespaceDeclaration Namespace { get; }
+        public override XamlNodeType NodeType { get; }
+        public override XamlSchemaContext SchemaContext { get; }
+        public override XamlType Type { get; }
+        public override object Value { get; }
+        public override bool Read();
+    }
+    public class XamlXmlReaderSettings : XamlReaderSettings {
+        public XamlXmlReaderSettings();
+        public XamlXmlReaderSettings(XamlXmlReaderSettings settings);
+        public bool CloseInput { get; set; }
+        public bool SkipXmlCompatibilityProcessing { get; set; }
+        public string XmlLang { get; set; }
+        public bool XmlSpacePreserve { get; set; }
+    }
+    public class XamlXmlWriter : XamlWriter {
+        public XamlXmlWriter(Stream stream, XamlSchemaContext schemaContext);
+        public XamlXmlWriter(Stream stream, XamlSchemaContext schemaContext, XamlXmlWriterSettings settings);
+        public XamlXmlWriter(TextWriter textWriter, XamlSchemaContext schemaContext);
+        public XamlXmlWriter(TextWriter textWriter, XamlSchemaContext schemaContext, XamlXmlWriterSettings settings);
+        public XamlXmlWriter(XmlWriter xmlWriter, XamlSchemaContext schemaContext);
+        public XamlXmlWriter(XmlWriter xmlWriter, XamlSchemaContext schemaContext, XamlXmlWriterSettings settings);
+        public override XamlSchemaContext SchemaContext { get; }
+        public XamlXmlWriterSettings Settings { get; }
+        protected override void Dispose(bool disposing);
+        public void Flush();
+        public override void WriteEndMember();
+        public override void WriteEndObject();
+        public override void WriteGetObject();
+        public override void WriteNamespace(NamespaceDeclaration namespaceDeclaration);
+        public override void WriteStartMember(XamlMember property);
+        public override void WriteStartObject(XamlType type);
+        public override void WriteValue(object value);
+    }
+    public class XamlXmlWriterException : XamlException {
+        public XamlXmlWriterException();
+        protected XamlXmlWriterException(SerializationInfo info, StreamingContext context);
+        public XamlXmlWriterException(string message);
+        public XamlXmlWriterException(string message, Exception innerException);
+    }
+    public class XamlXmlWriterSettings : XamlWriterSettings {
+        public XamlXmlWriterSettings();
+        public bool AssumeValidInput { get; set; }
+        public bool CloseOutput { get; set; }
+        public XamlXmlWriterSettings Copy();
+    }
+}
```


text:
var R          = require('ramda');
var Rx         = require('rx');
var defaults   = require('lodash/object/defaults');
var Observable = Rx.Observable;
var mvRx       = Observable.fromNodeCallback(require('mv'));
var DEFAULT_OPTIONS = { clobber: false, mkdirp: false };

/**
 * **File:** [rx/fs/mv.js](rx/fs/mv.js)
 *
 * @member module:Protean.Rx.mv
 * @param {String} from
 * @param {String} to
 * @param {Object} opts
 * @param {Boolean} [opts.mkdirp=false]
 * @param {Boolean} [opts.clobber=false]
 * @returns {Observable<String>}
 */
module.exports = function mv (from, to, opts) {
    opts = defaults(opts || {}, DEFAULT_OPTIONS);
    return mvRx(from, to, opts).
        map(R.always(to));
};


text:
TestCaseFactory* TestCaseFactory::head_ = NULL;

// Cookie value we use to signal "we're still working." See the comment above
// the class declaration for how this works.
static const char kProgressSignal[] = "...";

// Returns a new heap-allocated test case for the given test, or NULL on
// failure.
TestingInstance::TestingInstance(PP_Instance instance)
#if (defined __native_client__)
    : pp::Instance(instance),
#else
    : pp::InstancePrivate(instance),
#endif
      current_case_(NULL),
      executed_tests_(false),
      nacl_mode_(false),
      ssl_server_port_(-1),
      websocket_port_(-1) {
  callback_factory_.Initialize(this);
}

TestingInstance::~TestingInstance() {
  if (current_case_)
    delete current_case_;
}

bool TestingInstance::Init(uint32_t argc,
                           const char* argn[],
                           const char* argv[]) {
  for (uint32_t i = 0; i < argc; i++) {
    if (std::strcmp(argn[i], "mode") == 0) {
      if (std::strcmp(argv[i], "nacl") == 0)
        nacl_mode_ = true;
    } else if (std::strcmp(argn[i], "protocol") == 0) {
      protocol_ = argv[i];
    } else if (std::strcmp(argn[i], "websocket_port") == 0) {
      websocket_port_ = atoi(argv[i]);
    } else if (std::strcmp(argn[i], "ssl_server_port") == 0) {
      ssl_server_port_ = atoi(argv[i]);
    }
  }
  // Create the proper test case from the argument.
  for (uint32_t i = 0; i < argc; i++) {
    if (std::strcmp(argn[i], "testcase") == 0) {
      if (argv[i][0] == '\0')
        break;
      current_case_ = CaseForTestName(argv[i]);
      test_filter_ = FilterForTestName(argv[i]);
      if (!current_case_)
        errors_.append(std::string("Unknown test case ") + argv[i]);
      else if (!current_case_->Init())
        errors_.append(" Test case could not initialize.");
      return true;
    }
  }

  // In DidChangeView, we'll dump out a list of all available tests.
  return true;
}

#if !(defined __native_client__)
pp::Var TestingInstance::GetInstanceObject() {
  if (current_case_)
    return current_case_->GetTestObject();

  return pp::VarPrivate();
}
#endif

void TestingInstance::HandleMessage(const pp::Var& message_data) {
  if (current_case_)
    current_case_->HandleMessage(message_data);
}

void TestingInstance::DidChangeView(const pp::View& view) {
  if (!executed_tests_) {
    executed_tests_ = true;
    pp::Module::Get()->core()->CallOnMainThread(
        0,
        callback_factory_.NewCallback(&TestingInstance::ExecuteTests));
  }
  if (current_case_)
    current_case_->DidChangeView(view);
}

bool TestingInstance::HandleInputEvent(const pp::InputEvent& event) {
  if (current_case_)
    return current_case_->HandleInputEvent(event);
  return false;
}

void TestingInstance::EvalScript(const std::string& script) {
  SendTestCommand("EvalScript", script);
}

void TestingInstance::SetCookie(const std::string& name,
                                const std::string& value) {
  SendTestCommand("SetCookie", name + "=" + value);
}

void TestingInstance::LogTest(const std::string& test_name,
                              const std::string& error_message) {
  // Tell the browser we're still working.
  ReportProgress(kProgressSignal);

  std::string html;
  html.append("
");
  html.append(test_name);
  html.append(" ");
  if (error_message.empty()) {
    html.append("PASS");
  } else {
    html.append("FAIL: ");
    html.append(error_message);
    html.append("");

    if (!errors_.empty())
      errors_.append(", ");  // Separator for different error messages.
    errors_.append(test_name + " FAIL: " + error_message);
  }
  html.append("
");
  LogHTML(html);
}

void TestingInstance::AppendError(const std::string& message) {
  if (!errors_.empty())
    errors_.append(", ");
  errors_.append(message);
}

void TestingInstance::ExecuteTests(int32_t unused) {
  ReportProgress(kProgressSignal);

  // Clear the console.
  SendTestCommand("ClearConsole");

  if (!errors_.empty()) {
    // Catch initialization errors and output the current error string to
    // the console.
    LogError("Plugin initialization failed: " + errors_);
  } else if (!current_case_) {
    LogAvailableTests();
    errors_.append("FAIL: Only listed tests");
  } else {
    current_case_->RunTests(test_filter_);
    // Automated PyAuto tests rely on finding the exact strings below.
    LogHTML(errors_.empty() ?
            "[SHUTDOWN] All tests passed." :
            "[SHUTDOWN] Some tests failed.");
  }

  // Declare we're done by setting a cookie to either "PASS" or the errors.
  ReportProgress(errors_.empty() ? "PASS" : errors_);
  SendTestCommand("DidExecuteTests");
  // Note, DidExecuteTests unloads the plugin. We can't really do anthing after
  // this point.
}

TestCase* TestingInstance::CaseForTestName(const std::string& name) {
  std::string case_name = name.substr(0, name.find_first_of('_'));
  TestCaseFactory* iter = TestCaseFactory::head_;
  while (iter != NULL) {
    if (case_name == iter->name_)
      return iter->method_(this);
    iter = iter->next_;
  }
  return NULL;
}

std::string TestingInstance::FilterForTestName(const std::string& name) {
  size_t delim = name.find_first_of('_');
  if (delim != std::string::npos)
    return name.substr(delim+1);
  return "";
}

void TestingInstance::SendTestCommand(const std::string& command) {
  std::string msg("TESTING_MESSAGE:");
  msg += command;
  PostMessage(pp::Var(msg));
}

void TestingInstance::SendTestCommand(const std::string& command,
                                      const std::string& params) {
  SendTestCommand(command + ":" + params);
}

void TestingInstance::LogAvailableTests() {
  // Print out a listing of all tests.
  std::vector<std::string> test_cases;
  TestCaseFactory* iter = TestCaseFactory::head_;
  while (iter != NULL) {
    test_cases.push_back(iter->name_);
    iter = iter->next_;
  }
  std::sort(test_cases.begin(), test_cases.end());

  std::string html;
  html.append("Available test cases:
");
  for (size_t i = 0; i < test_cases.size(); ++i) {
    html.append("
");
    html.append(test_cases[i]);
    html.append("
");
  }
  html.append("
");
  html.append("<button onclick='RunAll()'>Run All Tests</button>");

  LogHTML(html);
}

void TestingInstance::LogError(const std::string& text) {
  std::string html;
  html.append("FAIL: ");
  html.append(text);
  html.append("");
  LogHTML(html);
}

void TestingInstance::LogHTML(const std::string& html) {
  SendTestCommand("LogHTML", html);
}

void TestingInstance::ReportProgress(const std::string& progress_value) {
  // Use streams since nacl doesn't compile base yet (for StringPrintf).
  std::ostringstream script;
  script << "window.domAutomationController.setAutomationId(0);" <<
            "window.domAutomationController.send(\"" << progress_value << "\")";
  EvalScript(script.str());
}

void TestingInstance::AddPostCondition(const std::string& script) {
  SendTestCommand("AddPostCondition", script);
}

class Module : public pp::Module {
 public:
  Module() : pp::Module() {}
  virtual ~Module() {}

  virtual pp::Instance* CreateInstance(PP_Instance instance) {
    return new TestingInstance(instance);
  }
};

namespace pp {

Module* CreateModule() {
  return new ::Module();
}

}  // namespace pp


text:
<vector xmlns:android="http://schemas.android.com/apk/res/android"
    android:width="24dp"
    android:height="24dp"
    android:viewportWidth="24"
    android:viewportHeight="24"
    android:tint="?attr/colorControlNormal">
  <path
      android:fillColor="@android:color/white"
      android:pathData="M7.5,17V7H8.5V11.5H15.5V7H16.5V17H15.5V12.5H8.5V17Z"/>
</vector>


text:
api = local_connect()
# Get the connected vehicle (currently only one vehicle can be returned).
v = api.get_vehicles()[0]

print " Battery: %s" % v.battery


text:
DVBCQGY2 ;;ALB-CIOFO/SBW - Gynecological Conditions Questionaire ; 7/JUL/2011
 ;;2.7;AMIE;**174**;Apr 10, 1995;Build 2
 ;
TXT ;
 ;; Your patient is applying to the U. S. Department of Veterans Affairs (VA) for
 ;; disability benefits.  VA will consider the information you provide on this
 ;; questionnaire as part of their evaluation in processing the Veteran's claim.
 ;;
 ;; 1. Diagnosis
 ;; Does the Veteran now have or has she ever had a gynecological condition?
 ;; ___ Yes   ___ No
 ;;
 ;; If yes, provide only diagnoses that pertain to gynecological condition(s):
 ;;    Diagnosis #1: ____________________________
 ;;    ICD code: ____________________________
 ;;    Date of diagnosis: ______________________
 ;;
 ;;    Diagnosis #2: ____________________________
 ;;    ICD code: ____________________________
 ;;    Date of diagnosis: ______________________
 ;;
 ;;    Diagnosis #3: ____________________________
 ;;    ICD code: ____________________________
 ;;    Date of diagnosis: ______________________
 ;;
 ;; If there are additional gynecological diagnoses, list using above format:
 ;; _____________________________________________________________________________
 ;;
 ;; 2. Medical history
 ;; Describe the history (including cause, onset and course) of each of the
 ;; Veteran's gynecological conditions: _________________________________________
 ;; _____________________________________________________________________________
 ;;
 ;; 3. Symptoms
 ;; Does the Veteran currently have symptoms related to a gynecological
 ;; condition, including any diseases, injuries or adhesions of the female
 ;; reproductive organs?
 ;; ___ Yes   ___ No
 ;; If yes, indicate current symptoms, including frequency and severity of pain,
 ;; if any: (check all that apply)
 ;;     ___ Intermittent pain
 ;;     ___ Constant pain
 ;;     ___ Mild pain
 ;;     ___ Moderate pain
 ;;     ___ Severe pain
 ;;     ___ Pelvic pressure
 ;;     ___ Irregular menstruation
 ;;     ___ Frequent or continuous menstrual disturbances
 ;;     ___ Other signs and/or symptoms describe and indicate condition(s)
 ;;         causing them: _______________________________________________________
 ;;^TOF^
 ;; 4. Treatment
 ;; a. Has the Veteran had treatment for symptoms/findings for any diseases,
 ;; injuries and/or adhesions of the reproductive organs?
 ;; ___ Yes   ___ No
 ;;     If yes, specify condition(s), organ(s) affected, and treatment: _________
 ;;     _________________________________________________________________________
 ;;     Date of treatment: ____________________
 ;;
 ;; b. Does the Veteran currently require treatment or medications [for
 ;; symptoms?] related to reproductive tract conditions?
 ;; ___ Yes   ___ No
 ;; If yes, list current treatment/medications and the reproductive organ
 ;; condition(s) being treated: _________________________________________________
 ;;
 ;; c. If yes, indicate effectiveness of treatment in controlling symptoms:
 ;;     ___ Symptoms do not require continuous treatment for the following organ/
 ;;         condition: __________________________________________________________
 ;;     ___ Symptoms require continuous treatment for the following organ/
 ;;         condition: __________________________________________________________
 ;;     ___ Symptoms are not controlled by continuous treatment: for the following
 ;;         organ/condition: ____________________________________________________
 ;;
 ;; 5. Conditions of the vulva
 ;; Has the Veteran been diagnosed with any diseases, injuries or other
 ;; conditions of the vulva (to include vulvovaginitis)?
 ;; ___ Yes   ___ No
 ;; If yes, describe: ___________________________________________________________
 ;;
 ;; 6. Conditions of the vagina
 ;; Has the Veteran been diagnosed with any diseases, injuries or other
 ;; conditions of the vagina?
 ;; ___ Yes   ___ No
 ;; If yes, describe: ___________________________________________________________
 ;;
 ;; 7. Conditions of the cervix
 ;; Has the Veteran been diagnosed with any diseases, injuries, adhesions or
 ;; other conditions of the cervix?
 ;; ___ Yes   ___ No
 ;; If yes, describe: ___________________________________________________________
 ;;
 ;; 8. Conditions of the uterus
 ;; a. Has the Veteran been diagnosed with any diseases, injuries, adhesions or
 ;; other conditions of the uterus?
 ;; ___ Yes   ___ No
 ;;
 ;; b. Has the Veteran had a hysterectomy?
 ;; ___ Yes   ___ No
 ;; If yes, provide date(s) of surgery, facility(ies) where performed, and cause:
 ;; _____________________________________________________________________________
 ;;^TOF^
 ;; c. Does the Veteran have uterine prolapse?
 ;; ___ Yes   ___ No
 ;; If yes, indicate severity:
 ;;     ___ Incomplete
 ;;     ___ Complete (through vagina and introitus)
 ;;         If yes, does the condition currently cause symptoms?
 ;;         ___ Yes   ___ No
 ;;         If yes, describe: ___________________________________________________
 ;;
 ;; d. Does the Veteran have uterine fibroids, enlargement of the uterus and/or
 ;; displacement of the uterus?
 ;; ___ Yes   ___ No
 ;; If yes, are there signs and symptoms?
 ;; ___ Yes   ___ No
 ;; If yes, check all that apply:
 ;;     ___ Adhesions
 ;;     ___ Marked displacement: If checked, indicate cause _____________________
 ;;     ___ Marked enlargement: If checked, indicate cause: _____________________
 ;;     ___ Uterine fibroids
 ;;     ___ Irregular menstruation: If checked, indicate cause: _________________
 ;;     ___ Frequent or continuous menstrual disturbances: If checked, indicate
 ;;         cause: ______________________________________________________________
 ;;     ___ Other, describe and indicate cause: _________________________________
 ;;
 ;; e. Has the Veteran been diagnosed with any other diseases, injuries,
 ;; adhesions or other conditions of the uterus?
 ;; ___ Yes   ___ No
 ;; If yes, describe: ___________________________________________________________
 ;;
 ;; 9. Conditions of the Fallopian tubes
 ;; Has the Veteran been diagnosed with any diseases, injuries, adhesions or other
 ;; conditions of the Fallopian tubes (to include pelvic inflammatory disease)?
 ;; ___ Yes   ___ No
 ;; If yes, describe: ___________________________________________________________
 ;;
 ;; 10. Conditions of the ovaries
 ;; a. Has the Veteran undergone menopause?
 ;; ___ Yes   ___ No
 ;;     If yes, indicate:
 ;;     ___ Natural menopause
 ;;     ___ Premature menopause
 ;;     ___ Surgical menopause
 ;;     ___ Chemical-induced menopause
 ;;     ___ Radiation-induced menopause
 ;;^TOF^
 ;; b. Has the Veteran undergone partial or complete oophorectomy?
 ;; ___ Yes   ___ No
 ;; If yes, check all that apply:
 ;;      ___ Partial removal of an ovary
 ;;              ___ Right   ___ Left    ___ Both
 ;;      ___ Complete removal of an  ovary
 ;;              ___ Right   ___ Left    ___ Both
 ;; If yes, provide date(s) of surgery, facility(ies) where performed, and reason
 ;; for surgery: ________________________________________________________________
 ;;
 ;; c. Does the Veteran have evidence of complete atrophy of 1 or both ovaries?
 ;; ___ Yes   ___ No   ___ Unknown
 ;; If yes, etiology: ______________
 ;; If yes, indicate severity:
 ;;     ___ Partial atrophy of 1 or both ovaries
 ;;     ___ Complete atrophy of 1 ovary
 ;;     ___ Complete atrophy of both ovaries (excluding natural menopause)
 ;;
 ;; d. Has the Veteran been diagnosed with any other diseases, injuries,
 ;; adhesions and/or other conditions of the ovaries?
 ;; ___ Yes   ___ No
 ;; If yes, describe: ___________________________________________________________
 ;;
 ;; 11. Incontinence
 ;; Does the Veteran have urinary incontinence/leakage?
 ;; ___ Yes   ___ No
 ;; If yes, is the urinary incontinence/leakage due to a gynecologic condition?
 ;; ___ Yes   ___ No
 ;; If yes, condition causing it: _______________________________________________
 ;; If yes, check all that apply:
 ;;     ___ Does not require/does not use absorbent material
 ;;     ___ Stress incontinence
 ;;     ___ Requires absorbent material that is changed less than 2 times per day
 ;;     ___ Requires absorbent material that is changed 2 to 4 times per day
 ;;     ___ Requires absorbent material that is changed more than 4 times per day
 ;;     ___ Requires the use of an appliance
 ;;          If checked, describe appliance: ____________________________________
 ;;
 ;; 12. Fistulae
 ;; a. Does the Veteran have a rectovaginal fistula?
 ;; ___ Yes   ___ No
 ;; If yes, cause: ______________________________________________________________
 ;; If yes, does the Veteran have vaginal-fecal leakage?
 ;; ___ Yes   ___ No
 ;; If yes, indicate frequency (check all that apply):
 ;;     ___ Less than once a week
 ;;     ___ 1-3 times per week
 ;;     ___ 4 or more times per week
 ;;     ___ Daily or more often
 ;;     ___ Requires wearing of pad or absorbent material
 ;;^TOF^
 ;; b. Does the Veteran have a urethrovaginal fistula?
 ;; ___ Yes   ___ No
 ;; If yes, cause: ______________________________________________________________
 ;; If yes, does the Veteran have urine leakage?
 ;; ___ Yes   ___ No
 ;; If yes, check all that apply:
 ;;     ___ Does not require/does not use absorbent material
 ;;     ___ Requires absorbent material that is changed less than 2 times per day
 ;;     ___ Requires absorbent material that is changed 2 to 4 times per day
 ;;     ___ Requires absorbent material that is changed more than 4 times per day
 ;;     ___ Requires the use of an appliance
 ;;          If checked, describe appliance: ____________________________________
 ;;
 ;; 13. Endometriosis
 ;; Has the Veteran been diagnosed with endometriosis?
 ;; NOTE: A diagnosis of endometriosis must be substantiated by laparoscopy.
 ;; ___ Yes   ___ No
 ;; If yes, does the Veteran currently have any findings, signs or symptoms due
 ;; to endometriosis?
 ;; ___ Yes   ___ No
 ;; If yes, check all that apply:
 ;;     ___ Pelvic pain
 ;;     ___ Heavy or irregular bleeding requiring continuous treatment for control
 ;;     ___ Heavy or irregular bleeding not controlled by treatment
 ;;     ___ Lesions involving bowel or bladder confirmed by laparoscopy
 ;;     ___ Bowel or bladder symptoms from endometriosis
 ;;     ___ Anemia caused by endometriosis
 ;;     ___ Other, describe: ____________________________________________________
 ;;
 ;; 14. Complications and residuals of pregnancy or other gynecologic procedures
 ;; a. Has the Veteran had any surgical complications of pregnancy?
 ;; ___ Yes   ___ No
 ;; If yes, check all that apply:
 ;;     ___ Relaxation of perineum
 ;;     ___ Rectocele
 ;;     ___ Cystocele
 ;;     ___ Other, describe: ____________________________________________________
 ;;
 ;; b. Has the Veteran had any other complications resulting from obstetrical
 ;; or gynecologic conditions or procedures?
 ;; ___ Yes   ___ No
 ;; If yes, describe: ___________________________________________________________
 ;; NOTE: If obstetrical or gynecologic complications impact other body systems,
 ;; also complete the additional appropriate Questionnaire(s).
 ;;
 Q


text:
 1">
        <ba-wizard>
          <ba-wizard-step ng-repeat="inspection_form in inspection_forms" title="{{inspection_form.title}}" form="questionForm">
            <form name="questionForm" ng-submit="next($index == inspection_forms.length - 1)">

            </form>
          </ba-wizard-step>
        </ba-wizard>

            Date
            {{now | date : 'M/d/yyyy h:m'}}

            Driver Name
            {{driver_name}}

        <form name="questionForm" ng-submit="next(true)">

        </form>


text:
module RequestGenerator
  extend ActiveSupport::Concern

  def request(method, path, body={}, headers={})
    id = "1"
    request = Soan::Request.new(id, method, path, body, headers)
    (route, matches) = *router.recognize(request)
    RequestBundle.new(request, route, matches)
  end

  def get(*args)    ; request("get", *args) ; end
  def post(*args)   ; request("post", *args) ; end
  def put(*args)    ; request("put", *args) ; end
  def patch(*args)  ; request("patch", *args) ; end
  def delete(*args) ; request("delete", *args) ; end

  class RequestBundle < Struct.new(:request, :route, :matches) ; end

end

RSpec.configure do |config|
  config.include RequestGenerator
end


text:
<?php if ( ! defined('BASEPATH')) exit('No direct script access allowed');
class Business_model extends CI_Model {
	// constructor for the user_model
	function __construct() {
		parent::__construct();
	}

	function is_associated($gID){
		$query = $this->db->query("SELECT is_associated FROM business WHERE google_id='$gID';");
		return $query->result();
	}

  function create_business($bInfo){
    $this->db->insert('business',$bInfo);
    return $this->db->insert_id();
  }

}
?>


text:
var express = require('express');

var app = express();

app.get('/', function(request, response) {
  response.send('Hello World!');
});

app.set('port', process.env.PORT || 3001);

var server = app.listen( app.get('port'),
  function() {
    console.log('Server listening at port '
                + server.address().port);
  }
);


text:
using Irony.Compiler;
using ScriptNET.Runtime;
#endregion

namespace ScriptNET.Ast
{
  /// <summary>
  /// Base class for Script.NET Ast's nodes
  /// </summary>
  public class ScriptAst : AstNode
  {
    /// <summary>
    /// Base constructor
    /// </summary>
    /// <param name="args">AstNodeList</param>
    public ScriptAst(AstNodeArgs args)
      : base(args)
    {

    }

    /// <summary>
    /// Returns Source code for given AST
    /// </summary>
    /// <returns></returns>
    public string Code()
    {
      return "Unimplemented yet";
    }

    /// <summary>
    /// Returns string representing concrete syntax tree
    /// </summary>
    /// <returns></returns>
    public string ConcreteSyntaxTree()
    {
      return ConcreteSyntaxTree("");
    }

    private string ConcreteSyntaxTree(string inted)
    {
      string tree = Term.Name + "\r\n";
      inted += " ";
      foreach (AstNode node in ChildNodes)
      {
        ScriptAst scriptNode = node as ScriptAst;
        if (scriptNode != null)
          tree += inted + scriptNode.ConcreteSyntaxTree(inted);
        else
        {
          if (!string.IsNullOrEmpty(node.Term.DisplayName))
            tree += inted + node.ToString() +"\r\n";
        }
      }
      return tree;
    }

    //TODO: Move To ScriptProg
    /// <summary>
    /// Evaluates all child nodes
    /// </summary>
    /// <param name="Context">ScriptContext object</param>
    /// <returns>result of the last node evaluation</returns>
    public object Execute(IScriptContext context)
    {
      Evaluate(context);
      return context.Result;
    }

    /// <summary>
    /// Evaluates script
    /// </summary>
    /// <param name="Context">ScriptContext</param>
    public virtual void Evaluate(IScriptContext context)
    {
      if (ChildNodes.Count > 0)
      {
        int index = 0;
        while (index < ChildNodes.Count)
        {
            ScriptAst node = ChildNodes[index] as ScriptAst;
            if (node != null)
                node.Evaluate(context);
            index++;
        }
      }
    }
  }
}


text:
package ru.sdroman;

import org.junit.Test;
import static org.hamcrest.core.Is.is;
import static org.junit.Assert.*;

public class StringArrayTest {

	@Test
	public void whenTakeArrayThenDeleteDuplicateString() {
		StringArray stringArray = new StringArray();
		String[] array = new String[]{"aa", "bb", "aa", "dd", "aa"};
		String[] result = new String[]{"aa", "bb", "dd"};
		assertThat(stringArray.stringDuplicate(array), is(result));
	}
}


text:
//
//  Copyright 2010-2017 Deveel
//
//    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.
//

using System;

namespace Deveel.Data.Storage {
	/// <summary>
	/// A unique identifier of an object within a database system,
	/// that is composed by a reference to the store it belongs to
	/// and the address of the object itself within the store.
	/// </summary>
	/// <remarks>
	/// It could happen that an object identifier is replicated
	/// by multiple stores, but the distinction is made by
	/// store: there cannot be two objects in the same store
	/// having the same identifier.
	/// </remarks>
	public struct ObjectId : IEquatable<ObjectId> {
		/// <summary>
		/// Constructs the <see cref="ObjectId"/> with the
		/// given references to the store and the address.
		/// </summary>
		/// <param name="storeId">The id of the store where the object belongs</param>
		/// <param name="id">The unique identifier of the object within the store.</param>
		public ObjectId(int storeId, long id)
			: this() {
			if (storeId < 0)
				throw new ArgumentOutOfRangeException(nameof(storeId));
			if (id < 0)
				throw new ArgumentOutOfRangeException(nameof(id));

			StoreId = storeId;
			Id = id;
		}

		/// <summary>
		/// Gets the unique identifier of the store that contains the object.
		/// </summary>
		/// <remarks>
		/// This is a unique value on a global level: it cannot happen that
		/// two stores have the same identifier in the same database system.
		/// </remarks>
		public int StoreId { get; }

		/// <summary>
		/// Gets the unique identifier of the object within the containing store.
		/// </summary>
		/// <remarks>
		/// This is a unique value on a store level: in the same store, it cannot
		/// happen to find two objects having the same identifier.
		/// </remarks>
		public long Id { get; }

		/// <inheritdoc/>
		public override bool Equals(object obj) {
			return Equals((ObjectId)obj);
		}

		/// <inheritdoc/>
		public override int GetHashCode() {
			return unchecked ((int)(StoreId*47 ^ Id));
		}

		/// <inheritdoc/>
		public bool Equals(ObjectId other) {
			return StoreId == other.StoreId &&
			       Id == other.Id;
		}

		/// <inheritdoc/>
		public override string ToString() {
			return String.Format("0x{0:X8}:0x{1:X8}", StoreId, Id);
		}
	}
}


text:
<?xml version="1.0" encoding="utf-8"?>
<resources>
    <!-- From: file:/Users/damodharan-2579/Documents/android-editor/android-editor/app/src/main/res/values/defaultpattern.xml -->
    <eat-comment/>
    <string-array name="constants">
        <item>\\b(\\d*[.]?\\d+)\\b</item>
        <item>\".*\"</item>
    </string-array>
    <string-array name="keywords">
        <item>import</item>
        <item>public</item>
        <item>private</item>
        <item>protected</item>
        <item>static</item>
        <item>void</item>
        <item>String</item>
        <item>Integer</item>
        <item>class</item>
        <item>extends</item>
    </string-array>
    <color name="pale">#dedede</color>
    <color name="white">#111</color>
    <!-- From: file:/Users/damodharan-2579/Documents/android-editor/android-editor/app/src/main/res/values/dimens.xml -->
    <eat-comment/>
    <dimen name="activity_horizontal_margin">16dp</dimen>
    <dimen name="activity_vertical_margin">16dp</dimen>
    <!-- From: file:/Users/damodharan-2579/Documents/android-editor/android-editor/app/src/main/res/values/defaultpattern.xml -->
    <eat-comment/>
    <dimen name="fontSize">6pt</dimen>
    <!-- From: file:/Users/damodharan-2579/Documents/android-editor/android-editor/app/src/main/res/values/strings.xml -->
    <eat-comment/>
    <string name="action_settings">Settings</string>
    <string name="app_name">Android-Tauto</string>
    <string name="hello_world">Hello world!</string>
    <!-- From: file:/Users/damodharan-2579/Documents/android-editor/android-editor/app/src/main/res/values/styles.xml -->
    <eat-comment/>
    <style name="AppBaseTheme" parent="android:Theme.Light">
        <!--
            Theme customizations available in newer API levels can go in
            res/values-vXX/styles.xml, while customizations related to
            backward-compatibility can go here.
        -->
    </style>
    <style name="AppTheme" parent="AppBaseTheme">
        <!-- All customizations that are NOT specific to a particular API-level can go here. -->
    </style>
</resources>


text:
'use strict';

let angular = require('angular');

module.exports = angular.module('spinnaker.core.utils.waypoints.container.directive', [
  require('./waypoint.service.js'),
])
  .directive('waypointContainer', function (waypointService) {
    return {
      restrict: 'A',
      scope: {
        key: '@waypointContainerKey',
        offsetHeight: '=waypointOffset',
      },
      link: {
        post: function (scope, elem) {
          var offset = scope.offsetHeight || 0;
          waypointService.registerWaypointContainer(scope, elem, scope.key, offset);
        }
      }
    };
  })
  .name;


text:
require 'bh/classes/navbar'

module Bh
  # Provides the `horizontal` helper.
  module HorizontalHelper

    def horizontal(*args, &block)
      if navbar = Bh::Stack.find(Bh::Navbar)
        horizontal = Bh::Base.new self, *args, &block
        horizontal.append_class! :'collapse navbar-collapse'
        horizontal.merge! id: navbar.id
        horizontal.render_tag :div
      end
    end
  end
end


text:
package net.java.sip.communicator.gui.imp;

/**
 * A class used to return contact description entered by the user in the
 * new contact dialog.
 */
public class ContactRemovalRequest
{
    private Object[]location          = null;
    private Object  contact           = null;

    /**
     * Returns the contact whose removal is requested by the user.
     * @return the contact whose removal is requested by the user.
     */
    public Object getContact()
    {
        return contact;
    }

    /**
     * Sets the contact whose removal is requested by the user.
     * @param contact the contact whose removal is requested by the user.
     */
    void setContact(Object contact)
    {
        this.contact = contact;
    }

    /**
     * Returns the location of the contact whose removal has been requested.
     * @return the location where the contact to be removed is currently located.
     */
    public Object[] getLocation()
    {
        return location;
    }

    /**
     * Sets the location where the contact is.
     * @param location the location of the contact.
     */
    void setLocation(Object[] location)
    {
        this.location = location;
    }
}


text: [1]:https://github.com/benjycui/introrx-chinese-edition "RP入门"


text:
package com.msd.gin.halyard.rio;

import com.fasterxml.jackson.core.JsonFactory;
import com.fasterxml.jackson.core.JsonParser;
import com.fasterxml.jackson.core.JsonToken;
import com.fasterxml.jackson.core.JsonTokenId;
import com.fasterxml.jackson.core.TreeNode;
import com.fasterxml.jackson.core.util.JsonParserDelegate;
import com.fasterxml.jackson.databind.JsonNode;
import com.fasterxml.jackson.databind.ObjectMapper;
import java.io.IOException;
import java.io.InputStream;
import java.io.Reader;
import java.net.URI;
import java.net.URISyntaxException;
import java.nio.charset.StandardCharsets;
import java.security.MessageDigest;
import java.security.NoSuchAlgorithmException;
import java.util.Arrays;
import java.util.Base64;
import java.util.Collection;
import java.util.Collections;
import java.util.Iterator;
import org.eclipse.rdf4j.model.IRI;
import org.eclipse.rdf4j.model.Statement;
import org.eclipse.rdf4j.model.ValueFactory;
import org.eclipse.rdf4j.model.impl.SimpleValueFactory;
import org.eclipse.rdf4j.model.vocabulary.OWL;
import org.eclipse.rdf4j.model.vocabulary.RDF;
import org.eclipse.rdf4j.model.vocabulary.RDFS;
import org.eclipse.rdf4j.model.vocabulary.XMLSchema;
import org.eclipse.rdf4j.rio.ParseErrorListener;
import org.eclipse.rdf4j.rio.ParseLocationListener;
import org.eclipse.rdf4j.rio.ParserConfig;
import org.eclipse.rdf4j.rio.RDFFormat;
import org.eclipse.rdf4j.rio.RDFHandler;
import org.eclipse.rdf4j.rio.RDFHandlerException;
import org.eclipse.rdf4j.rio.RDFParseException;
import org.eclipse.rdf4j.rio.RDFParser;
import org.eclipse.rdf4j.rio.RDFParserFactory;
import org.eclipse.rdf4j.rio.RioSetting;
import org.eclipse.rdf4j.rio.helpers.RioSettingImpl;

/**
 *
 * @author Adam Sotona (MSD)
 */
public final class JSONParser implements RDFParser {

    public static class Factory implements RDFParserFactory {

        @Override
        public RDFFormat getRDFFormat() {
            return JSON;
        }

        @Override
        public RDFParser getParser() {
            return new JSONParser();
        }

    }

    public static final RDFFormat JSON = new RDFFormat("JSON", Arrays.asList("application/json"), StandardCharsets.UTF_8, Collections.singletonList("json"), RDFFormat.NO_CONTEXTS, RDFFormat.NO_CONTEXTS);
    public static final RioSetting<Boolean> GENERATE_ONTOLOGY = new RioSettingImpl<>(JSONParser.class.getCanonicalName() + ".GENERATE_ONTOLOGY", "Generate ontology statements while parsing", Boolean.FALSE);
    public static final RioSetting<Boolean> GENERATE_DATA = new RioSettingImpl<>(JSONParser.class.getCanonicalName() + ".GENERATE_DATA", "Generate data statements while parsing", Boolean.TRUE);

    private static final String MD_ALGORITHM = "SHA-512";

    private final JsonFactory jsonFactory = new ObjectMapper().getFactory();
    private final MessageDigest md;

    private ValueFactory vf = SimpleValueFactory.getInstance();
    private RDFHandler rdfHandler;
    private ParserConfig config = new ParserConfig();
    private boolean generateOntology, generateData;
    private IRI baseURI;

    public JSONParser() {
        this(MD_ALGORITHM);
    }

    JSONParser(String mdAlgorithm) {
        try {
            md = MessageDigest.getInstance(mdAlgorithm);
        } catch (NoSuchAlgorithmException ex) {
            throw new RuntimeException(ex);
        }
    }

    @Override
    public RDFFormat getRDFFormat() {
        return JSON;
    }

    @Override
    public Collection<RioSetting<?>> getSupportedSettings() {
            return Arrays.asList(GENERATE_DATA, GENERATE_ONTOLOGY);
    }

    @Override
    public RDFParser setValueFactory(ValueFactory valueFactory) {
        this.vf = valueFactory;
        return this;
    }

    @Override
    public RDFParser setRDFHandler(RDFHandler handler) {
        this.rdfHandler = handler;
        return this;
    }

    @Override
    public RDFParser setParseErrorListener(ParseErrorListener el) {
        return this;
    }

    @Override
    public RDFParser setParseLocationListener(ParseLocationListener ll) {
        return this;
    }

    @Override
    public RDFParser setParserConfig(ParserConfig config) {
        this.config = config;
        return this;
    }

    @Override
    public ParserConfig getParserConfig() {
        return this.config;
    }

    @Override
    public <T> RDFParser set(RioSetting<T> setting, T value) {
        this.config.set(setting, value);
        return this;
    }

    @Override
    @SuppressWarnings("deprecation")
    public void setVerifyData(boolean verifyData) {}

    @Override
    public void setPreserveBNodeIDs(boolean preserveBNodeIDs) {}

    @Override
    @SuppressWarnings("deprecation")
    public void setStopAtFirstError(boolean stopAtFirstError) {}

    @Override
    @SuppressWarnings({"deprecation"})
    public void setDatatypeHandling(DatatypeHandling datatypeHandling) {}

    @Override
    public void parse(InputStream in, String baseURI) throws IOException, RDFParseException, RDFHandlerException {
        parse(jsonFactory.createParser(in), baseURI);
    }

    @Override
    public void parse(Reader reader, String baseURI) throws IOException, RDFParseException, RDFHandlerException {
        parse(jsonFactory.createParser(reader), baseURI);
    }

    private void parse(JsonParser jsonSource, String baseURI) throws IOException {
        this.baseURI = vf.createIRI(baseURI);
        generateOntology = getParserConfig().get(GENERATE_ONTOLOGY);
        generateData = getParserConfig().get(GENERATE_DATA);
        try (JsonParser parser = new JsonParserDelegate(jsonSource) {
            @Override
            public JsonToken nextToken() throws IOException {
                JsonToken t = super.nextToken();
                return t != null && t.isNumeric() ? JsonToken.VALUE_STRING : t;
            }

            @Override
            public JsonToken getCurrentToken() {
                JsonToken t = super.getCurrentToken();
                return t != null && t.isNumeric() ? JsonToken.VALUE_STRING : t;
            }

            @Override
            public int getCurrentTokenId() {
                int id = super.getCurrentTokenId();
                return (id == JsonTokenId.ID_NUMBER_INT || id == JsonTokenId.ID_NUMBER_FLOAT) ? JsonTokenId.ID_STRING : id;
            }

        }) {
            if (rdfHandler != null) {
                rdfHandler.startRDF();
            }
            if (generateOntology) {
                handleNamespace(RDF.PREFIX, RDF.NAMESPACE);
                handleNamespace(RDFS.PREFIX, RDFS.NAMESPACE);
                handleNamespace(OWL.PREFIX, OWL.NAMESPACE);
                handleStatement(vf.createStatement(this.baseURI, RDF.TYPE, OWL.ONTOLOGY));
            }
            handleNamespace("", this.baseURI.stringValue());
            TreeNode root = parser.readValueAsTree();
            if (root != null) {
                if (root.isArray()) {
                    for (int i=0; i<root.size(); i++) {
                        transform(root.get(i));
                    }
                } else if (root.isObject()) {
                    transform(root);
                } else {
                    throw new IllegalArgumentException("Illegal node type");
                }
                if (parser.nextToken() != null) {
                    throw new IllegalArgumentException("Invalid JSON format");
                }
            }
            if (rdfHandler != null) {
                rdfHandler.endRDF();
            }
        } catch (URISyntaxException ex) {
            throw new RDFParseException(ex);
        }
    }
    private void hash(TreeNode node) {
        if (node.isArray()) {
            md.update((byte)'l');
            for (int i = 0; i < node.size(); i++) {
                hash(node.get(i));
            }
            md.update((byte)'e');
        } else if (node.isObject()) {
            String[] fieldNames = new String[node.size()];
            Iterator<String> it = node.fieldNames();
            for (int i=0; i< fieldNames.length; i++) {
                fieldNames[i] = it.next();
            }
            Arrays.sort(fieldNames);
            md.update((byte)'d');
            for (String fName : fieldNames) {
                hash(fName);
                hash(node.get(fName));
            }
            md.update((byte)'e');
        } else if (node.isValueNode()) {
            String val = ((JsonNode)node).textValue();
            if (val != null) {
                hash(val);
            }
        } else {
            throw new IllegalArgumentException(node.toString());
        }
    }

    private void hash(String val) {
        byte[] bs = val.getBytes(StandardCharsets.UTF_8);
        byte[] bsLen = String.valueOf(bs.length).getBytes(StandardCharsets.UTF_8);
        md.update(bsLen);
        md.update((byte)':');
        md.update(bs);
    }

    private void handleNamespace(String prefix, String uri) {
        if (rdfHandler != null) {
            rdfHandler.handleNamespace(prefix, uri);
        }
    }

    private void handleStatement(Statement st) {
        if (rdfHandler != null) {
            rdfHandler.handleStatement(st);
        }
    }

    private void transform(TreeNode node) throws URISyntaxException {
        String hash;
        try {
            hash(node);
            hash = Base64.getUrlEncoder().withoutPadding().encodeToString(md.digest());
        } finally {
            md.reset();
        }
        treeWalk(null, null, vf.createIRI(baseURI + hash).stringValue(), "", null, null, node);
    }

    private void treeWalk(IRI parentIRI, IRI parentClass, String path, String predicatePath, String label, Integer index, TreeNode node) throws URISyntaxException {
        if (node.isArray()) {
            for (int i = 0; i < node.size(); i++) {
                treeWalk(parentIRI, parentClass, path + ":" + i, predicatePath, label, i, node.get(i));
            }
        } else if (node.isObject()) {
            IRI pkIRI = vf.createIRI((parentIRI == null ? "" : parentIRI.stringValue()) + path);
            IRI classIRI = vf.createIRI(baseURI + predicatePath + ":Node");
            if (parentIRI != null) {
                IRI predicate = vf.createIRI(baseURI + predicatePath);
                if (generateData) {
                    handleStatement(vf.createStatement(parentIRI, predicate, pkIRI));
                }
                if (generateOntology) {
                    handleStatement(vf.createStatement(predicate, RDF.TYPE, OWL.OBJECTPROPERTY));
                    handleStatement(vf.createStatement(predicate, RDFS.LABEL, vf.createLiteral(label)));
                    handleStatement(vf.createStatement(predicate, RDFS.DOMAIN, parentClass));
                    handleStatement(vf.createStatement(predicate, RDFS.RANGE, classIRI));
                }
            }
            if (generateData) {
                handleStatement(vf.createStatement(pkIRI, RDF.TYPE, classIRI));
            }
            if (generateOntology) {
                handleStatement(vf.createStatement(classIRI, RDF.TYPE, RDFS.CLASS));
            }
            if (index != null) {
                IRI indexIRI = vf.createIRI(baseURI + predicatePath + ":index");
                if (generateData) {
                    handleStatement(vf.createStatement(pkIRI, indexIRI, vf.createLiteral(index.toString(), XMLSchema.INTEGER)));
                }
                if (generateOntology) {
                    handleStatement(vf.createStatement(indexIRI, RDF.TYPE, OWL.DATATYPEPROPERTY));
                    handleStatement(vf.createStatement(indexIRI, RDFS.LABEL, vf.createLiteral("index")));
                    handleStatement(vf.createStatement(indexIRI, RDFS.DOMAIN, classIRI));
                }
            }
            Iterator<String> fieldNames = node.fieldNames();
            while (fieldNames.hasNext()) {
                String fieldName = fieldNames.next();
                String encodedFieldName = new URI(null, null, fieldName).getRawFragment().replace(".", "%2E").replace(":", "%3A");
                treeWalk(pkIRI, classIRI, "." + encodedFieldName, (predicatePath.length() == 0 ? "": predicatePath + '.') + encodedFieldName, fieldName, null, node.get(fieldName));
            }
        } else if (node.isValueNode()) {
            if (parentIRI == null) {
                throw new IllegalArgumentException("Value without parent IRI");
            }
            IRI predicate = vf.createIRI(baseURI + predicatePath);
            if (generateData) {
                String value = ((JsonNode)node).textValue();
                if (value != null) {
                    handleStatement(vf.createStatement(parentIRI, predicate, vf.createLiteral(value)));
                }
            }
            if (generateOntology) {
                handleStatement(vf.createStatement(predicate, RDF.TYPE, OWL.DATATYPEPROPERTY));
                handleStatement(vf.createStatement(predicate, RDFS.LABEL, vf.createLiteral(label)));
                handleStatement(vf.createStatement(predicate, RDFS.DOMAIN, parentClass));
            }
        } else {
                throw new IllegalArgumentException("Illegal node type");
        }
    }
}


text:
{% extends "horizon/common/_modal_form.html" %}
{% load i18n %}
{% load url from future %}

{% block form_id %}update_ikepolicy_form{% endblock %}
{% block form_action %}{% url 'horizon:project:vpn:update_ikepolicy' ikepolicy_id %}{% endblock %}

{% block modal-header %}{% trans "Edit IKE Policy" %}{% endblock %}

{% block modal-body %}

    <fieldset>
    {% include "horizon/common/_form_fields.html" %}
    </fieldset>

{% trans "Description:" %}

{% trans "You may update IKE Policy details here." %}

{% endblock %}

{% block modal-footer %}
  <input class="btn btn-primary pull-right" type="submit" value="{% trans "Save Changes" %}" />
  {% trans "Cancel" %}
{% endblock %}


text:
<?xml version="1.0" encoding="UTF-8"?>
<response xmlns="urn:didata.com:api:cloud:types" requestId="eu_20181121T192344024+0100_06309e7f-c0bb-4034-b960-0b28ad694608">
    <operation>DELETE_SSL_DOMAIN_CERTIFICATE</operation>
    <responseCode>OK</responseCode>
    <message>SSL Domain Certificate has been deleted.</message>
</response>


text:
/**
 * @file autopilot_interface.h
 *
 * @brief Autopilot interface definition
 *
 * Functions for sending and recieving commands to an autopilot via MAVlink
 *
 * @author Trent Lukaczyk, <aerialhedgehog@gmail.com>
 * @author Jaycee Lock,    <jaycee.lock@gmail.com>
 * @author Lorenz Meier,   <lm@inf.ethz.ch>
 *
 */

#ifndef AUTOPILOT_INTERFACE_H_
#define AUTOPILOT_INTERFACE_H_

// ------------------------------------------------------------------------------
//   Includes
// ------------------------------------------------------------------------------

#include "serial_port.h"
#include <signal.h>
#include <time.h>
#include <sys/time.h>
#include "ros_comm.h"
#include <common/mavlink.h>

//// ------------------------------------------------------------------------------
////   Defines
//// ------------------------------------------------------------------------------
//
///**
// * Defines for mavlink_set_position_target_local_ned_t.type_mask
// *
// * Bitmask to indicate which dimensions should be ignored by the vehicle
// *
// * a value of 0b0000000000000000 or 0b0000001000000000 indicates that none of
// * the setpoint dimensions should be ignored.
// *
// * If bit 10 is set the floats afx afy afz should be interpreted as force
// * instead of acceleration.
// *
// * Mapping:
// * bit 1: x,
// * bit 2: y,
// * bit 3: z,
// * bit 4: vx,
// * bit 5: vy,
// * bit 6: vz,
// * bit 7: ax,
// * bit 8: ay,
// * bit 9: az,
// * bit 10: is force setpoint,
// * bit 11: yaw,
// * bit 12: yaw rate
// * remaining bits unused
// *
// * Combine bitmasks with bitwise &
// *
// * Example for position and yaw angle:
// * uint16_t type_mask =
// *     MAVLINK_MSG_SET_POSITION_TARGET_LOCAL_NED_POSITION &
// *     MAVLINK_MSG_SET_POSITION_TARGET_LOCAL_NED_YAW_ANGLE;
// */
//
//                                                // bit number  876543210987654321
//#define MAVLINK_MSG_SET_POSITION_TARGET_LOCAL_NED_POSITION     0b0000110111111000
//#define MAVLINK_MSG_SET_POSITION_TARGET_LOCAL_NED_VELOCITY     0b0000110111000111
//#define MAVLINK_MSG_SET_POSITION_TARGET_LOCAL_NED_ACCELERATION 0b0000110000111111
//#define MAVLINK_MSG_SET_POSITION_TARGET_LOCAL_NED_FORCE        0b0000111000111111
//#define MAVLINK_MSG_SET_POSITION_TARGET_LOCAL_NED_YAW_ANGLE    0b0000100111111111
//#define MAVLINK_MSG_SET_POSITION_TARGET_LOCAL_NED_YAW_RATE     0b0000010111111111
//

// ------------------------------------------------------------------------------
//   Prototypes
// ------------------------------------------------------------------------------

// helper functions
uint64_t get_time_usec();
void set_position(float x, float y, float z, mavlink_set_position_target_local_ned_t &sp);
void set_velocity(float vx, float vy, float vz, mavlink_set_position_target_local_ned_t &sp);
void set_acceleration(float ax, float ay, float az, mavlink_set_position_target_local_ned_t &sp);
void set_yaw(float yaw, mavlink_set_position_target_local_ned_t &sp);
void set_yaw_rate(float yaw_rate, mavlink_set_position_target_local_ned_t &sp);

void* start_autopilot_interface_read_thread(void *args);
void* start_autopilot_interface_write_thread(void *args);

// ------------------------------------------------------------------------------
//   Data Structures
// ------------------------------------------------------------------------------

struct Time_Stamps
{
	Time_Stamps()
	{
		reset_timestamps();
	}

	uint64_t heartbeat;
	uint64_t sys_status;
	uint64_t battery_status;
	uint64_t radio_status;
	uint64_t local_position_ned;
	uint64_t global_position_int;
	uint64_t position_target_local_ned;
	uint64_t position_target_global_int;
	uint64_t highres_imu;
	uint64_t attitude;
	uint64_t rc_channels;
	uint64_t vfr_hud;
	void
	reset_timestamps()
	{
		heartbeat = 0;
		sys_status = 0;
		battery_status = 0;
		radio_status = 0;
		local_position_ned = 0;
		global_position_int = 0;
		position_target_local_ned = 0;
		position_target_global_int = 0;
		highres_imu = 0;
		attitude = 0;
	}

};

// Struct containing information on the MAV we are currently connected to

struct Mavlink_Messages {

	int sysid;
	int compid;

	// Heartbeat
	mavlink_heartbeat_t heartbeat;

	// System Status
	mavlink_sys_status_t sys_status;

	// Battery Status
	mavlink_battery_status_t battery_status;

	// Radio Status
	mavlink_radio_status_t radio_status;

	// Local Position
	mavlink_local_position_ned_t local_position_ned;

	// Global Position
	mavlink_global_position_int_t global_position_int;

	// Local Position Target
	mavlink_position_target_local_ned_t position_target_local_ned;

	// Global Position Target
	mavlink_position_target_global_int_t position_target_global_int;

	// HiRes IMU
	mavlink_highres_imu_t highres_imu;

	// Attitude
	mavlink_attitude_t attitude;

	//RC_channels
	mavlink_rc_channels_t rc_channels;

	// System Parameters?

	//VFR_HUD
	mavlink_vfr_hud_t vfr_hud;
	// Time Stamps
	Time_Stamps time_stamps;

	void
	reset_timestamps()
	{
		time_stamps.reset_timestamps();
	}

};

// ----------------------------------------------------------------------------------
//   Autopilot Interface Class
// ----------------------------------------------------------------------------------
/*
 * Autopilot Interface Class
 *
 * This starts two threads for read and write over MAVlink. The read thread
 * listens for any MAVlink message and pushes it to the current_messages
 * attribute.  The write thread at the moment only streams a position target
 * in the local NED frame (mavlink_set_position_target_local_ned_t), which
 * is changed by using the method update_setpoint().  Sending these messages
 * are only half the requirement to get response from the autopilot, a signal
 * to enter "offboard_control" mode is sent by using the enable_offboard_control()
 * method.  Signal the exit of this mode with disable_offboard_control().  It's
 * important that one way or another this program signals offboard mode exit,
 * otherwise the vehicle will go into failsafe.
 */
class Autopilot_Interface
{

public:

	Autopilot_Interface();
	Autopilot_Interface(Serial_Port *serial_port_);
	~Autopilot_Interface();

	char reading_status;
//	char writing_status;
	char control_status;

	ROS_Communication ros_comm;
	Mavlink_Messages current_messages;
	mavlink_set_position_target_local_ned_t initial_position;

	void update_setpoint(mavlink_set_position_target_local_ned_t setpoint);
	void read_messages();

	void safety_arm();
	void enable_offboard_control();
	void disable_offboard_control();

	void start();
	void stop();

	void start_read_thread();
	void start_write_thread(void);

	void handle_quit( int sig );

	void write_RCoverride();
//	void write_manual_control();

private:

	bool time_to_exit;

	pthread_t read_tid;
	pthread_t write_tid;

	void read_thread();
	void write_thread(void);

	int toggle_offboard_control( bool flag );
	void write_setpoint();

};

#endif // AUTOPILOT_INTERFACE_H_


text:
package org.apache.httpcomponents.ant;

import java.io.File;

import org.apache.http.entity.mime.content.ContentBody;
import org.apache.http.entity.mime.content.FileBody;
import org.apache.tools.ant.BuildException;
import org.apache.tools.ant.Task;

public class FilePartNode extends PartNode {

    private File file;

    private String filename;

    private String charset;

    public void setFile(File file) {
        this.file = file;
    }

    public void setFilename(String filename) {
        this.filename = filename;
    }

    public void setCharset(String charset) {
        this.charset = charset;
    }

    @Override
    public ContentBody buildContentBoby() {
        if (file == null) {
            throw new BuildException("Missing 'file' attribute");
        }
        FileBody fileBody;
        String mimeType = getMimeType();
        if (mimeType == null) {
            mimeType = "application/octet-stream";
        }
        if (filename != null) {
            fileBody = new FileBody(file, filename, mimeType, charset);
        } else {
            fileBody = new FileBody(file, mimeType, charset);
        }
        return fileBody;
    }

    @Override
    public void log(Task task, int msgLevel) {
        task.log("File part: name=" + getName() + " file=" + file + (filename != null ? (" filename=" + filename) : ""), msgLevel);
    }
}


text:
var arduino = require('../');

var board = new arduino.Board();

board.on('connected', function(){
  board.write('HELLO WORLD');
});

board.on('message', function(data) {
  console.log(data);
});


text:
#ifndef QSSLCERTIFICATE_H
#define QSSLCERTIFICATE_H

#include <QtCore/qnamespace.h>
#include <QtCore/qbytearray.h>
#include <QtCore/qcryptographichash.h>
#include <QtCore/qregexp.h>
#include <QtCore/qsharedpointer.h>
#include <QtNetwork/qssl.h>

typedef struct x509_st X509; // ### check if this works

QT_BEGIN_HEADER

QT_BEGIN_NAMESPACE

QT_MODULE(Network)

#ifndef QT_NO_OPENSSL

class QDateTime;
class QIODevice;
class QSslKey;
class QStringList;
template <typename T, typename U> class QMultiMap;

class QSslCertificatePrivate;
class Q_NETWORK_EXPORT QSslCertificate
{
public:
    enum SubjectInfo {
        Organization,
        CommonName,
        LocalityName,
        OrganizationalUnitName,
        CountryName,
        StateOrProvinceName
    };

    QSslCertificate(QIODevice *device, QSsl::EncodingFormat format = QSsl::Pem);
    QSslCertificate( // ### s/encoded/data (to be consistent with signature in .cpp file) ?
        const QByteArray &encoded = QByteArray(), QSsl::EncodingFormat format = QSsl::Pem);
    QSslCertificate(const QSslCertificate &other);
    ~QSslCertificate();
    QSslCertificate &operator=(const QSslCertificate &other);
    bool operator==(const QSslCertificate &other) const;
    inline bool operator!=(const QSslCertificate &other) const { return !operator==(other); }

    bool isNull() const;
    bool isValid() const;
    void clear();

    // Certificate info
    QByteArray version() const;
    QByteArray serialNumber() const;
    QByteArray digest(QCryptographicHash::Algorithm algorithm = QCryptographicHash::Md5) const;
    QString issuerInfo(SubjectInfo info) const;
    QString issuerInfo(const QByteArray &tag) const;
    QString subjectInfo(SubjectInfo info) const;
    QString subjectInfo(const QByteArray &tag) const;
    QMultiMap<QSsl::AlternateNameEntryType, QString> alternateSubjectNames() const;
    QDateTime effectiveDate() const;
    QDateTime expiryDate() const;
    QSslKey publicKey() const;

    QByteArray toPem() const;
    QByteArray toDer() const;

    static QList<QSslCertificate> fromPath(
        const QString &path, QSsl::EncodingFormat format = QSsl::Pem,
        QRegExp::PatternSyntax syntax = QRegExp::FixedString);
    static QList<QSslCertificate> fromDevice(
        QIODevice *device, QSsl::EncodingFormat format = QSsl::Pem);
    static QList<QSslCertificate> fromData(
        const QByteArray &data, QSsl::EncodingFormat format = QSsl::Pem);

    Qt::HANDLE handle() const;

private:
    QExplicitlySharedDataPointer<QSslCertificatePrivate> d;
    friend class QSslCertificatePrivate;
    friend class QSslSocketBackendPrivate;
};

#ifndef QT_NO_DEBUG_STREAM
class QDebug;
Q_NETWORK_EXPORT QDebug operator<<(QDebug debug, const QSslCertificate &certificate);
Q_NETWORK_EXPORT QDebug operator<<(QDebug debug, QSslCertificate::SubjectInfo info);
#endif

#endif // QT_NO_OPENSSL

QT_END_NAMESPACE

QT_END_HEADER

#endif


text:
[![Build Status](https://travis-ci.org/ekumenlabs/terminus.svg?branch=master)](https://travis-ci.org/ekumenlabs/terminus)

# Terminus
Terminus is a library that can build cities from different sources (e.g. by procedurally generating them or by using OpenStreetMaps data) and later output them to different file formats (RNDF, monolane, SDF, etc).

## Usage

Please, refer to the [wiki](https://github.com/ekumenlabs/terminus/wiki) for installation and usage instructions.