text:
angular.module('starter', ['ionic', 'starter.services', 'starter.controllers'])

.config(function($stateProvider, $urlRouterProvider) {

  // Ionic uses AngularUI Router which uses the concept of states
  // Learn more here: https://github.com/angular-ui/ui-router
  // Set up the various states which the app can be in.
  // Each state's controller can be found in controllers.js
  $stateProvider

    // setup an abstract state for the tabs directive
    .state('tab', {
      url: "/tab",
      abstract: true,
      templateUrl: "templates/tabs.html"
    })

    // the pet tab has its own child nav-view and history
    .state('tab.beer-index', {
      url: '/beers',
      views: {
        'beers-tab': {
          templateUrl: 'templates/beer-index.html',
          controller: 'BeerIndexCtrl'
        }
      }
    })

    .state('tab.beer-detail', {
      url: '/beer/:beerId',
      views: {
        'beers-tab': {
          templateUrl: 'templates/beer-detail.html',
          controller: 'BeerDetailCtrl'
        }
      }
    })

    .state('tab.adopt', {
      url: '/adopt',
      views: {
        'adopt-tab': {
          templateUrl: 'templates/adopt.html'
        }
      }
    })

    .state('tab.about', {
      url: '/about',
      views: {
        'about-tab': {
          templateUrl: 'templates/about.html'
        }
      }
    });

  // if none of the above states are matched, use this as the fallback
  $urlRouterProvider.otherwise('/tab/beers');

});


text:
package simulator

import (
	"io/ioutil"
	"os"
	"path"
	"strings"

	"github.com/vmware/govmomi/vim25/methods"
	"github.com/vmware/govmomi/vim25/mo"
	"github.com/vmware/govmomi/vim25/soap"
	"github.com/vmware/govmomi/vim25/types"
)

type HostDatastoreBrowser struct {
	mo.HostDatastoreBrowser
}

type searchDatastore struct {
	*HostDatastoreBrowser

	DatastorePath string
	SearchSpec    *types.HostDatastoreBrowserSearchSpec

	res []types.HostDatastoreBrowserSearchResults

	recurse bool
}

func (s *searchDatastore) addFile(file os.FileInfo, res *types.HostDatastoreBrowserSearchResults) {
	details := s.SearchSpec.Details
	if details == nil {
		details = new(types.FileQueryFlags)
	}

	name := file.Name()

	info := types.FileInfo{
		Path: name,
	}

	var finfo types.BaseFileInfo = &info

	if details.FileSize {
		info.FileSize = file.Size()
	}

	if details.Modification {
		mtime := file.ModTime()
		info.Modification = &mtime
	}

	if isTrue(details.FileOwner) {
		// Assume for now this process created all files in the datastore
		user := os.Getenv("USER")

		info.Owner = user
	}

	if file.IsDir() {
		finfo = &types.FolderFileInfo{FileInfo: info}
	} else if details.FileType {
		switch path.Ext(name) {
		case ".img":
			finfo = &types.FloppyImageFileInfo{FileInfo: info}
		case ".iso":
			finfo = &types.IsoImageFileInfo{FileInfo: info}
		case ".log":
			finfo = &types.VmLogFileInfo{FileInfo: info}
		case ".nvram":
			finfo = &types.VmNvramFileInfo{FileInfo: info}
		case ".vmdk":
			// TODO: lookup device to set other fields
			finfo = &types.VmDiskFileInfo{FileInfo: info}
		case ".vmx":
			finfo = &types.VmConfigFileInfo{FileInfo: info}
		}
	}

	res.File = append(res.File, finfo)
}

func (s *searchDatastore) queryMatch(file os.FileInfo) bool {
	if len(s.SearchSpec.Query) == 0 {
		return true
	}

	name := file.Name()
	ext := path.Ext(name)

	for _, q := range s.SearchSpec.Query {
		switch q.(type) {
		case *types.FileQuery:
			return true
		case *types.FolderFileQuery:
			if file.IsDir() {
				return true
			}
		case *types.FloppyImageFileQuery:
			if ext == ".img" {
				return true
			}
		case *types.IsoImageFileQuery:
			if ext == ".iso" {
				return true
			}
		case *types.VmConfigFileQuery:
			if ext == ".vmx" {
				// TODO: check Filter and Details fields
				return true
			}
		case *types.VmDiskFileQuery:
			if ext == ".vmdk" {
				// TODO: check Filter and Details fields
				return !strings.HasSuffix(name, "-flat.vmdk")
			}
		case *types.VmLogFileQuery:
			if ext == ".log" {
				return strings.HasPrefix(name, "vmware")
			}
		case *types.VmNvramFileQuery:
			if ext == ".nvram" {
				return true
			}
		case *types.VmSnapshotFileQuery:
			if ext == ".vmsn" {
				return true
			}
		}
	}

	return false
}

func (s *searchDatastore) search(ds *types.ManagedObjectReference, folder string, dir string) error {
	files, err := ioutil.ReadDir(dir)
	if err != nil {
		tracef("search %s: %s", dir, err)
		return err
	}

	res := types.HostDatastoreBrowserSearchResults{
		Datastore:  ds,
		FolderPath: folder,
	}

	for _, file := range files {
		name := file.Name()

		if s.queryMatch(file) {
			for _, m := range s.SearchSpec.MatchPattern {
				if ok, _ := path.Match(m, name); ok {
					s.addFile(file, &res)
					break
				}
			}
		}

		if s.recurse && file.IsDir() {
			_ = s.search(ds, path.Join(folder, name), path.Join(dir, name))
		}
	}

	s.res = append(s.res, res)

	return nil
}

func (s *searchDatastore) Run(task *Task) (types.AnyType, types.BaseMethodFault) {
	p, fault := parseDatastorePath(s.DatastorePath)
	if fault != nil {
		return nil, fault
	}

	ref := Map.FindByName(p.Datastore, s.Datastore)
	if ref == nil {
		return nil, &types.InvalidDatastore{Name: p.Datastore}
	}

	ds := ref.(*Datastore)

	isolatedLockContext := &Context{} // we don't need/want to share the task lock
	Map.WithLock(isolatedLockContext, task, func() {
		task.Info.Entity = &ds.Self // TODO: CreateTask() should require mo.Entity, rather than mo.Reference
		task.Info.EntityName = ds.Name
	})

	dir := path.Join(ds.Info.GetDatastoreInfo().Url, p.Path)

	err := s.search(&ds.Self, s.DatastorePath, dir)
	if err != nil {
		ff := types.FileFault{
			File: p.Path,
		}

		if os.IsNotExist(err) {
			return nil, &types.FileNotFound{FileFault: ff}
		}

		return nil, &types.InvalidArgument{InvalidProperty: p.Path}
	}

	if s.recurse {
		return types.ArrayOfHostDatastoreBrowserSearchResults{
			HostDatastoreBrowserSearchResults: s.res,
		}, nil
	}

	return s.res[0], nil
}

func (b *HostDatastoreBrowser) SearchDatastoreTask(ctx *Context, s *types.SearchDatastore_Task) soap.HasFault {
	task := NewTask(&searchDatastore{
		HostDatastoreBrowser: b,
		DatastorePath:        s.DatastorePath,
		SearchSpec:           s.SearchSpec,
	})

	return &methods.SearchDatastore_TaskBody{
		Res: &types.SearchDatastore_TaskResponse{
			Returnval: task.Run(ctx),
		},
	}
}

func (b *HostDatastoreBrowser) SearchDatastoreSubFoldersTask(ctx *Context, s *types.SearchDatastoreSubFolders_Task) soap.HasFault {
	task := NewTask(&searchDatastore{
		HostDatastoreBrowser: b,
		DatastorePath:        s.DatastorePath,
		SearchSpec:           s.SearchSpec,
		recurse:              true,
	})

	return &methods.SearchDatastoreSubFolders_TaskBody{
		Res: &types.SearchDatastoreSubFolders_TaskResponse{
			Returnval: task.Run(ctx),
		},
	}
}

redpajama_set_name: RedPajamaGithub


text:
package org.elasticsearch.xpack.slm.action;

import org.elasticsearch.ResourceNotFoundException;
import org.elasticsearch.action.ActionListener;
import org.elasticsearch.action.support.ActionFilters;
import org.elasticsearch.action.support.master.TransportMasterNodeAction;
import org.elasticsearch.cluster.ClusterState;
import org.elasticsearch.cluster.SnapshotsInProgress;
import org.elasticsearch.cluster.block.ClusterBlockException;
import org.elasticsearch.cluster.block.ClusterBlockLevel;
import org.elasticsearch.cluster.metadata.IndexNameExpressionResolver;
import org.elasticsearch.cluster.service.ClusterService;
import org.elasticsearch.common.inject.Inject;
import org.elasticsearch.snapshots.SnapshotsService;
import org.elasticsearch.tasks.Task;
import org.elasticsearch.threadpool.ThreadPool;
import org.elasticsearch.transport.TransportService;
import org.elasticsearch.xpack.core.slm.SnapshotLifecycleMetadata;
import org.elasticsearch.xpack.core.slm.SnapshotLifecyclePolicyItem;
import org.elasticsearch.xpack.core.slm.SnapshotLifecycleStats;
import org.elasticsearch.xpack.core.slm.action.GetSnapshotLifecycleAction;

import java.util.Arrays;
import java.util.Collections;
import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.stream.Collectors;

public class TransportGetSnapshotLifecycleAction extends TransportMasterNodeAction<
    GetSnapshotLifecycleAction.Request,
    GetSnapshotLifecycleAction.Response> {

    @Inject
    public TransportGetSnapshotLifecycleAction(
        TransportService transportService,
        ClusterService clusterService,
        ThreadPool threadPool,
        ActionFilters actionFilters,
        IndexNameExpressionResolver indexNameExpressionResolver
    ) {
        super(
            GetSnapshotLifecycleAction.NAME,
            transportService,
            clusterService,
            threadPool,
            actionFilters,
            GetSnapshotLifecycleAction.Request::new,
            indexNameExpressionResolver,
            GetSnapshotLifecycleAction.Response::new,
            ThreadPool.Names.SAME
        );
    }

    @Override
    protected void masterOperation(
        final Task task,
        final GetSnapshotLifecycleAction.Request request,
        final ClusterState state,
        final ActionListener<GetSnapshotLifecycleAction.Response> listener
    ) {
        SnapshotLifecycleMetadata snapMeta = state.metadata().custom(SnapshotLifecycleMetadata.TYPE);
        if (snapMeta == null) {
            if (request.getLifecycleIds().length == 0) {
                listener.onResponse(new GetSnapshotLifecycleAction.Response(Collections.emptyList()));
            } else {
                listener.onFailure(
                    new ResourceNotFoundException(
                        "snapshot lifecycle policy or policies {} not found, no policies are configured",
                        Arrays.toString(request.getLifecycleIds())
                    )
                );
            }
        } else {
            final Map<String, SnapshotLifecyclePolicyItem.SnapshotInProgress> inProgress;
            SnapshotsInProgress sip = state.custom(SnapshotsInProgress.TYPE);
            if (sip == null) {
                inProgress = Collections.emptyMap();
            } else {
                inProgress = new HashMap<>();
                for (List<SnapshotsInProgress.Entry> entriesForRepo : sip.entriesByRepo()) {
                    for (SnapshotsInProgress.Entry entry : entriesForRepo) {
                        Map<String, Object> meta = entry.userMetadata();
                        if (meta == null
                            || meta.get(SnapshotsService.POLICY_ID_METADATA_FIELD) == null
                            || (meta.get(SnapshotsService.POLICY_ID_METADATA_FIELD) instanceof String == false)) {
                            continue;
                        }

                        String policyId = (String) meta.get(SnapshotsService.POLICY_ID_METADATA_FIELD);
                        inProgress.put(policyId, SnapshotLifecyclePolicyItem.SnapshotInProgress.fromEntry(entry));
                    }
                }
            }

            final Set<String> ids = new HashSet<>(Arrays.asList(request.getLifecycleIds()));
            final SnapshotLifecycleStats slmStats = snapMeta.getStats();
            List<SnapshotLifecyclePolicyItem> lifecycles = snapMeta.getSnapshotConfigurations().values().stream().filter(meta -> {
                if (ids.isEmpty()) {
                    return true;
                } else {
                    return ids.contains(meta.getPolicy().getId());
                }
            })
                .map(
                    policyMeta -> new SnapshotLifecyclePolicyItem(
                        policyMeta,
                        inProgress.get(policyMeta.getPolicy().getId()),
                        slmStats.getMetrics().get(policyMeta.getPolicy().getId())
                    )
                )
                .collect(Collectors.toList());
            if (lifecycles.size() == 0) {
                if (request.getLifecycleIds().length == 0) {
                    listener.onResponse(new GetSnapshotLifecycleAction.Response(Collections.emptyList()));
                } else {
                    listener.onFailure(
                        new ResourceNotFoundException(
                            "snapshot lifecycle policy or policies {} not found",
                            Arrays.toString(request.getLifecycleIds())
                        )
                    );
                }
            } else {
                listener.onResponse(new GetSnapshotLifecycleAction.Response(lifecycles));
            }
        }
    }

    @Override
    protected ClusterBlockException checkBlock(GetSnapshotLifecycleAction.Request request, ClusterState state) {
        return state.blocks().globalBlockedException(ClusterBlockLevel.METADATA_READ);
    }
}


text:
/**
 * @author Vadim L. Bogdanov
 * @version $Revision$
 */

package javax.swing.plaf.basic;

import java.awt.Color;
import java.awt.Component;
import java.awt.Container;
import java.awt.Dimension;
import java.awt.FontMetrics;
import java.awt.Graphics;
import java.awt.LayoutManager;
import java.awt.Rectangle;

import java.awt.event.ActionEvent;
import java.awt.event.HierarchyEvent;
import java.awt.event.HierarchyListener;

import java.beans.PropertyChangeEvent;
import java.beans.PropertyChangeListener;
import java.beans.PropertyVetoException;

import javax.swing.AbstractAction;
import javax.swing.Action;
import javax.swing.BorderFactory;
import javax.swing.Icon;
import javax.swing.JButton;
import javax.swing.JComponent;
import javax.swing.JInternalFrame;
import javax.swing.JMenu;
import javax.swing.JMenuBar;
import javax.swing.SwingConstants;
import javax.swing.SwingUtilities;
import javax.swing.UIManager;

import javax.swing.border.EmptyBorder;
import javax.swing.event.InternalFrameEvent;
import javax.swing.event.InternalFrameListener;

import org.apache.harmony.x.swing.StringConstants;
import org.apache.harmony.x.swing.TitlePaneInternals;
import org.apache.harmony.x.swing.Utilities;

public class BasicInternalFrameTitlePane extends JComponent {

    public class CloseAction extends AbstractAction {
        public CloseAction() {
            putValue(SHORT_DESCRIPTION, closeTooltipText);
            putValue(SMALL_ICON, closeIcon);
        }

        public void actionPerformed(final ActionEvent e) {
            if (frame.isClosable()) {
                try {
                    frame.setClosed(true);
                } catch (final PropertyVetoException v) {
                }
            }
        }
    }

    public class IconifyAction extends AbstractAction {
        public IconifyAction() {
            putValue(SHORT_DESCRIPTION, minimizeTooltipText);
            putValue(SMALL_ICON, iconIcon);
        }

        public void actionPerformed(final ActionEvent e) {
            if (frame.isIconifiable()) {
                try {
                    frame.setIcon(true);
                } catch (final PropertyVetoException v) {
                }
            }
        }
    }

    public class MaximizeAction extends AbstractAction {
        public MaximizeAction() {
            putValue(SHORT_DESCRIPTION, maximizeTooltipText);
            putValue(SMALL_ICON, maxIcon);
        }

        public void actionPerformed(final ActionEvent e) {
            if (frame.isMaximizable()) {
                try {
                    if (frame.isIcon()) {
                        frame.setIcon(false);
                    }
                    frame.setMaximum(true);
                } catch (final PropertyVetoException v) {
                }
            }
        }
    }

    public class RestoreAction extends AbstractAction {
        public RestoreAction() {
            putValue(SHORT_DESCRIPTION, restoreTooltipText);
            putValue(SMALL_ICON, minIcon);
        }

        public void actionPerformed(final ActionEvent e) {
            if (frame.isIcon()) {
                if (frame.isIconifiable()) {
                    try {
                        frame.setIcon(false);
                    } catch (final PropertyVetoException v) {
                    }
                }
            } else if (frame.isMaximum()) {
                if (frame.isMaximizable()) {
                    try {
                        frame.setMaximum(false);
                    } catch (final PropertyVetoException v) {
                    }
                }
            }
        }
    }

    public class MoveAction extends AbstractAction {
        private static final String MOVE_ACTION_NAME = "Move";

        public MoveAction() {
            putValue(Action.NAME, MOVE_ACTION_NAME);
        }

        public void actionPerformed(final ActionEvent e) {
            if (e == null) {
                return;
            }

            ((BasicDesktopPaneUI)frame.getDesktopPane().getUI()).
                frameOperation = BasicDesktopPaneUI.DRAGGING;
        }
    }

    public class SizeAction extends AbstractAction {
        private static final String SIZE_ACTION_NAME = "Size";

        public SizeAction() {
            putValue(Action.NAME, SIZE_ACTION_NAME);
        }

        public void actionPerformed(final ActionEvent e) {
            if (e == null) {
                return;
            }
            ((BasicDesktopPaneUI)frame.getDesktopPane().getUI()).
                frameOperation = BasicDesktopPaneUI.RESIZING;
        }
    }

    public class PropertyChangeHandler implements PropertyChangeListener {
        public void propertyChange(final PropertyChangeEvent e) {
            // Note: could optimize work with buttons
            // may be we should always do the same work (update buttons,
            // enableActions, etc.)?
            if (JInternalFrame.IS_MAXIMUM_PROPERTY.equals(e.getPropertyName())
                || JInternalFrame.IS_ICON_PROPERTY.equals(e.getPropertyName())) {
                setButtonIcons();
                enableActions();
            } else if (e.getPropertyName().
                    equals(StringConstants.INTERNAL_FRAME_ICONABLE_PROPERTY)) {
                updateButton(iconButton, frame.isIconifiable());
            } else if (e.getPropertyName().
                    equals(StringConstants.INTERNAL_FRAME_MAXIMIZABLE_PROPERTY)) {
                updateButton(maxButton, frame.isMaximizable());
            } else if (e.getPropertyName().
                    equals(StringConstants.INTERNAL_FRAME_CLOSABLE_PROPERTY)) {
                updateButton(closeButton, frame.isClosable());
            } else if (e.getPropertyName().
                    equals(StringConstants.INTERNAL_FRAME_RESIZABLE_PROPERTY)) {
                enableActions();
            } else if (e.getPropertyName().equals("ancestor")) {
                // to enable sizeAction, moveAction
                enableActions();
                revalidate();
            } else if (JInternalFrame.FRAME_ICON_PROPERTY.
                    equals(e.getPropertyName())) {
                internals.setFrameIcon(frame.getFrameIcon());
                revalidate();
                repaint();
            } else if (JInternalFrame.TITLE_PROPERTY.
                    equals(e.getPropertyName())) {
                revalidate();
                repaint();
            }
        }

        private void updateButton(final JButton button, final boolean add) {
            if (add) {
                add(button);
            } else {
                remove(button);
            }
            enableActions();
            revalidate();
            repaint();
        }
    }

    public class SystemMenuBar extends JMenuBar {
        public SystemMenuBar() {
            setFocusable(false);
            setBorder(new EmptyBorder(0, 0, 0, 0));
        }

        public void paint(final Graphics g) {
            paintChildren(g);
        }
    }

    public class TitlePaneLayout implements LayoutManager {
        public Dimension preferredLayoutSize(final Container c) {
            return minimumLayoutSize(c);
        }

        public Dimension minimumLayoutSize(final Container c) {
            Dimension size = Utilities.getCompoundLabelSize(
                BasicInternalFrameTitlePane.this,
                getMinimumString(internals.getWindowTitle()),
                internals.getFrameIcon(),
                SwingConstants.LEFT,
                SwingConstants.LEFT,
                internals.gapX
                );

            if (closeButton.getParent() == BasicInternalFrameTitlePane.this) {
                size.width += internals.gapX + closeIcon.getIconWidth();
            }
            if (maxButton.getParent() == BasicInternalFrameTitlePane.this) {
                size.width += internals.gapX + maxIcon.getIconWidth();
            }
            if (iconButton.getParent() == BasicInternalFrameTitlePane.this) {
                size.width += internals.gapX + iconIcon.getIconWidth();
            }

            size.width += 2 * internals.gapX;

            return Utilities.addInsets(size, BasicInternalFrameTitlePane.this
                    .getInsets());
        }

        private String getMinimumString(final String str) {
            if (str == null) {
                return "";
            }
            return str.substring(0, Math.min(3, str.length())) + "...";
        }

        public void addLayoutComponent(final String name, final Component c) {
        }

        public void layoutContainer(final Container c) {
            final int width = internals.getUIFrameIcon().getIconWidth();
            final int height = internals.getUIFrameIcon().getIconHeight();

            Rectangle inner = SwingUtilities.calculateInnerArea(
                BasicInternalFrameTitlePane.this, null);
            int y = inner.y + (inner.height - height) / 2;
            boolean isLTR = getComponentOrientation().isLeftToRight();
            int buttonOffsetX = isLTR ? getWidth() : -width;
            int sign = isLTR ? 1 : -1;
            Rectangle buttonBounds = new Rectangle(buttonOffsetX, y, width, height);

            // calculate bounds of closeButton
            if (closeButton.getParent() == BasicInternalFrameTitlePane.this) {
                buttonBounds.x -= sign * (width + internals.gapX);
                closeButton.setBounds(buttonBounds);
            }

            // calculate bounds of maxButton
            if (maxButton.getParent() == BasicInternalFrameTitlePane.this) {
                buttonBounds.x -= sign * (width + internals.gapX);
                maxButton.setBounds(buttonBounds);
            }

            // calculate bounds of iconButton
            if (iconButton.getParent() == BasicInternalFrameTitlePane.this) {
                buttonBounds.x -= sign * (width + internals.gapX);
                iconButton.setBounds(buttonBounds);
            }

            int iconTextOffsetX = isLTR ? internals.gapX
                    : buttonBounds.x + width + internals.gapX;
            int reminderWidth = isLTR ? buttonBounds.x - 2 * internals.gapX
                    : getWidth() - iconTextOffsetX - internals.gapX;
            Rectangle viewR = new Rectangle(iconTextOffsetX, 0, reminderWidth, getHeight());

            paintedTitle = layoutCompoundLabel(BasicInternalFrameTitlePane.this,
                internals.getWindowTitle(),
                internals.hasMenuBar ? internals.getFrameIcon() : null,
                viewR,
                menuBarBounds,
                textR);
            if (menuBar != null) {
                menuBar.setBounds(menuBarBounds);
            }

            // calculate bounds of possible decoration
            if (internals.decorationR != null) {
                int decorX = isLTR ? textR.x + textR.width + internals.gapX
                        : buttonBounds.x + width + internals.gapX;
                int decorWidth = isLTR ? viewR.x + viewR.width - decorX
                        : textR.x - viewR.x - internals.gapX;

                internals.decorationR.setBounds(decorX, textR.y,  decorWidth, textR.height);
            }
        }

        private String layoutCompoundLabel(final JComponent c,
                                           final String text,
                                           final Icon icon,
                                           final Rectangle viewR,
                                           final Rectangle iconR,
                                           final Rectangle textR) {
            boolean isEmptyTitle = Utilities.isEmptyString(text);
            String fixedText = isEmptyTitle ? " ": text;

            String result = SwingUtilities.layoutCompoundLabel(c,
                Utilities.getFontMetrics(c),
                fixedText,
                icon,
                SwingConstants.CENTER,
                SwingConstants.LEADING,
                SwingConstants.CENTER,
                SwingConstants.TRAILING,
                viewR,
                iconR,
                textR,
                internals.gapX
            );

            if (isEmptyTitle) {
                result = "";
                textR.width = -internals.gapX;
            }
            return result;
        }

        public void removeLayoutComponent(final Component comp) {
        }
    }

    protected static final String ICONIFY_CMD = "Iconify";
    protected static final String MAXIMIZE_CMD = "Maximize";
    protected static final String RESTORE_CMD = "Restore";
    protected static final String CLOSE_CMD = "Close";
    protected static final String MOVE_CMD = "Move";
    protected static final String SIZE_CMD = "Size";

    protected JMenuBar menuBar;
    protected JMenu windowMenu;
    protected JInternalFrame frame;

    protected Color selectedTitleColor;
    protected Color notSelectedTitleColor;
    protected Color selectedTextColor;
    protected Color notSelectedTextColor;

    protected JButton iconButton;
    protected JButton maxButton;
    protected JButton closeButton;

    protected Icon iconIcon;
    protected Icon maxIcon;
    protected Icon minIcon;
    protected Icon closeIcon;

    protected Action iconifyAction;
    protected Action maximizeAction;
    protected Action restoreAction;
    protected Action closeAction;
    protected Action moveAction;
    protected Action sizeAction;

    protected PropertyChangeListener propertyChangeListener;

    // tooltips text
    private String maximizeTooltipText;
    private String minimizeTooltipText;
    private String closeTooltipText;
    private String restoreTooltipText;

    // system menu items text
    private String closeButtonText;
    private String maxButtonText;
    private String minButtonText;
    private String moveButtonText;
    private String restoreButtonText;
    private String sizeButtonText;

    private String paintedTitle;
    private Rectangle textR = new Rectangle();
    private Rectangle menuBarBounds = new Rectangle();

    private TitlePaneInternals internals;

    public BasicInternalFrameTitlePane(final JInternalFrame frame) {
        if (frame == null) {
            throw new NullPointerException();
        }

        this.frame = frame;
        setBorder(BorderFactory.createEmptyBorder(1, 0, 1, 0));
        installInternals();
        installTitlePane();
    }

    protected JMenuBar createSystemMenuBar() {
        return new SystemMenuBar();
    }

    protected void assembleSystemMenu() {
        windowMenu = createSystemMenu();
        internals.setWindowMenu(windowMenu);
        addSystemMenuItems(windowMenu);

        menuBar = createSystemMenuBar();
        menuBar.add(windowMenu);
    }

    protected void addSystemMenuItems(final JMenu menu) {
        menu.add(TitlePaneInternals.createMenuItem(restoreAction,
                                                   restoreButtonText, 'R'));
        menu.add(TitlePaneInternals.createMenuItem(moveAction,
                                                   moveButtonText, 'M'));
        menu.add(TitlePaneInternals.createMenuItem(sizeAction,
                                                   sizeButtonText, 'S'));
        menu.add(TitlePaneInternals.createMenuItem(iconifyAction,
                                                   minButtonText, 'N'));
        menu.add(TitlePaneInternals.createMenuItem(maximizeAction,
                                                   maxButtonText, 'X'));

        menu.addSeparator();
        menu.add(TitlePaneInternals.createMenuItem(closeAction,
                                                   closeButtonText, 'C'));
    }

    protected JMenu createSystemMenu() {
        JMenu menu = new JMenu();
        menu.setBorder(new EmptyBorder(0, 0, 0, 0));
        menu.setOpaque(false);
        return menu;
    }

    protected void postClosingEvent(final JInternalFrame frame) {
        // this method seems to be unused
        Object[] listeners = frame.getListeners(InternalFrameListener.class);
        InternalFrameEvent e = null;

        for (int i = 0; i < listeners.length; i++) {
            if (e == null) {
                e = new InternalFrameEvent(
                    frame, InternalFrameEvent.INTERNAL_FRAME_CLOSING);
            }
            ((InternalFrameListener)listeners[i]).internalFrameClosing(e);
        }
    }

    protected PropertyChangeListener createPropertyChangeListener() {
        return new PropertyChangeHandler();
    }

    protected LayoutManager createLayout() {
        return new TitlePaneLayout();
    }

    protected String getTitle(final String text, final FontMetrics fm,
                              final int availableWidth) {
        return Utilities.clipString(fm, text, availableWidth);
    }

    protected void paintTitleBackground(final Graphics g) {
        g.setColor(internals.isSelected()
                   ? selectedTitleColor
                   : notSelectedTitleColor);
        g.fillRect(0, 0, getWidth(), getHeight());
    }

    public void paintComponent(final Graphics g) {
        paintTitleBackground(g);

        if (menuBar == null) {
            Icon frameIcon = internals.getFrameIcon();
            if (frameIcon != null) {
                frameIcon.paintIcon(this, g, menuBarBounds.x, menuBarBounds.y);
            }
        }

        g.setColor(internals.isSelected()
                   ? selectedTextColor
                   : notSelectedTextColor);

        FontMetrics fm = getFontMetrics(g.getFont());
        g.drawString(paintedTitle, textR.x,
                     Utilities.getTextY(fm, textR));
    }

    protected void installListeners() {
        if (propertyChangeListener == null) {
            propertyChangeListener = createPropertyChangeListener();
        }
        frame.addPropertyChangeListener(propertyChangeListener);

        // propertyChangeListener will be uninstalled
        // when title pane is removed from internal frame
        addHierarchyListener(new HierarchyListener() {
            public void hierarchyChanged(final HierarchyEvent e) {
                if (e.getChanged() == BasicInternalFrameTitlePane.this
                        && (e.getChangeFlags() & HierarchyEvent.PARENT_CHANGED) != 0
                        && !frame.isAncestorOf(BasicInternalFrameTitlePane.this)) {
                    uninstallListeners();
                }
            }
        });
    }

    protected void uninstallListeners() {
        // Warning: there is no method like uninstallTitlePane(); this method
        // is called directly from HierarchyListener.hierarchyChanged();
        frame.removePropertyChangeListener(propertyChangeListener);
    }

    protected void installDefaults() {
        // tooltips
        maximizeTooltipText = UIManager.getString(
                "InternalFrame.maxButtonToolTip");
        minimizeTooltipText = UIManager.getString(
                "InternalFrame.iconButtonToolTip");
        closeTooltipText = UIManager.getString(
                "InternalFrame.closeButtonToolTip");
        restoreTooltipText = UIManager.getString(
                "InternalFrame.restoreButtonToolTip");

        // window menu labels
        closeButtonText = UIManager.getString(
                "InternalFrameTitlePane.closeButtonText");
        maxButtonText = UIManager.getString(
                "InternalFrameTitlePane.maximizeButtonText");
        minButtonText = UIManager.getString(
                "InternalFrameTitlePane.minimizeButtonText");
        moveButtonText = UIManager.getString(
                "InternalFrameTitlePane.moveButtonText");
        restoreButtonText = UIManager.getString(
                "InternalFrameTitlePane.restoreButtonText");
        sizeButtonText = UIManager.getString(
                "InternalFrameTitlePane.sizeButtonText");

        // icons
        closeIcon = UIManager.getIcon("InternalFrame.closeIcon");
        maxIcon = UIManager.getIcon("InternalFrame.maximizeIcon");
        minIcon = UIManager.getIcon("InternalFrame.minimizeIcon");
        iconIcon = UIManager.getIcon("InternalFrame.iconifyIcon");
        // "InternalFrame.icon" is loaded in BasicInternalFrameUI

        // colors
        selectedTitleColor =
            UIManager.getColor("InternalFrame.activeTitleBackground");
        selectedTextColor =
            UIManager.getColor("InternalFrame.activeTitleForeground");
        notSelectedTitleColor =
            UIManager.getColor("InternalFrame.inactiveTitleBackground");
        notSelectedTextColor =
            UIManager.getColor("InternalFrame.inactiveTitleForeground");

        // font
        setFont(UIManager.getFont("InternalFrame.titleFont"));
    }

    protected void uninstallDefaults() {
        // there is no need to uninstall anything because
        // the title pane is replaced while changing L&F
    }

    /**
     * This function is used in
     * <code>BasicInternalFrameUI.installKeyboardActions</code> to implement
     * menu opening with keyboard.
     */
    protected void showSystemMenu() {
        windowMenu.doClick(0);
    }

    protected void setButtonIcons() {
        if (frame.isIcon()) {
            iconButton.setAction(restoreAction);
        } else {
            iconButton.setAction(iconifyAction);
        }

        if (frame.isMaximum() && !frame.isIcon()) {
            maxButton.setAction(restoreAction);
        } else {
            maxButton.setAction(maximizeAction);
        }
    }

    protected void installTitlePane() {
        installDefaults();
        installListeners();
        createActions();
        setLayout(createLayout());
        createButtons();
        assembleSystemMenu();
        addSubComponents();
        enableActions();
    }

    protected void enableActions() {
        iconifyAction.setEnabled(!frame.isIcon() && frame.isIconifiable());
        closeAction.setEnabled(frame.isClosable());
        maximizeAction.setEnabled(frame.isMaximizable()
                                  && (!frame.isMaximum()
                                      || frame.isIcon()
                                      && frame.isIconifiable()));

        restoreAction.setEnabled(frame.isMaximum() && frame.isMaximizable()
                                 || frame.isIcon() && frame.isIconifiable());

        moveAction.setEnabled(frame.getDesktopPane() != null
            && !frame.isMaximum()
            && frame.getDesktopPane().getUI() instanceof BasicDesktopPaneUI);

        sizeAction.setEnabled(moveAction.isEnabled()
                              && frame.isResizable() && !frame.isIcon());
    }

    protected void createButtons() {
        maxButton = createTitlePaneButton(maximizeAction);
        iconButton = createTitlePaneButton(iconifyAction);
        closeButton = createTitlePaneButton(closeAction);

        setButtonIcons();
    }

    private JButton createTitlePaneButton(final Action action) {
        JButton button = new JButton(action);
        button.setFocusable(false);
        return button;
    }

    protected void createActions() {
        closeAction = new CloseAction();
        iconifyAction = new IconifyAction();
        maximizeAction = new MaximizeAction();
        moveAction = new MoveAction();
        restoreAction = new RestoreAction();
        sizeAction = new SizeAction();
    }

    protected void addSubComponents() {
        if (menuBar != null) {
            add(menuBar);
        }

        if (frame.isIconifiable()) {
            add(iconButton);
        }
        if (frame.isMaximizable()) {
            add(maxButton);
        }
        if (frame.isClosable()) {
            add(closeButton);
        }
    }

    private void installInternals() {
        internals = new TitlePaneInternals(frame);
        putClientProperty("internals", internals);
    }
}


text:
package net.automatalib.commons.util;

import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.File;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.io.OutputStreamWriter;
import java.io.Reader;
import java.io.Writer;
import java.nio.charset.StandardCharsets;
import java.nio.file.Files;
import java.util.zip.GZIPInputStream;

import com.google.common.base.Preconditions;
import net.automatalib.commons.util.io.NonClosingInputStream;
import net.automatalib.commons.util.io.NonClosingOutputStream;

/**
 * Utility methods for operating with {@code java.io.*} classes.
 *
 * @author Malte Isberner
 */
public final class IOUtil {

    private IOUtil() {
        // prevent instantiation
    }

    /**
     * Ensures that the returned stream is an uncompressed version of the supplied input stream.
     *

     * This method first tries to read the first two bytes from the stream, then resets the stream. If the first two
     * bytes equal the GZip magic number (see {@link GZIPInputStream#GZIP_MAGIC}), the supplied stream is wrapped in a
     * {@link GZIPInputStream}. Otherwise, the stream is returned as-is.
     *

     * Note: this requires the input stream to {@link InputStream#markSupported() support marking}.
     *
     * @param is
     *         the input stream
     *
     * @return an uncompressed version of {@code is}
     *
     * @throws IOException
     *         if reading the magic number fails
     * @throws IllegalArgumentException
     *         if the stream does not support {@link InputStream#markSupported() marking}
     */
    public static InputStream asUncompressedInputStream(InputStream is) throws IOException {
        Preconditions.checkArgument(is.markSupported(), "input stream must support marking");

        is.mark(2);
        byte[] buf = new byte[2];
        int bytesRead;
        try {
            bytesRead = is.read(buf);
        } finally {
            is.reset();
        }
        if (bytesRead == 2) {
            final int byteMask = 0xff;
            final int byteWidth = 8;
            int magic = (buf[1] & byteMask) << byteWidth | (buf[0] & byteMask);
            if (magic == GZIPInputStream.GZIP_MAGIC) {
                return new GZIPInputStream(is);
            }
        }
        return is;
    }

    /**
     * Ensures that the returned stream is a buffered version of the supplied input stream. The result must not
     * necessarily be an instance of {@link BufferedInputStream}, it can also be, e.g., a {@link ByteArrayInputStream},
     * depending on the type of the supplied input stream.
     *
     * @param is
     *         the input stream
     *
     * @return a buffered version of {@code is}
     */
    public static InputStream asBufferedInputStream(InputStream is) {
        if (isBufferedInputStream(is)) {
            return is;
        }
        return new BufferedInputStream(is);
    }

    /**
     * Returns an input stream that reads the contents of the given file. Additionally buffers the input stream to
     * improve performance.
     *
     * @param file
     *         the file to read
     *
     * @return a buffered input stream for the file contents
     *
     * @throws IOException
     *         if accessing the file results in an I/O error
     */
    public static InputStream asBufferedInputStream(File file) throws IOException {
        return asBufferedInputStream(Files.newInputStream(file.toPath()));
    }

    /**
     * Ensures that the returned stream is a buffered version of the supplied output stream. The result must not
     * necessarily be an instance of {@link BufferedOutputStream}, it can also be, e.g., a
     * {@link ByteArrayOutputStream}, depending on the type of the supplied output stream.
     *
     * @param os
     *         the output stream
     *
     * @return a buffered version of {@code os}
     */
    public static OutputStream asBufferedOutputStream(OutputStream os) {
        if (isBufferedOutputStream(os)) {
            return os;
        }
        return new BufferedOutputStream(os);
    }

    /**
     * Returns an output stream that writes the contents to the given file. Additionally buffers the input stream to
     * improve performance.
     *
     * @param file
     *         the file to write to
     *
     * @return a buffered output stream for the file contents
     *
     * @throws IOException
     *         if accessing the file results in an I/O error
     */
    public static OutputStream asBufferedOutputStream(File file) throws IOException {
        return asBufferedOutputStream(Files.newOutputStream(file.toPath()));
    }

    /**
     * Returns a reader that parses the contents of the given file with {@link StandardCharsets#UTF_8} encoding.
     * Additionally buffers the input stream to improve performance.
     *
     * @param file
     *         the file to read
     *
     * @return a buffered, UTF-8-decoding reader for the file contents
     *
     * @throws IOException
     *         if accessing the file results in an I/O error
     */
    public static Reader asBufferedUTF8Reader(final File file) throws IOException {
        return Files.newBufferedReader(file.toPath(), StandardCharsets.UTF_8);
    }

    /**
     * Returns a reader that parses the contents of the given input stream with {@link StandardCharsets#UTF_8} encoding.
     * If the given input stream is not already a buffering input stream, additionally buffers the input stream to
     * improve performance.
     *

     * Implementation note: the input stream (byte-wise representation) will be buffered, not the reader (character-wise
     * representation).
     *
     * @param is
     *         the input stream to read
     *
     * @return a buffered, UTF-8-decoding reader for the input stream.
     */
    public static Reader asBufferedUTF8Reader(final InputStream is) {
        return asUTF8Reader(asBufferedInputStream(is));
    }

    /**
     * Returns a reader that parses the contents of the given input stream with {@link StandardCharsets#UTF_8} encoding.
     *
     * @param is
     *         the input stream to read
     *
     * @return a UTF-8-decoding reader for the input stream
     */
    public static Reader asUTF8Reader(final InputStream is) {
        return new InputStreamReader(is, StandardCharsets.UTF_8);
    }

    /**
     * Returns a writer that writes contents to the given file with {@link StandardCharsets#UTF_8} encoding.
     * Additionally buffers the input stream to improve performance.
     *
     * @param file
     *         the file to write to
     *
     * @return a buffered, UTF-8-encoding writer for the file contents
     *
     * @throws IOException
     *         if writing to the file results in I/O errors
     */
    public static Writer asBufferedUTF8Writer(final File file) throws IOException {
        return Files.newBufferedWriter(file.toPath(), StandardCharsets.UTF_8);
    }

    /**
     * Returns a writer that writes contents to the given output stream with {@link StandardCharsets#UTF_8} encoding. If
     * the given output stream is not already a buffering output stream, additionally buffers the output stream to
     * improve performance.
     *

     * Implementation note: the output stream (byte-wise representation) will be buffered, not the writer (character-
     * wise representation).
     *
     * @param os
     *         the output stream to write to
     *
     * @return a buffered, UTF-8 encoding writer for the output stream
     */
    public static Writer asBufferedUTF8Writer(final OutputStream os) {
        return asUTF8Writer(asBufferedOutputStream(os));
    }

    /**
     * Returns a writer that writes contents to the given output stream with {@link StandardCharsets#UTF_8} encoding.
     *
     * @param os
     *         the output stream to write to
     *
     * @return a UTF-8-encoding writer for the output stream.
     */
    public static Writer asUTF8Writer(final OutputStream os) {
        return new OutputStreamWriter(os, StandardCharsets.UTF_8);
    }

    /**
     * Returns a buffered input stream that de-compresses the contents of {@code is} (in case the given input stream
     * contains gzip'ed content) and does not propagate calls to {@link InputStream#close()} to the passed {@code is}.
     *
     * @param is
     *         the input stream to read
     *
     * @return a (potentially) de-compressing, buffered, non-closing version of {@code is}
     *
     * @throws IOException
     *         if reading the stream (for detecting whether it contains compressed contents) fails
     * @see NonClosingInputStream
     * @see #asBufferedInputStream(InputStream)
     * @see #asUncompressedInputStream(InputStream)
     */
    public static InputStream asUncompressedBufferedNonClosingInputStream(InputStream is) throws IOException {
        if (isBufferedInputStream(is)) {
            return asUncompressedInputStream(new NonClosingInputStream(is));
        }

        // inverse chaining so that calls to #close can clear the buffers
        return asUncompressedInputStream(asBufferedInputStream(new NonClosingInputStream(is)));
    }

    /**
     * Returns a buffered reader that un-compresses the contents of {@code is} (in case the given input stream contains
     * gzip'ed content), does not propagate calls to {@link Reader#close()} to the passed {@code is} and parses the
     * contents of the given input stream with {@link StandardCharsets#UTF_8} encoding.
     *

     * Implementation note: the input stream (byte-wise representation) will be buffered, not the reader (character-wise
     * representation).
     *
     * @param is
     *         the input stream to read
     *
     * @return a (potentially) de-compressing, buffered, non-closing, UTF-8-decoding version of {@code is}
     *
     * @throws IOException
     *         if reading the stream (for detecting whether it contains compressed contents) fails
     * @see #asUTF8Reader(InputStream)
     * @see #asUncompressedBufferedNonClosingInputStream(InputStream)
     */
    public static Reader asUncompressedBufferedNonClosingUTF8Reader(final InputStream is) throws IOException {
        return asUTF8Reader(asUncompressedBufferedNonClosingInputStream(is));
    }

    /**
     * Returns a buffered output stream that does not propagate calls to {@link OutputStream#close()} to the passed
     * {@code os}.
     *
     * @param os
     *         the output stream to write to
     *
     * @return a buffered, non-closing version of {@code os}
     *
     * @see #asBufferedOutputStream(OutputStream)
     * @see NonClosingOutputStream
     */
    public static OutputStream asBufferedNonClosingOutputStream(OutputStream os) {
        if (isBufferedOutputStream(os)) {
            return new NonClosingOutputStream(os);
        }

        // inverse chaining so that calls to #close can clear the buffers
        return asBufferedOutputStream(new NonClosingOutputStream(os));
    }

    /**
     * Returns a writer that writes contents to the given output stream with {@link StandardCharsets#UTF_8} encoding and
     * does not propagate calls to {@link Writer#close()} to the passed {@code os}.
     *

     * Implementation note: the output stream (byte-wise representation) will be buffered, not the writer (character-
     * wise representation).
     *
     * @param os
     *         the output stream to write to
     *
     * @return a buffered, non-closing, UTF-8-encoding writer for the output stream
     *
     * @see #asBufferedNonClosingOutputStream(OutputStream)
     * @see #asUTF8Writer(OutputStream)
     */
    public static Writer asBufferedNonClosingUTF8Writer(final OutputStream os) {
        return asUTF8Writer(asBufferedNonClosingOutputStream(os));
    }

    private static boolean isBufferedInputStream(InputStream is) {
        return is instanceof BufferedInputStream || is instanceof ByteArrayInputStream;
    }

    private static boolean isBufferedOutputStream(OutputStream os) {
        return os instanceof BufferedOutputStream || os instanceof ByteArrayOutputStream;
    }
}


text:
package gitea // import "code.gitea.io/sdk/gitea"
import (
	"bytes"
	"encoding/json"
	"fmt"
	"io"
	"mime/multipart"
	"net/http"

	"code.gitea.io/gitea/modules/structs"
)

// Attachment is equal to structs.Attachment
type Attachment = structs.Attachment

// ListReleaseAttachments list release's attachments
func (c *Client) ListReleaseAttachments(user, repo string, release int64) ([]*Attachment, error) {
	attachments := make([]*Attachment, 0, 10)
	err := c.getParsedResponse("GET",
		fmt.Sprintf("/repos/%s/%s/releases/%d/assets", user, repo, release),
		nil, nil, &attachments)
	return attachments, err
}

// GetReleaseAttachment returns the requested attachment
func (c *Client) GetReleaseAttachment(user, repo string, release int64, id int64) (*Attachment, error) {
	a := new(Attachment)
	err := c.getParsedResponse("GET",
		fmt.Sprintf("/repos/%s/%s/releases/%d/assets/%d", user, repo, release, id),
		nil, nil, &a)
	return a, err
}

// CreateReleaseAttachment creates an attachment for the given release
func (c *Client) CreateReleaseAttachment(user, repo string, release int64, file io.Reader, filename string) (*Attachment, error) {
	// Write file to body
	body := new(bytes.Buffer)
	writer := multipart.NewWriter(body)
	part, err := writer.CreateFormFile("attachment", filename)
	if err != nil {
		return nil, err
	}

	if _, err = io.Copy(part, file); err != nil {
		return nil, err
	}
	if err = writer.Close(); err != nil {
		return nil, err
	}

	// Send request
	attachment := new(Attachment)
	err = c.getParsedResponse("POST",
		fmt.Sprintf("/repos/%s/%s/releases/%d/assets", user, repo, release),
		http.Header{"Content-Type": {writer.FormDataContentType()}}, body, &attachment)
	return attachment, err
}

// EditReleaseAttachment updates the given attachment with the given options
func (c *Client) EditReleaseAttachment(user, repo string, release int64, attachment int64, form structs.EditAttachmentOptions) (*Attachment, error) {
	body, err := json.Marshal(&form)
	if err != nil {
		return nil, err
	}
	attach := new(Attachment)
	return attach, c.getParsedResponse("PATCH", fmt.Sprintf("/repos/%s/%s/releases/%d/assets/%d", user, repo, release, attachment), jsonHeader, bytes.NewReader(body), attach)
}

// DeleteReleaseAttachment deletes the given attachment including the uploaded file
func (c *Client) DeleteReleaseAttachment(user, repo string, release int64, id int64) error {
	_, err := c.getResponse("DELETE", fmt.Sprintf("/repos/%s/%s/releases/%d/assets/%d", user, repo, release, id), nil, nil)
	return err
}


text:
/*
 * Do not modify this file. This file is generated from the cloudtrail-2013-11-01.normal.json service model.
 */
using System;
using System.Collections.Generic;
using System.Xml.Serialization;
using System.Text;
using System.IO;

using Amazon.Runtime;
using Amazon.Runtime.Internal;

namespace Amazon.CloudTrail.Model
{
    /// <summary>
    /// Container for the parameters to the LookupEvents operation.
    /// Looks up API activity events captured by CloudTrail that create, update, or delete
    /// resources in your account. Events for a region can be looked up for the times in which
    /// you had CloudTrail turned on in that region during the last seven days. Lookup supports
    /// five different attributes: time range (defined by a start time and end time), user
    /// name, event name, resource type, and resource name. All attributes are optional. The
    /// maximum number of attributes that can be specified in any one lookup request are time
    /// range and one other attribute. The default number of results returned is 10, with
    /// a maximum of 50 possible. The response includes a token that you can use to get the
    /// next page of results. The rate of lookup requests is limited to one per second per
    /// account.
    ///
    ///  <important>Events that occurred during the selected time range will not be available
    /// for lookup if CloudTrail logging was not enabled when the events occurred.</important>
    /// </summary>
    public partial class LookupEventsRequest : AmazonCloudTrailRequest
    {
        private DateTime? _endTime;
        private List<LookupAttribute> _lookupAttributes = new List<LookupAttribute>();
        private int? _maxResults;
        private string _nextToken;
        private DateTime? _startTime;

        /// <summary>
        /// Gets and sets the property EndTime.
        /// <para>
        /// Specifies that only events that occur before or at the specified time are returned.
        /// If the specified end time is before the specified start time, an error is returned.
        /// </para>
        /// </summary>
        public DateTime EndTime
        {
            get { return this._endTime.GetValueOrDefault(); }
            set { this._endTime = value; }
        }

        // Check to see if EndTime property is set
        internal bool IsSetEndTime()
        {
            return this._endTime.HasValue;
        }

        /// <summary>
        /// Gets and sets the property LookupAttributes.
        /// <para>
        /// Contains a list of lookup attributes. Currently the list can contain only one item.
        /// </para>
        /// </summary>
        public List<LookupAttribute> LookupAttributes
        {
            get { return this._lookupAttributes; }
            set { this._lookupAttributes = value; }
        }

        // Check to see if LookupAttributes property is set
        internal bool IsSetLookupAttributes()
        {
            return this._lookupAttributes != null && this._lookupAttributes.Count > 0;
        }

        /// <summary>
        /// Gets and sets the property MaxResults.
        /// <para>
        /// The number of events to return. Possible values are 1 through 50. The default is 10.
        /// </para>
        /// </summary>
        public int MaxResults
        {
            get { return this._maxResults.GetValueOrDefault(); }
            set { this._maxResults = value; }
        }

        // Check to see if MaxResults property is set
        internal bool IsSetMaxResults()
        {
            return this._maxResults.HasValue;
        }

        /// <summary>
        /// Gets and sets the property NextToken.
        /// <para>
        /// The token to use to get the next page of results after a previous API call. This token
        /// must be passed in with the same parameters that were specified in the the original
        /// call. For example, if the original call specified an AttributeKey of 'Username' with
        /// a value of 'root', the call with NextToken should include those same parameters.
        /// </para>
        /// </summary>
        public string NextToken
        {
            get { return this._nextToken; }
            set { this._nextToken = value; }
        }

        // Check to see if NextToken property is set
        internal bool IsSetNextToken()
        {
            return this._nextToken != null;
        }

        /// <summary>
        /// Gets and sets the property StartTime.
        /// <para>
        /// Specifies that only events that occur after or at the specified time are returned.
        /// If the specified start time is after the specified end time, an error is returned.
        /// </para>
        /// </summary>
        public DateTime StartTime
        {
            get { return this._startTime.GetValueOrDefault(); }
            set { this._startTime = value; }
        }

        // Check to see if StartTime property is set
        internal bool IsSetStartTime()
        {
            return this._startTime.HasValue;
        }

    }
}


text:
package org.terasology.rendering.nui;

/**
 * @author Immortius
 */
public interface SubRegion extends AutoCloseable {

    void close();
}


text:
namespace rocksdb {

struct Options;
struct FileMetaData;

class Env;
struct EnvOptions;
class Iterator;
class SnapshotChecker;
class TableCache;
class VersionEdit;
class TableBuilder;
class WritableFileWriter;
class InternalStats;

// @param column_family_name Name of the column family that is also identified
//    by column_family_id, or empty string if unknown. It must outlive the
//    TableBuilder returned by this function.
TableBuilder* NewTableBuilder(
    const ImmutableCFOptions& options, const MutableCFOptions& moptions,
    const InternalKeyComparator& internal_comparator,
    const std::vector<std::unique_ptr<IntTblPropCollectorFactory>>*
        int_tbl_prop_collector_factories,
    uint32_t column_family_id, const std::string& column_family_name,
    WritableFileWriter* file, const CompressionType compression_type,
    const uint64_t sample_for_compression,
    const CompressionOptions& compression_opts, int level,
    const bool skip_filters = false, const uint64_t creation_time = 0,
    const uint64_t oldest_key_time = 0, const uint64_t target_file_size = 0,
    const uint64_t file_creation_time = 0);

// Build a Table file from the contents of *iter.  The generated file
// will be named according to number specified in meta. On success, the rest of
// *meta will be filled with metadata about the generated table.
// If no data is present in *iter, meta->file_size will be set to
// zero, and no Table file will be produced.
//
// @param column_family_name Name of the column family that is also identified
//    by column_family_id, or empty string if unknown.
extern Status BuildTable(
    const std::string& dbname, Env* env, const ImmutableCFOptions& options,
    const MutableCFOptions& mutable_cf_options, const EnvOptions& env_options,
    TableCache* table_cache, InternalIterator* iter,
    std::vector<std::unique_ptr<FragmentedRangeTombstoneIterator>>
        range_del_iters,
    FileMetaData* meta, const InternalKeyComparator& internal_comparator,
    const std::vector<std::unique_ptr<IntTblPropCollectorFactory>>*
        int_tbl_prop_collector_factories,
    uint32_t column_family_id, const std::string& column_family_name,
    std::vector<SequenceNumber> snapshots,
    SequenceNumber earliest_write_conflict_snapshot,
    SnapshotChecker* snapshot_checker, const CompressionType compression,
    const uint64_t sample_for_compression,
    const CompressionOptions& compression_opts, bool paranoid_file_checks,
    InternalStats* internal_stats, TableFileCreationReason reason,
    EventLogger* event_logger = nullptr, int job_id = 0,
    const Env::IOPriority io_priority = Env::IO_HIGH,
    TableProperties* table_properties = nullptr, int level = -1,
    const uint64_t creation_time = 0, const uint64_t oldest_key_time = 0,
    Env::WriteLifeTimeHint write_hint = Env::WLTH_NOT_SET,
    const uint64_t file_creation_time = 0);

}  // namespace rocksdb


text:
using System;
using System.Collections.Generic;
using System.Linq;
using System.Web;
using System.Web.UI;
using System.Web.UI.WebControls;
using DotNetNuke;
using DotNetNuke.UI.WebControls;
using DotNetNuke.Common;
using DotNetNuke.Security.Roles;
using DotNetNuke.Common.Utilities;
using DotNetNuke.UI.Skins.Controls;
using DotNetNuke.Services.Localization;
using DotNetNuke.Modules.Groups.Components;

namespace DotNetNuke.Modules.Groups
{
    public partial class GroupView : GroupsModuleBase
    {
        protected void Page_Load(object sender, EventArgs e)
        {

            RoleInfo role = RoleController.Instance.GetRole(PortalId, r => r.SecurityMode != SecurityMode.SecurityRole && r.RoleID == GroupId);
            if (role == null && GroupId > 0)
            {
                UI.Skins.Skin.AddModuleMessage(this, Localization.GetString("GroupIdNotFound", Constants.SharedResourcesPath), ModuleMessage.ModuleMessageType.YellowWarning);
            }

            if (role == null && (UserInfo.IsInRole(PortalSettings.AdministratorRoleName) || UserInfo.IsSuperUser))
            {
                role = new RoleInfo();
                role.RoleID = -1;
                role.RoleName = Localization.GetString("Sample_RoleName", LocalResourceFile);
                role.Description = Localization.GetString("Sample_RoleDescription", LocalResourceFile);

            }

            if (role == null)
                litOutput.Text = string.Empty;
            else
            {
                var resxPath = Constants.SharedResourcesPath;

                var template = GroupViewTemplate;
                template = template.Replace("{resx:posts}", Localization.GetString("posts", resxPath));
                template = template.Replace("{resx:members}", Localization.GetString("members", resxPath));
                template = template.Replace("{resx:photos}", Localization.GetString("photos", resxPath));
                template = template.Replace("{resx:documents}", Localization.GetString("documents", resxPath));

                template = template.Replace("{resx:Join}", Localization.GetString("Join", resxPath));
                template = template.Replace("{resx:JoinGroup}", Localization.GetString("JoinGroup", resxPath));
                template = template.Replace("{resx:Pending}", Localization.GetString("Pending", resxPath));
                template = template.Replace("{resx:LeaveGroup}", Localization.GetString("LeaveGroup", resxPath));
                template = template.Replace("{resx:EditGroup}", Localization.GetString("EditGroup", resxPath));
                template = template.Replace("[GroupViewTabId]", GroupViewTabId.ToString());

                var groupParser = new GroupViewParser(PortalSettings, role, UserInfo, template, TabId);
                groupParser.GroupEditUrl = GetEditUrl();

                litOutput.Text = groupParser.ParseView();

            }

        }
    }
}


text:
(function() {
    var view = {
        $noApprenticeshipsBlock: null,
        $apprenticeshipsBlock: null,
        $numberOfApprenticesLabel: null,
        $apprenticeshipsTableBody: null,

        load: function() {
            view.$noApprenticeshipsBlock = $('#no-apprenticeships');
            view.$apprenticeshipsBlock = $('#apprenticeships');
            view.$numberOfApprenticesLabel = $('#numberOfApprentices');
            view.$apprenticeshipsTableBody = $('#apprenticeships table > tbody');

        }
    };

    function showEmptyState() {
        $('#no-apprenticeships').removeClass('rj-dont-display');
        $('#apprenticeships').addClass('rj-dont-display');
    }
    function showApprenticeships(apprenticeships) {
        $('#no-apprenticeships').addClass('rj-dont-display');
        $('#apprenticeships').removeClass('rj-dont-display');

        // random global variable assignment - variable is used again later -  the copy in the training header.
        numberOfApps = apprenticeships.length;
        appsMoreThanOne = "";
        if (numberOfApps >= 2) {
            appsMoreThanOne ="s"} else {appsMoreThanOne=""};

        //end of robs random code

        view.$numberOfApprenticesLabel.text(apprenticeships.length);
        for(var i = 0; i < apprenticeships.length; i++) {
            var $tr = makeRow(apprenticeships[i]);
            view.$apprenticeshipsTableBody.append($tr);
        }
    }
    function makeRow(apprenticeship) {

        // changes heading, works when i put it in here
        var newCopy = apprenticeship.training.name;
        var x = document.getElementById("apprenticeReplaceMe");
        if(x) {
            x.innerHTML = numberOfApps + ' ' + newCopy + appsMoreThanOne;
        }

        var displayCost = apprenticeship.cost ? '£' + apprenticeship.cost.format(0) : 'TBD';
        var displayStart = apprenticeship.start.month ? apprenticeship.start.month + '/' + apprenticeship.start.year : 'unknown';
        var displayFinish = apprenticeship.finish.month ? apprenticeship.finish.month + '/' + apprenticeship.finish.year : 'unknown';

        var $tr = $('

');
        $tr.append(makeCell(apprenticeship.training.name));
        $tr.append(makeCell(apprenticeship.apprentice.first));
        $tr.append(makeCell(apprenticeship.apprentice.last));
        $tr.append(makeCell(apprenticeship.apprentice.uln));
        $tr.append(makeCell(displayStart));
        $tr.append(makeCell(displayFinish));
        $tr.append(makeCell(displayCost));
        $tr.append(makeActionCell(apprenticeship.id));
        return $tr;
    }
    function makeCell(text) {
        return $('	').text(text || 'unknown');
    }
    function makeActionCell(id) {
        var source = commitmentListSource || 'employer';

        var a = $('Edit');
        a.attr('href', '../provider-interface/add-apprenticeship?id=' + id + '&source=' + source);

        var td = $('	');
        td.append(a);

        return td;
    }

    $(document).ready(function() {
        console.log('load commitment list');
        view.load();

        var apprenticeships = window.das.commitments.getAll();
        if(apprenticeships.length > 0) {
            showApprenticeships(apprenticeships);
        }
        else {
            showEmptyState();
        }
    });

})();


text:
import Controller from '@ember/controller';
import { isBlank } from '@ember/utils';
import { A } from '@ember/array';
import { inject as service } from '@ember/service';

export default Controller.extend({
  spdx: service(),
  features: service(),

  setEvent(state) {
    if (state === 'registered') {
      return 'register';
    } else if (state === 'findable') {
      return 'publish';
    } else {
      return null;
    }
  },

  actions: {
    submit(doi) {
      doi.set('event', this.setEvent(doi.get('state')));

      // track use of the form
      doi.set('source', 'fabricaForm');

      // don't send xml
      doi.set('xml', null);

      // only store name identifiers and affiliations with a value
      A(doi.get('creators')).forEach((creator) => {
        creator.set('nameIdentifiers', A(creator.get('nameIdentifiers')).filter(function(nameIdentifier) {
          return !isBlank(nameIdentifier.nameIdentifier);
        }));
        creator.set('affiliation', A(creator.get('affiliation')).filter(function(affiliation) {
          return !isBlank(affiliation.name);
        }));
        if (creator.nameType === 'Organizational') {
          creator.set('givenName', null);
          creator.set('familyName', null);
        }
      });

      // only store titles with a title text
      doi.set('titles', A(doi.get('titles')).filter(function(title) {
        return !isBlank(title.title);
      }));

      // only store subject with a subject text
      doi.set('subjects', A(doi.get('subjects')).filter(function(subject) {
        return !isBlank(subject.subject);
      }));

      // only store name identifiers and affiliations for contributor with a value
      doi.set('contributors', A(doi.get('contributors')).filter(function(contributor) {
        let nameIdentifiers = A(contributor.get('nameIdentifiers')).filter(function(nameIdentifier) {
          return !isBlank(nameIdentifier.nameIdentifier);
        });
        let affiliation = A(contributor.get('affiliation')).filter(function(affiliation) {
          return !isBlank(affiliation.name);
        });

        let contributorType = !isBlank(contributor.contributorType) ? [ contributor.contributorType ] : [];

        return !isBlank(nameIdentifiers) || !isBlank(affiliation) || !isBlank(contributorType) || !isBlank(contributor.name);
      }));

      // only store dates with a text
      doi.set('dates', A(doi.get('dates')).filter(function(date) {
        return !isBlank(date.date) || !isBlank(date.dateType) || !isBlank(date.dateInformation);
      }));

      // only store related identifiers with a text
      doi.set('relatedIdentifiers', A(doi.get('relatedIdentifiers')).filter(function(identifier) {
        return !isBlank(identifier.relatedIdentifier) || !isBlank(identifier.relatedIdentifierType) || !isBlank(identifier.relationType) || !isBlank(identifier.relatedMetadataScheme) || !isBlank(identifier.resourceTypeGeneral);
      }));

      // only store descriptions with a description text
      doi.set('descriptions', A(doi.get('descriptions')).filter(function(description) {
        return !isBlank(description.description);
      }));

      doi.set('geoLocations', A(doi.get('geoLocations')).filter(function(geoLocation) {
        let point = isBlank(geoLocation.geoLocationPoint.pointLongitude) &&
          isBlank(geoLocation.geoLocationPoint.pointLatitude) ? [] : [ geoLocation.geoLocationPoint ];
        let box = isBlank(geoLocation.geoLocationBox.westBoundLongitude) &&
          isBlank(geoLocation.geoLocationBox.eastBoundLongitude) &&
          isBlank(geoLocation.geoLocationBox.southBoundLatitude) &&
          isBlank(geoLocation.geoLocationBox.northBoundLatitude) ? [] : [ geoLocation.geoLocationBox ];

        return !isBlank(geoLocation.geoLocationPlace) || !isBlank(point) || !isBlank(box);
      }));

      // only store identifiers with a  text
      doi.set('alternateIdentifiers', A(doi.get('alternateIdentifiers')).filter(function(alternateIdentifier) {
        return !isBlank(alternateIdentifier.identifier);
      }));

      // only store rights with a text
      doi.set('rightsList', A(doi.get('rightsList')).filter(function(rights) {
        return !isBlank(rights.rights);
      }));

      // only store sizes with a text
      doi.set('sizes', A(doi.get('sizes')).filter(function(size) {
        return !isBlank(size);
      }));

      // only store formats with a text
      doi.set('formats', A(doi.get('formats')).filter(function(format) {
        return !isBlank(format);
      }));

      // only store funding references with a text
      doi.set('fundingReferences', A(doi.get('fundingReferences')).filter(function(fundingReference) {
        return !isBlank(fundingReference.funderName) || !isBlank(fundingReference.funderIdentifier) || !isBlank(fundingReference.funderIdentifierType) || !isBlank(fundingReference.awardNumber) || !isBlank(fundingReference.awardTitle);
      }));

      let self = this;
      doi.save().then(function(doi) {
        self.transitionToRoute('dois.show', doi);
      }).catch(function(reason) {
        console.debug(reason);

        self.get('flashMessages').warning('An error occured and this DOI could not be saved.', { componentName: 'doi-error' });
      });
    },
    cancel() {
      this.transitionToRoute('repositories.show.dois', this.get('model.repository.id'));
    },
  },
});


text:
package ru.apermyakov.io.socket.manager;

import java.io.IOException;

/**
 * Interface to modulate client activity.
 *
 * @author apermyakov
 * @version 1.0
 * @since 27.12.2017
 */
public interface ClientInterface {

    /**
     * Method for initial client.
     */
    void initialClient() throws IOException;

    /**
     * Method for start client.
     */
    void startClient() throws IOException;
}


text:
<?xml version="1.0"?>
<view icon="13248" title="ZChatSystem" width="230" height="236">
		<control progid="DecalControls.FixedLayout" clipped="">
			<control progid="DecalControls.Notebook" name="Notebook1" left="0" top="0" width="232" height="208">
			<page label="Message">
				<control progid="DecalControls.FixedLayout" clipped="">
					<control progid="DecalControls.List" name="Message_List" left="0" top="0" width="232" height="188">
						<column progid="DecalControls.CheckColumn" fixedwidth="20"/>
						<column progid="DecalControls.TextColumn" fixedwidth="140"/>
						<column progid="DecalControls.IconColumn" fixedwidth="16"/>
						<column progid="DecalControls.IconColumn" fixedwidth="16"/>
					</control>
				</control>

			</page>
			<page label="Color">
				<control progid="DecalControls.FixedLayout" clipped="">
					<control progid="DecalControls.List" name="Color_List" left="0" top="0" width="232" height="188">
						<column progid="DecalControls.CheckColumn" fixedwidth="20"/>
						<column progid="DecalControls.TextColumn" fixedwidth="140"/>
						<column progid="DecalControls.IconColumn" fixedwidth="16"/>
						<column progid="DecalControls.IconColumn" fixedwidth="16"/>
					</control>
				</control>

			</page>
			<page label="Window">
				<control progid="DecalControls.FixedLayout" clipped="">
					<control progid="DecalControls.List" name="Window_List" left="0" top="0" width="232" height="188">
						<column progid="DecalControls.CheckColumn" fixedwidth="20"/>
						<column progid="DecalControls.TextColumn" fixedwidth="140"/>
						<column progid="DecalControls.IconColumn" fixedwidth="16"/>
						<column progid="DecalControls.IconColumn" fixedwidth="16"/>
					</control>
				</control>

			</page>
			</control>

		</control>

</view>


text:
package google_cloud_ml_v1beta1

import proto "github.com/gogo/protobuf/proto"
import fmt "fmt"
import math "math"
import _ "go.pedge.io/pb/gogo/google/api"
import _ "go.pedge.io/pb/gogo/google/api"
import _ "go.pedge.io/pb/gogo/google/longrunning"
import google_protobuf2 "github.com/gogo/protobuf/types"

// Reference imports to suppress errors if they are not otherwise used.
var _ = proto.Marshal
var _ = fmt.Errorf
var _ = math.Inf

// Represents a machine learning solution.
//
// A model can have multiple versions, each of which is a deployed, trained
// model ready to receive prediction requests. The model itself is just a
// container.
type Model struct {
	// Required. The name specified for the model when it was created.
	//
	// The model name must be unique within the project it is created in.
	Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
	// Optional. The description specified for the model when it was created.
	Description string `protobuf:"bytes,2,opt,name=description,proto3" json:"description,omitempty"`
	// Output only. The default version of the model. This version will be used to
	// handle prediction requests that do not specify a version.
	//
	// You can change the default version by calling
	// [projects.methods.versions.setDefault](/ml/reference/rest/v1beta1/projects.models.versions/setDefault).
	DefaultVersion *Version `protobuf:"bytes,3,opt,name=default_version,json=defaultVersion" json:"default_version,omitempty"`
	// Optional. The list of regions where the model is going to be deployed.
	// Currently only one region per model is supported.
	// Defaults to 'us-central1' if nothing is set.
	Regions []string `protobuf:"bytes,4,rep,name=regions" json:"regions,omitempty"`
	// Optional. If true, enables StackDriver Logging for online prediction.
	// Default is false.
	OnlinePredictionLogging bool `protobuf:"varint,5,opt,name=online_prediction_logging,json=onlinePredictionLogging,proto3" json:"online_prediction_logging,omitempty"`
}

func (m *Model) Reset()                    { *m = Model{} }
func (m *Model) String() string            { return proto.CompactTextString(m) }
func (*Model) ProtoMessage()               {}
func (*Model) Descriptor() ([]byte, []int) { return fileDescriptorModelService, []int{0} }

func (m *Model) GetName() string {
	if m != nil {
		return m.Name
	}
	return ""
}

func (m *Model) GetDescription() string {
	if m != nil {
		return m.Description
	}
	return ""
}

func (m *Model) GetDefaultVersion() *Version {
	if m != nil {
		return m.DefaultVersion
	}
	return nil
}

func (m *Model) GetRegions() []string {
	if m != nil {
		return m.Regions
	}
	return nil
}

func (m *Model) GetOnlinePredictionLogging() bool {
	if m != nil {
		return m.OnlinePredictionLogging
	}
	return false
}

// Represents a version of the model.
//
// Each version is a trained model deployed in the cloud, ready to handle
// prediction requests. A model can have multiple versions. You can get
// information about all of the versions of a given model by calling
// [projects.models.versions.list](/ml/reference/rest/v1beta1/projects.models.versions/list).
type Version struct {
	// Required.The name specified for the version when it was created.
	//
	// The version name must be unique within the model it is created in.
	Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
	// Optional. The description specified for the version when it was created.
	Description string `protobuf:"bytes,2,opt,name=description,proto3" json:"description,omitempty"`
	// Output only. If true, this version will be used to handle prediction
	// requests that do not specify a version.
	//
	// You can change the default version by calling
	// [projects.methods.versions.setDefault](/ml/reference/rest/v1beta1/projects.models.versions/setDefault).
	IsDefault bool `protobuf:"varint,3,opt,name=is_default,json=isDefault,proto3" json:"is_default,omitempty"`
	// Required. The Google Cloud Storage location of the trained model used to
	// create the version. See the
	// [overview of model deployment](/ml/docs/concepts/deployment-overview) for
	// more informaiton.
	//
	// When passing Version to
	// [projects.models.versions.create](/ml/reference/rest/v1beta1/projects.models.versions/create)
	// the model service uses the specified location as the source of the model.
	// Once deployed, the model version is hosted by the prediction service, so
	// this location is useful only as a historical record.
	DeploymentUri string `protobuf:"bytes,4,opt,name=deployment_uri,json=deploymentUri,proto3" json:"deployment_uri,omitempty"`
	// Output only. The time the version was created.
	CreateTime *google_protobuf2.Timestamp `protobuf:"bytes,5,opt,name=create_time,json=createTime" json:"create_time,omitempty"`
	// Output only. The time the version was last used for prediction.
	LastUseTime *google_protobuf2.Timestamp `protobuf:"bytes,6,opt,name=last_use_time,json=lastUseTime" json:"last_use_time,omitempty"`
	// Optional. The Google Cloud ML runtime version to use for this deployment.
	// If not set, Google Cloud ML will choose a version.
	RuntimeVersion string `protobuf:"bytes,8,opt,name=runtime_version,json=runtimeVersion,proto3" json:"runtime_version,omitempty"`
	// Optional. Manually select the number of nodes to use for serving the
	// model. If unset (i.e., by default), the number of nodes used to serve
	// the model automatically scales with traffic. However, care should be
	// taken to ramp up traffic according to the model's ability to scale. If
	// your model needs to handle bursts of traffic beyond it's ability to
	// scale, it is recommended you set this field appropriately.
	ManualScaling *ManualScaling `protobuf:"bytes,9,opt,name=manual_scaling,json=manualScaling" json:"manual_scaling,omitempty"`
}

func (m *Version) Reset()                    { *m = Version{} }
func (m *Version) String() string            { return proto.CompactTextString(m) }
func (*Version) ProtoMessage()               {}
func (*Version) Descriptor() ([]byte, []int) { return fileDescriptorModelService, []int{1} }

func (m *Version) GetName() string {
	if m != nil {
		return m.Name
	}
	return ""
}

func (m *Version) GetDescription() string {
	if m != nil {
		return m.Description
	}
	return ""
}

func (m *Version) GetIsDefault() bool {
	if m != nil {
		return m.IsDefault
	}
	return false
}

func (m *Version) GetDeploymentUri() string {
	if m != nil {
		return m.DeploymentUri
	}
	return ""
}

func (m *Version) GetCreateTime() *google_protobuf2.Timestamp {
	if m != nil {
		return m.CreateTime
	}
	return nil
}

func (m *Version) GetLastUseTime() *google_protobuf2.Timestamp {
	if m != nil {
		return m.LastUseTime
	}
	return nil
}

func (m *Version) GetRuntimeVersion() string {
	if m != nil {
		return m.RuntimeVersion
	}
	return ""
}

func (m *Version) GetManualScaling() *ManualScaling {
	if m != nil {
		return m.ManualScaling
	}
	return nil
}

// Options for manually scaling a model.
type ManualScaling struct {
	// The number of nodes to allocate for this model. These nodes are always up,
	// starting from the time the model is deployed, so the cost of operating
	// this model will be proportional to nodes * number of hours since
	// deployment.
	Nodes int32 `protobuf:"varint,1,opt,name=nodes,proto3" json:"nodes,omitempty"`
}

func (m *ManualScaling) Reset()                    { *m = ManualScaling{} }
func (m *ManualScaling) String() string            { return proto.CompactTextString(m) }
func (*ManualScaling) ProtoMessage()               {}
func (*ManualScaling) Descriptor() ([]byte, []int) { return fileDescriptorModelService, []int{2} }

func (m *ManualScaling) GetNodes() int32 {
	if m != nil {
		return m.Nodes
	}
	return 0
}

// Request message for the CreateModel method.
type CreateModelRequest struct {
	// Required. The project name.
	//
	// Authorization: requires `Editor` role on the specified project.
	Parent string `protobuf:"bytes,1,opt,name=parent,proto3" json:"parent,omitempty"`
	// Required. The model to create.
	Model *Model `protobuf:"bytes,2,opt,name=model" json:"model,omitempty"`
}

func (m *CreateModelRequest) Reset()                    { *m = CreateModelRequest{} }
func (m *CreateModelRequest) String() string            { return proto.CompactTextString(m) }
func (*CreateModelRequest) ProtoMessage()               {}
func (*CreateModelRequest) Descriptor() ([]byte, []int) { return fileDescriptorModelService, []int{3} }

func (m *CreateModelRequest) GetParent() string {
	if m != nil {
		return m.Parent
	}
	return ""
}

func (m *CreateModelRequest) GetModel() *Model {
	if m != nil {
		return m.Model
	}
	return nil
}

// Request message for the ListModels method.
type ListModelsRequest struct {
	// Required. The name of the project whose models are to be listed.
	//
	// Authorization: requires `Viewer` role on the specified project.
	Parent string `protobuf:"bytes,1,opt,name=parent,proto3" json:"parent,omitempty"`
	// Optional. A page token to request the next page of results.
	//
	// You get the token from the `next_page_token` field of the response from
	// the previous call.
	PageToken string `protobuf:"bytes,4,opt,name=page_token,json=pageToken,proto3" json:"page_token,omitempty"`
	// Optional. The number of models to retrieve per "page" of results. If there
	// are more remaining results than this number, the response message will
	// contain a valid value in the `next_page_token` field.
	//
	// The default value is 20, and the maximum page size is 100.
	PageSize int32 `protobuf:"varint,5,opt,name=page_size,json=pageSize,proto3" json:"page_size,omitempty"`
}

func (m *ListModelsRequest) Reset()                    { *m = ListModelsRequest{} }
func (m *ListModelsRequest) String() string            { return proto.CompactTextString(m) }
func (*ListModelsRequest) ProtoMessage()               {}
func (*ListModelsRequest) Descriptor() ([]byte, []int) { return fileDescriptorModelService, []int{4} }

func (m *ListModelsRequest) GetParent() string {
	if m != nil {
		return m.Parent
	}
	return ""
}

func (m *ListModelsRequest) GetPageToken() string {
	if m != nil {
		return m.PageToken
	}
	return ""
}

func (m *ListModelsRequest) GetPageSize() int32 {
	if m != nil {
		return m.PageSize
	}
	return 0
}

// Response message for the ListModels method.
type ListModelsResponse struct {
	// The list of models.
	Models []*Model `protobuf:"bytes,1,rep,name=models" json:"models,omitempty"`
	// Optional. Pass this token as the `page_token` field of the request for a
	// subsequent call.
	NextPageToken string `protobuf:"bytes,2,opt,name=next_page_token,json=nextPageToken,proto3" json:"next_page_token,omitempty"`
}

func (m *ListModelsResponse) Reset()                    { *m = ListModelsResponse{} }
func (m *ListModelsResponse) String() string            { return proto.CompactTextString(m) }
func (*ListModelsResponse) ProtoMessage()               {}
func (*ListModelsResponse) Descriptor() ([]byte, []int) { return fileDescriptorModelService, []int{5} }

func (m *ListModelsResponse) GetModels() []*Model {
	if m != nil {
		return m.Models
	}
	return nil
}

func (m *ListModelsResponse) GetNextPageToken() string {
	if m != nil {
		return m.NextPageToken
	}
	return ""
}

// Request message for the GetModel method.
type GetModelRequest struct {
	// Required. The name of the model.
	//
	// Authorization: requires `Viewer` role on the parent project.
	Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
}

func (m *GetModelRequest) Reset()                    { *m = GetModelRequest{} }
func (m *GetModelRequest) String() string            { return proto.CompactTextString(m) }
func (*GetModelRequest) ProtoMessage()               {}
func (*GetModelRequest) Descriptor() ([]byte, []int) { return fileDescriptorModelService, []int{6} }

func (m *GetModelRequest) GetName() string {
	if m != nil {
		return m.Name
	}
	return ""
}

// Request message for the DeleteModel method.
type DeleteModelRequest struct {
	// Required. The name of the model.
	//
	// Authorization: requires `Editor` role on the parent project.
	Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
}

func (m *DeleteModelRequest) Reset()                    { *m = DeleteModelRequest{} }
func (m *DeleteModelRequest) String() string            { return proto.CompactTextString(m) }
func (*DeleteModelRequest) ProtoMessage()               {}
func (*DeleteModelRequest) Descriptor() ([]byte, []int) { return fileDescriptorModelService, []int{7} }

func (m *DeleteModelRequest) GetName() string {
	if m != nil {
		return m.Name
	}
	return ""
}

// Uploads the provided trained model version to Cloud Machine Learning.
type CreateVersionRequest struct {
	// Required. The name of the model.
	//
	// Authorization: requires `Editor` role on the parent project.
	Parent string `protobuf:"bytes,1,opt,name=parent,proto3" json:"parent,omitempty"`
	// Required. The version details.
	Version *Version `protobuf:"bytes,2,opt,name=version" json:"version,omitempty"`
}

func (m *CreateVersionRequest) Reset()                    { *m = CreateVersionRequest{} }
func (m *CreateVersionRequest) String() string            { return proto.CompactTextString(m) }
func (*CreateVersionRequest) ProtoMessage()               {}
func (*CreateVersionRequest) Descriptor() ([]byte, []int) { return fileDescriptorModelService, []int{8} }

func (m *CreateVersionRequest) GetParent() string {
	if m != nil {
		return m.Parent
	}
	return ""
}

func (m *CreateVersionRequest) GetVersion() *Version {
	if m != nil {
		return m.Version
	}
	return nil
}

// Request message for the ListVersions method.
type ListVersionsRequest struct {
	// Required. The name of the model for which to list the version.
	//
	// Authorization: requires `Viewer` role on the parent project.
	Parent string `protobuf:"bytes,1,opt,name=parent,proto3" json:"parent,omitempty"`
	// Optional. A page token to request the next page of results.
	//
	// You get the token from the `next_page_token` field of the response from
	// the previous call.
	PageToken string `protobuf:"bytes,4,opt,name=page_token,json=pageToken,proto3" json:"page_token,omitempty"`
	// Optional. The number of versions to retrieve per "page" of results. If
	// there are more remaining results than this number, the response message
	// will contain a valid value in the `next_page_token` field.
	//
	// The default value is 20, and the maximum page size is 100.
	PageSize int32 `protobuf:"varint,5,opt,name=page_size,json=pageSize,proto3" json:"page_size,omitempty"`
}

func (m *ListVersionsRequest) Reset()                    { *m = ListVersionsRequest{} }
func (m *ListVersionsRequest) String() string            { return proto.CompactTextString(m) }
func (*ListVersionsRequest) ProtoMessage()               {}
func (*ListVersionsRequest) Descriptor() ([]byte, []int) { return fileDescriptorModelService, []int{9} }

func (m *ListVersionsRequest) GetParent() string {
	if m != nil {
		return m.Parent
	}
	return ""
}

func (m *ListVersionsRequest) GetPageToken() string {
	if m != nil {
		return m.PageToken
	}
	return ""
}

func (m *ListVersionsRequest) GetPageSize() int32 {
	if m != nil {
		return m.PageSize
	}
	return 0
}

// Response message for the ListVersions method.
type ListVersionsResponse struct {
	// The list of versions.
	Versions []*Version `protobuf:"bytes,1,rep,name=versions" json:"versions,omitempty"`
	// Optional. Pass this token as the `page_token` field of the request for a
	// subsequent call.
	NextPageToken string `protobuf:"bytes,2,opt,name=next_page_token,json=nextPageToken,proto3" json:"next_page_token,omitempty"`
}

func (m *ListVersionsResponse) Reset()         { *m = ListVersionsResponse{} }
func (m *ListVersionsResponse) String() string { return proto.CompactTextString(m) }
func (*ListVersionsResponse) ProtoMessage()    {}
func (*ListVersionsResponse) Descriptor() ([]byte, []int) {
	return fileDescriptorModelService, []int{10}
}

func (m *ListVersionsResponse) GetVersions() []*Version {
	if m != nil {
		return m.Versions
	}
	return nil
}

func (m *ListVersionsResponse) GetNextPageToken() string {
	if m != nil {
		return m.NextPageToken
	}
	return ""
}

// Request message for the GetVersion method.
type GetVersionRequest struct {
	// Required. The name of the version.
	//
	// Authorization: requires `Viewer` role on the parent project.
	Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
}

func (m *GetVersionRequest) Reset()                    { *m = GetVersionRequest{} }
func (m *GetVersionRequest) String() string            { return proto.CompactTextString(m) }
func (*GetVersionRequest) ProtoMessage()               {}
func (*GetVersionRequest) Descriptor() ([]byte, []int) { return fileDescriptorModelService, []int{11} }

func (m *GetVersionRequest) GetName() string {
	if m != nil {
		return m.Name
	}
	return ""
}

// Request message for the DeleteVerionRequest method.
type DeleteVersionRequest struct {
	// Required. The name of the version. You can get the names of all the
	// versions of a model by calling
	// [projects.models.versions.list](/ml/reference/rest/v1beta1/projects.models.versions/list).
	//
	// Authorization: requires `Editor` role on the parent project.
	Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
}

func (m *DeleteVersionRequest) Reset()         { *m = DeleteVersionRequest{} }
func (m *DeleteVersionRequest) String() string { return proto.CompactTextString(m) }
func (*DeleteVersionRequest) ProtoMessage()    {}
func (*DeleteVersionRequest) Descriptor() ([]byte, []int) {
	return fileDescriptorModelService, []int{12}
}

func (m *DeleteVersionRequest) GetName() string {
	if m != nil {
		return m.Name
	}
	return ""
}

// Request message for the SetDefaultVersion request.
type SetDefaultVersionRequest struct {
	// Required. The name of the version to make the default for the model. You
	// can get the names of all the versions of a model by calling
	// [projects.models.versions.list](/ml/reference/rest/v1beta1/projects.models.versions/list).
	//
	// Authorization: requires `Editor` role on the parent project.
	Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
}

func (m *SetDefaultVersionRequest) Reset()         { *m = SetDefaultVersionRequest{} }
func (m *SetDefaultVersionRequest) String() string { return proto.CompactTextString(m) }
func (*SetDefaultVersionRequest) ProtoMessage()    {}
func (*SetDefaultVersionRequest) Descriptor() ([]byte, []int) {
	return fileDescriptorModelService, []int{13}
}

func (m *SetDefaultVersionRequest) GetName() string {
	if m != nil {
		return m.Name
	}
	return ""
}

func init() {
	proto.RegisterType((*Model)(nil), "google.cloud.ml.v1beta1.Model")
	proto.RegisterType((*Version)(nil), "google.cloud.ml.v1beta1.Version")
	proto.RegisterType((*ManualScaling)(nil), "google.cloud.ml.v1beta1.ManualScaling")
	proto.RegisterType((*CreateModelRequest)(nil), "google.cloud.ml.v1beta1.CreateModelRequest")
	proto.RegisterType((*ListModelsRequest)(nil), "google.cloud.ml.v1beta1.ListModelsRequest")
	proto.RegisterType((*ListModelsResponse)(nil), "google.cloud.ml.v1beta1.ListModelsResponse")
	proto.RegisterType((*GetModelRequest)(nil), "google.cloud.ml.v1beta1.GetModelRequest")
	proto.RegisterType((*DeleteModelRequest)(nil), "google.cloud.ml.v1beta1.DeleteModelRequest")
	proto.RegisterType((*CreateVersionRequest)(nil), "google.cloud.ml.v1beta1.CreateVersionRequest")
	proto.RegisterType((*ListVersionsRequest)(nil), "google.cloud.ml.v1beta1.ListVersionsRequest")
	proto.RegisterType((*ListVersionsResponse)(nil), "google.cloud.ml.v1beta1.ListVersionsResponse")
	proto.RegisterType((*GetVersionRequest)(nil), "google.cloud.ml.v1beta1.GetVersionRequest")
	proto.RegisterType((*DeleteVersionRequest)(nil), "google.cloud.ml.v1beta1.DeleteVersionRequest")
	proto.RegisterType((*SetDefaultVersionRequest)(nil), "google.cloud.ml.v1beta1.SetDefaultVersionRequest")
}

func init() {
	proto.RegisterFile("google/cloud/ml/v1beta1/model_service.proto", fileDescriptorModelService)
}

var fileDescriptorModelService = []byte{
	// 985 bytes of a gzipped FileDescriptorProto
	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xb4, 0x56, 0xcf, 0x6f, 0xdc, 0x44,
	0x14, 0x96, 0x93, 0x6c, 0xb2, 0xfb, 0xb6, 0x9b, 0x28, 0x43, 0xa0, 0xcb, 0x42, 0xe8, 0xca, 0x55,
	0xda, 0xd5, 0xa6, 0xb5, 0xc9, 0x82, 0x22, 0x75, 0x81, 0x22, 0x95, 0x48, 0x15, 0x52, 0x23, 0x22,
	0xa7, 0xe5, 0x6a, 0x39, 0xbb, 0x53, 0xe3, 0x62, 0xcf, 0x18, 0xcf, 0x38, 0x82, 0x42, 0x0e, 0x70,
	0xe0, 0xc8, 0x01, 0xc4, 0x95, 0x0b, 0x77, 0xfe, 0x19, 0xee, 0x9c, 0x10, 0x7f, 0x04, 0x27, 0x34,
	0xbf, 0x36, 0xde, 0xec, 0x0f, 0x3b, 0x48, 0xbd, 0x79, 0xde, 0x7c, 0x6f, 0xde, 0x37, 0xef, 0x7b,
	0xef, 0x79, 0x60, 0x3f, 0xa4, 0x34, 0x8c, 0xb1, 0x3b, 0x8a, 0x69, 0x3e, 0x76, 0x93, 0xd8, 0x3d,
	0x3f, 0x38, 0xc3, 0x3c, 0x38, 0x70, 0x13, 0x3a, 0xc6, 0xb1, 0xcf, 0x70, 0x76, 0x1e, 0x8d, 0xb0,
	0x93, 0x66, 0x94, 0x53, 0x74, 0x53, 0x81, 0x1d, 0x09, 0x76, 0x92, 0xd8, 0xd1, 0xe0, 0xce, 0xdb,
	0xfa, 0x94, 0x20, 0x8d, 0xdc, 0x80, 0x10, 0xca, 0x03, 0x1e, 0x51, 0xc2, 0x94, 0x5b, 0xe7, 0xf5,
	0xe2, 0x6e, 0xce, 0xbf, 0xd0, 0xe6, 0xdb, 0xda, 0x1c, 0x53, 0x12, 0x66, 0x39, 0x21, 0x11, 0x09,
	0x5d, 0x9a, 0xe2, 0x6c, 0xca, 0xf7, 0x96, 0x06, 0xc9, 0xd5, 0x59, 0xfe, 0xdc, 0xe5, 0x51, 0x82,
	0x19, 0x0f, 0x92, 0x54, 0x01, 0xec, 0xbf, 0x2c, 0xa8, 0x1d, 0x0b, 0xae, 0x08, 0xc1, 0x1a, 0x09,
	0x12, 0xdc, 0xb6, 0xba, 0x56, 0xaf, 0xe1, 0xc9, 0x6f, 0xd4, 0x85, 0xe6, 0x18, 0xb3, 0x51, 0x16,
	0xa5, 0xe2, 0xd0, 0xf6, 0x8a, 0xdc, 0x2a, 0x9a, 0xd0, 0xa7, 0xb0, 0x35, 0xc6, 0xcf, 0x83, 0x3c,
	0xe6, 0xfe, 0x39, 0xce, 0x98, 0x40, 0xad, 0x76, 0xad, 0x5e, 0x73, 0xd0, 0x75, 0x16, 0xdc, 0xd6,
	0xf9, 0x5c, 0xe1, 0xbc, 0x4d, 0xed, 0xa8, 0xd7, 0xa8, 0x0d, 0x1b, 0x19, 0x0e, 0x05, 0xf9, 0xf6,
	0x5a, 0x77, 0xb5, 0xd7, 0xf0, 0xcc, 0x12, 0x0d, 0xe1, 0x4d, 0x4a, 0xe2, 0x88, 0x60, 0x3f, 0xcd,
	0xf0, 0x38, 0x1a, 0x89, 0xc8, 0x7e, 0x4c, 0xc3, 0x30, 0x22, 0x61, 0xbb, 0xd6, 0xb5, 0x7a, 0x75,
	0xef, 0xa6, 0x02, 0x9c, 0x4c, 0xf6, 0x9f, 0xa8, 0x6d, 0xfb, 0xdf, 0x15, 0xd8, 0x30, 0x11, 0xfe,
	0xdf, 0x15, 0x77, 0x01, 0x22, 0xe6, 0x6b, 0xb2, 0xf2, 0x76, 0x75, 0xaf, 0x11, 0xb1, 0x23, 0x65,
	0x40, 0x7b, 0xb0, 0x39, 0xc6, 0x69, 0x4c, 0xbf, 0x49, 0x30, 0xe1, 0x7e, 0x9e, 0x45, 0xed, 0x35,
	0x79, 0x46, 0xeb, 0xd2, 0xfa, 0x2c, 0x8b, 0xd0, 0x07, 0xd0, 0x1c, 0x65, 0x38, 0xe0, 0xd8, 0x17,
	0x12, 0x48, 0xd6, 0xcd, 0x41, 0xc7, 0x24, 0xc9, 0xe8, 0xe3, 0x3c, 0x35, 0xfa, 0x78, 0xa0, 0xe0,
	0xc2, 0x80, 0x1e, 0x42, 0x2b, 0x0e, 0x18, 0xf7, 0x73, 0xa6, 0xdd, 0xd7, 0x4b, 0xdd, 0x9b, 0xc2,
	0xe1, 0x19, 0x53, 0xfe, 0x77, 0x61, 0x2b, 0xcb, 0x89, 0xf0, 0x9c, 0xa8, 0x54, 0x97, 0x24, 0x37,
	0xb5, 0xd9, 0x64, 0xe8, 0x18, 0x36, 0x93, 0x80, 0xe4, 0x41, 0xec, 0xb3, 0x51, 0x10, 0x8b, 0xf4,
	0x36, 0x64, 0xa4, 0x3b, 0x0b, 0xd5, 0x3c, 0x96, 0xf0, 0x53, 0x85, 0xf6, 0x5a, 0x49, 0x71, 0x69,
	0xef, 0x41, 0x6b, 0x6a, 0x1f, 0xed, 0x40, 0x8d, 0xd0, 0x31, 0x66, 0x52, 0x82, 0x9a, 0xa7, 0x16,
	0xf6, 0x19, 0xa0, 0x4f, 0xe4, 0x65, 0x65, 0x25, 0x7a, 0xf8, 0xab, 0x1c, 0x33, 0x8e, 0xde, 0x80,
	0xf5, 0x34, 0xc8, 0x30, 0xe1, 0x5a, 0x2f, 0xbd, 0x42, 0xef, 0x43, 0x4d, 0x76, 0x97, 0xd4, 0xaa,
	0x39, 0x78, 0x67, 0x31, 0x35, 0x79, 0x9a, 0x02, 0xdb, 0x21, 0x6c, 0x3f, 0x89, 0x18, 0x97, 0x36,
	0x56, 0x16, 0x62, 0x17, 0x20, 0x0d, 0x42, 0xec, 0x73, 0xfa, 0x25, 0x26, 0x5a, 0xcf, 0x86, 0xb0,
	0x3c, 0x15, 0x06, 0xf4, 0x16, 0xc8, 0x85, 0xcf, 0xa2, 0x97, 0x4a, 0xc9, 0x9a, 0x57, 0x17, 0x86,
	0xd3, 0xe8, 0x25, 0xb6, 0x39, 0xa0, 0x62, 0x20, 0x96, 0x52, 0xc2, 0x30, 0x3a, 0x84, 0x75, 0xc9,
	0x43, 0xdc, 0x7c, 0xb5, 0x02, 0x6b, 0x8d, 0x46, 0x77, 0x60, 0x8b, 0xe0, 0xaf, 0xb9, 0x5f, 0xa0,
	0xa3, 0x4a, 0xb4, 0x25, 0xcc, 0x27, 0x86, 0x92, 0xbd, 0x07, 0x5b, 0x8f, 0x31, 0x9f, 0xca, 0xdf,
	0x9c, 0x6a, 0xb7, 0x7b, 0x80, 0x8e, 0x70, 0x8c, 0xaf, 0x64, 0x7a, 0x1e, 0xf2, 0x05, 0xec, 0x28,
	0x4d, 0x4c, 0xbb, 0x96, 0xa4, 0x6c, 0x08, 0x1b, 0xa6, 0xb4, 0x56, 0x2a, 0x0e, 0x00, 0xe3, 0x60,
	0x47, 0xf0, 0x9a, 0x48, 0x99, 0xb6, 0xbf, 0x52, 0x75, 0xbe, 0x83, 0x9d, 0xe9, 0x50, 0x5a, 0x9f,
	0x0f, 0xa1, 0xae, 0xd9, 0x18, 0x85, 0xca, 0xf9, 0x4f, 0x3c, 0x2a, 0xab, 0x74, 0x17, 0xb6, 0x1f,
	0x63, 0x7e, 0x25, 0xa3, 0xf3, 0xb2, 0xdf, 0x87, 0x1d, 0xa5, 0x53, 0x05, 0xac, 0x03, 0xed, 0x53,
	0xcc, 0x8f, 0xa6, 0x86, 0xe9, 0x12, 0xfc, 0xe0, 0x1f, 0x80, 0x1b, 0x52, 0xfe, 0x53, 0xf5, 0x77,
	0x42, 0x3f, 0x59, 0xd0, 0x2c, 0xf4, 0x1f, 0xda, 0x5f, 0x78, 0xf3, 0xd9, 0x2e, 0xed, 0x94, 0x14,
	0xb2, 0x3d, 0xf8, 0xe1, 0xcf, 0xbf, 0x7f, 0x59, 0xb9, 0x67, 0xdf, 0x9e, 0xfc, 0x1a, 0xbf, 0x55,
	0x32, 0x7e, 0x94, 0x66, 0xf4, 0x05, 0x1e, 0x71, 0xe6, 0xf6, 0x2f, 0xd4, 0xef, 0x92, 0x0d, 0x55,
	0xaf, 0xa2, 0x9f, 0x2d, 0x80, 0xcb, 0x1e, 0x42, 0xfd, 0x85, 0x21, 0x66, 0x3a, 0xba, 0xb3, 0x5f,
	0x09, 0xab, 0x44, 0xb7, 0xf7, 0x25, 0xb7, 0x3d, 0x54, 0x85, 0x1b, 0xfa, 0xde, 0x82, 0xba, 0x69,
	0x31, 0xd4, 0x5b, 0x18, 0xe6, 0x4a, 0x17, 0x96, 0xe6, 0x67, 0x0e, 0x07, 0xa1, 0x52, 0x81, 0x81,
	0x26, 0xe0, 0xf6, 0x2f, 0xd0, 0x8f, 0x16, 0x34, 0x0b, 0xfd, 0xbb, 0x44, 0xa9, 0xd9, 0x2e, 0xef,
	0xec, 0x1a, 0x70, 0xe1, 0xc5, 0xe0, 0x7c, 0x66, 0x5e, 0x0c, 0x86, 0x48, 0xbf, 0x12, 0x91, 0xdf,
	0x2c, 0x68, 0x4d, 0x8d, 0x07, 0x74, 0xbf, 0xa4, 0x68, 0xa6, 0x0b, 0xb3, 0x8c, 0xcc, 0xc7, 0x92,
	0xcc, 0x03, 0xdb, 0x59, 0xa2, 0xcc, 0x25, 0x1d, 0xd7, 0x34, 0xe2, 0xd0, 0x8c, 0x14, 0xf4, 0xbb,
	0x05, 0x37, 0x8a, 0x8d, 0x8e, 0xee, 0x2d, 0x2d, 0x8c, 0x2b, 0xa3, 0xa7, 0x73, 0xbf, 0x22, 0x5a,
	0x17, 0xd2, 0xa1, 0xa4, 0xfb, 0x2e, 0xba, 0x26, 0x5d, 0x59, 0xe8, 0x97, 0x03, 0x61, 0x49, 0xa1,
	0xcf, 0x4c, 0x8d, 0x4e, 0xe9, 0x78, 0x9a, 0x47, 0x6a, 0x91, 0xa0, 0x13, 0x46, 0x42, 0xdb, 0x5f,
	0x2d, 0x68, 0x4d, 0x0d, 0x9f, 0x25, 0xda, 0xce, 0x1b, 0x52, 0x65, 0xda, 0x6a, 0x5e, 0xfd, 0xeb,
	0xf2, 0xfa, 0xc3, 0x82, 0xed, 0x99, 0x41, 0x87, 0x0e, 0x16, 0x72, 0x5b, 0x34, 0x14, 0x2b, 0xa4,
	0xee, 0x48, 0x52, 0x7c, 0x68, 0x3f, 0xb8, 0x1e, 0xc5, 0x21, 0x9b, 0x84, 0x1c, 0x5a, 0xfd, 0x47,
	0x87, 0x70, 0x6b, 0x44, 0x93, 0x99, 0x60, 0x41, 0x1a, 0x99, 0x80, 0x8f, 0xb6, 0x8b, 0x83, 0xf8,
	0x44, 0xbc, 0xe2, 0x4e, 0xac, 0xb3, 0x75, 0xf9, 0x9c, 0x7b, 0xef, 0xbf, 0x00, 0x00, 0x00, 0xff,
	0xff, 0xda, 0xac, 0xc5, 0xb4, 0x5d, 0x0c, 0x00, 0x00,
}