text:
using content::BrowserThread;

namespace chromeos {

namespace {

const char kSAMLStartCookie[] = "google-accounts-saml-start";
const char kSAMLEndCookie[] = "google-accounts-saml-end";

// Import |cookies| into |cookie_store|.
void ImportCookies(const net::CookieList& cookies,
                   net::CookieStore* cookie_store) {
  for (const auto& cookie : cookies) {
    // To re-create the original cookie, a domain should only be passed in to
    // SetCookieWithDetailsAsync if cookie.Domain() has a leading period, to
    // re-create the original cookie.
    std::string domain;
    if (!cookie.Domain().empty() && cookie.Domain()[0] == '.')
      domain = cookie.Domain();

    cookie_store->SetCookieWithDetailsAsync(
        cookie.Source(), cookie.Name(), cookie.Value(), domain, cookie.Path(),
        cookie.CreationDate(), cookie.ExpiryDate(), cookie.LastAccessDate(),
        cookie.IsSecure(), cookie.IsHttpOnly(), cookie.SameSite(),
        // enforce_strict_secure should have been applied on the original
        // cookie, prior to import.
        false, cookie.Priority(), net::CookieStore::SetCookiesCallback());
  }
}

class ProfileAuthDataTransferer {
 public:
  ProfileAuthDataTransferer(
      net::URLRequestContextGetter* from_context,
      net::URLRequestContextGetter* to_context,
      bool transfer_auth_cookies_and_channel_ids_on_first_login,
      bool transfer_saml_auth_cookies_on_subsequent_login,
      const base::Closure& completion_callback);

  void BeginTransfer();

 private:
  void BeginTransferOnIOThread();

  // Transfer the proxy auth cache from |from_context_| to |to_context_|. If
  // the user was required to authenticate with a proxy during login, this
  // authentication information will be transferred into the user's session.
  void TransferProxyAuthCache();

  // Callback that receives the content of |to_context_|'s cookie jar. Checks
  // whether this is the user's first login, based on the state of the cookie
  // jar, and starts retrieval of the data that should be transfered. Calls
  // Finish() if there is no data to transfer.
  void OnTargetCookieJarContentsRetrieved(
      const net::CookieList& target_cookies);

  // Retrieve the contents of |from_context_|'s cookie jar. When the retrieval
  // finishes, OnCookiesToTransferRetrieved will be called with the result.
  void RetrieveCookiesToTransfer();

  // Callback that receives the contents of |from_context_|'s cookie jar. Calls
  // MaybeTransferCookiesAndChannelIDs() to try and perform the transfer.
  void OnCookiesToTransferRetrieved(const net::CookieList& cookies_to_transfer);

  // Retrieve |from_context_|'s channel IDs. When the retrieval finishes,
  // OnChannelIDsToTransferRetrieved will be called with the result.
  void RetrieveChannelIDsToTransfer();

  // Callback that receives |from_context_|'s channel IDs. Calls
  // MaybeTransferCookiesAndChannelIDs() to try and perform the transfer.
  void OnChannelIDsToTransferRetrieved(
      const net::ChannelIDStore::ChannelIDList& channel_ids_to_transfer);

  // Given a |cookie| set during login, returns true if the cookie may have been
  // set by GAIA. The main criterion is the |cookie|'s creation date. The points
  // in time at which redirects from GAIA to SAML IdP and back occur are stored
  // in |saml_start_time_| and |saml_end_time_|. If the cookie was set between
  // these two times, it was created by the SAML IdP. Otherwise, it was created
  // by GAIA.
  // As an additional precaution, the cookie's domain is checked. If the domain
  // contains "google" or "youtube", the cookie is considered to have been set
  // by GAIA as well.
  bool IsGAIACookie(const net::CanonicalCookie& cookie);

  // If all data to be transferred has been retrieved already, transfer it to
  // |to_context_| and call Finish().
  void MaybeTransferCookiesAndChannelIDs();

  // Post the |completion_callback_| to the UI thread and schedule destruction
  // of |this|.
  void Finish();

  scoped_refptr<net::URLRequestContextGetter> from_context_;
  scoped_refptr<net::URLRequestContextGetter> to_context_;
  bool transfer_auth_cookies_and_channel_ids_on_first_login_;
  bool transfer_saml_auth_cookies_on_subsequent_login_;
  base::Closure completion_callback_;

  net::CookieList cookies_to_transfer_;
  net::ChannelIDStore::ChannelIDList channel_ids_to_transfer_;

  // The time at which a redirect from GAIA to a SAML IdP occurred.
  base::Time saml_start_time_;
  // The time at which a redirect from a SAML IdP back to GAIA occurred.
  base::Time saml_end_time_;

  bool first_login_;
  bool waiting_for_auth_cookies_;
  bool waiting_for_channel_ids_;
};

ProfileAuthDataTransferer::ProfileAuthDataTransferer(
    net::URLRequestContextGetter* from_context,
    net::URLRequestContextGetter* to_context,
    bool transfer_auth_cookies_and_channel_ids_on_first_login,
    bool transfer_saml_auth_cookies_on_subsequent_login,
    const base::Closure& completion_callback)
    : from_context_(from_context),
      to_context_(to_context),
      transfer_auth_cookies_and_channel_ids_on_first_login_(
          transfer_auth_cookies_and_channel_ids_on_first_login),
      transfer_saml_auth_cookies_on_subsequent_login_(
          transfer_saml_auth_cookies_on_subsequent_login),
      completion_callback_(completion_callback),
      first_login_(false),
      waiting_for_auth_cookies_(false),
      waiting_for_channel_ids_(false) {
}

void ProfileAuthDataTransferer::BeginTransfer() {
  DCHECK_CURRENTLY_ON(BrowserThread::UI);
  // If we aren't transferring auth cookies or channel IDs, post the completion
  // callback immediately. Otherwise, it will be called when the transfer
  // finishes.
  if (!transfer_auth_cookies_and_channel_ids_on_first_login_ &&
      !transfer_saml_auth_cookies_on_subsequent_login_) {
    BrowserThread::PostTask(BrowserThread::UI, FROM_HERE, completion_callback_);
    // Null the callback so that when Finish is called, the callback won't be
    // called again.
    completion_callback_.Reset();
  }
  BrowserThread::PostTask(
      BrowserThread::IO, FROM_HERE,
      base::Bind(&ProfileAuthDataTransferer::BeginTransferOnIOThread,
                 base::Unretained(this)));
}

void ProfileAuthDataTransferer::BeginTransferOnIOThread() {
  DCHECK_CURRENTLY_ON(BrowserThread::IO);
  TransferProxyAuthCache();
  if (transfer_auth_cookies_and_channel_ids_on_first_login_ ||
      transfer_saml_auth_cookies_on_subsequent_login_) {
    // Retrieve the contents of |to_context_|'s cookie jar.
    net::CookieStore* to_store =
        to_context_->GetURLRequestContext()->cookie_store();
    to_store->GetAllCookiesAsync(base::Bind(
        &ProfileAuthDataTransferer::OnTargetCookieJarContentsRetrieved,
        base::Unretained(this)));
  } else {
    Finish();
  }
}

void ProfileAuthDataTransferer::TransferProxyAuthCache() {
  DCHECK_CURRENTLY_ON(BrowserThread::IO);
  net::HttpAuthCache* new_cache = to_context_->GetURLRequestContext()->
      http_transaction_factory()->GetSession()->http_auth_cache();
  new_cache->UpdateAllFrom(*from_context_->GetURLRequestContext()->
      http_transaction_factory()->GetSession()->http_auth_cache());
}

void ProfileAuthDataTransferer::OnTargetCookieJarContentsRetrieved(
    const net::CookieList& target_cookies) {
  DCHECK_CURRENTLY_ON(BrowserThread::IO);
  first_login_ = target_cookies.empty();
  if (first_login_) {
    // On first login, transfer all auth cookies and channel IDs if
    // |transfer_auth_cookies_and_channel_ids_on_first_login_| is true.
    waiting_for_auth_cookies_ =
        transfer_auth_cookies_and_channel_ids_on_first_login_;
    waiting_for_channel_ids_ =
        transfer_auth_cookies_and_channel_ids_on_first_login_;
  } else {
    // On subsequent login, transfer auth cookies set by the SAML IdP if
    // |transfer_saml_auth_cookies_on_subsequent_login_| is true.
    waiting_for_auth_cookies_ = transfer_saml_auth_cookies_on_subsequent_login_;
  }

  if (!waiting_for_auth_cookies_ && !waiting_for_channel_ids_) {
    Finish();
    return;
  }

  if (waiting_for_auth_cookies_)
    RetrieveCookiesToTransfer();
  if (waiting_for_channel_ids_)
    RetrieveChannelIDsToTransfer();
}

void ProfileAuthDataTransferer::RetrieveCookiesToTransfer() {
  DCHECK_CURRENTLY_ON(BrowserThread::IO);
  net::CookieStore* from_store =
      from_context_->GetURLRequestContext()->cookie_store();
  from_store->GetAllCookiesAsync(
      base::Bind(&ProfileAuthDataTransferer::OnCookiesToTransferRetrieved,
                 base::Unretained(this)));
}

void ProfileAuthDataTransferer::OnCookiesToTransferRetrieved(
    const net::CookieList& cookies_to_transfer) {
  DCHECK_CURRENTLY_ON(BrowserThread::IO);
  waiting_for_auth_cookies_ = false;
  cookies_to_transfer_ = cookies_to_transfer;

  // Look for cookies indicating the points in time at which redirects from GAIA
  // to SAML IdP and back occurred. These cookies are synthesized by
  // chrome/browser/resources/gaia_auth/background.js. If the cookies are found,
  // their creation times are stored in |saml_start_time_| and
  // |cookies_to_transfer_| and the cookies are deleted.
  for (net::CookieList::iterator it = cookies_to_transfer_.begin();
       it != cookies_to_transfer_.end(); ) {
    if (it->Name() == kSAMLStartCookie) {
      saml_start_time_ = it->CreationDate();
      it = cookies_to_transfer_.erase(it);
    } else if (it->Name() == kSAMLEndCookie) {
      saml_end_time_ = it->CreationDate();
      it = cookies_to_transfer_.erase(it);
    } else {
      ++it;
    }
  }

  MaybeTransferCookiesAndChannelIDs();
}

void ProfileAuthDataTransferer::RetrieveChannelIDsToTransfer() {
  DCHECK_CURRENTLY_ON(BrowserThread::IO);
  net::ChannelIDService* from_service =
      from_context_->GetURLRequestContext()->channel_id_service();
  from_service->GetChannelIDStore()->GetAllChannelIDs(
      base::Bind(
          &ProfileAuthDataTransferer::OnChannelIDsToTransferRetrieved,
          base::Unretained(this)));
}

void ProfileAuthDataTransferer::OnChannelIDsToTransferRetrieved(
    const net::ChannelIDStore::ChannelIDList& channel_ids_to_transfer) {
  DCHECK_CURRENTLY_ON(BrowserThread::IO);
  channel_ids_to_transfer_ = channel_ids_to_transfer;
  waiting_for_channel_ids_ = false;
  MaybeTransferCookiesAndChannelIDs();
}

bool ProfileAuthDataTransferer::IsGAIACookie(
    const net::CanonicalCookie& cookie) {
  const base::Time& creation_date = cookie.CreationDate();
  if (creation_date < saml_start_time_)
    return true;
  if (!saml_end_time_.is_null() && creation_date > saml_end_time_)
    return true;

  const std::string& domain = cookie.Domain();
  return domain.find("google") != std::string::npos ||
         domain.find("youtube") != std::string::npos;
}

void ProfileAuthDataTransferer::MaybeTransferCookiesAndChannelIDs() {
  DCHECK_CURRENTLY_ON(BrowserThread::IO);
  if (waiting_for_auth_cookies_ || waiting_for_channel_ids_)
    return;

  net::CookieStore* to_store =
      to_context_->GetURLRequestContext()->cookie_store();
  if (first_login_) {
    ImportCookies(cookies_to_transfer_, to_store);
    net::ChannelIDService* to_cert_service =
        to_context_->GetURLRequestContext()->channel_id_service();
    to_cert_service->GetChannelIDStore()->InitializeFrom(
        channel_ids_to_transfer_);
  } else {
    net::CookieList non_gaia_cookies;
    for (net::CookieList::const_iterator it = cookies_to_transfer_.begin();
         it != cookies_to_transfer_.end(); ++it) {
      if (!IsGAIACookie(*it))
        non_gaia_cookies.push_back(*it);
    }
    ImportCookies(non_gaia_cookies, to_store);
  }

  Finish();
}

void ProfileAuthDataTransferer::Finish() {
  DCHECK_CURRENTLY_ON(BrowserThread::IO);
  if (!completion_callback_.is_null())
    BrowserThread::PostTask(BrowserThread::UI, FROM_HERE, completion_callback_);
  base::MessageLoop::current()->DeleteSoon(FROM_HERE, this);
}

}  // namespace

void ProfileAuthData::Transfer(
    net::URLRequestContextGetter* from_context,
    net::URLRequestContextGetter* to_context,
    bool transfer_auth_cookies_and_channel_ids_on_first_login,
    bool transfer_saml_auth_cookies_on_subsequent_login,
    const base::Closure& completion_callback) {
  DCHECK_CURRENTLY_ON(BrowserThread::UI);
  (new ProfileAuthDataTransferer(
       from_context,
       to_context,
       transfer_auth_cookies_and_channel_ids_on_first_login,
       transfer_saml_auth_cookies_on_subsequent_login,
       completion_callback))->BeginTransfer();
}

}  // namespace chromeos


text:
var webpack = require('webpack');
var WebpackDevServer = require('webpack-dev-server');
var config = require('./webpack.config');

var jsonServer = require('json-server');
var server = jsonServer.create();
var router = jsonServer.router('db.json');
var middlewares = jsonServer.defaults();

new WebpackDevServer(webpack(config), {
  publicPath: config.output.publicPath,
  hot: true,
  historyApiFallback: true
}).listen(3001, 'localhost', function (err, result) {
  if (err) {
    return console.log(err);
  }

  console.log('Listening at http://localhost:3001/');
});

server.use(middlewares);
server.use(router);
server.listen(3000, function() {
  console.log('json-server running on port 3000');
});

redpajama_set_name: RedPajamaGithub


text:
package org.kuali.rice.krad.datadictionary;

import java.util.List;

/**
 * This is a description of what this class does - mpham don't forget to fill this in.
 *
 * @author Kuali Rice Team (rice.collab@kuali.org)
 *
 */
public class SearchingTypeDefinition extends DataDictionaryDefinitionBase {
	private static final long serialVersionUID = -8779609937539520677L;

	private SearchingAttribute searchingAttribute;
	private List<String> paths;

	/**
	 * @return the searchingAttribute
	 */
	public SearchingAttribute getSearchingAttribute() {
		return this.searchingAttribute;
	}
	/**
	 * @return the documentValues
	 */
	public List<String> getDocumentValues() {
		return this.paths;
	}
	/**
	 * @param searchingAttribute the searchingAttribute to set
	 */
	public void setSearchingAttribute(SearchingAttribute searchingAttribute) {
		this.searchingAttribute = searchingAttribute;
	}
	/**
	 * @param documentValues the documentValues to set
	 */
	public void setDocumentValues(List<String> paths) {
		this.paths = paths;
	}
	/**
	 * This overridden method ...
	 *
	 * @see org.kuali.rice.krad.datadictionary.DataDictionaryDefinition#completeValidation(java.lang.Class, java.lang.Class)
	 */
	public void completeValidation(Class rootBusinessObjectClass,
			Class otherBusinessObjectClass) {

	}
}


text:
<?php

namespace Sylius\Component\Product\Model;

use Sylius\Component\Resource\Model\AbstractTranslation;

/**
 * @author Gonzalo Vilaseca <gvilaseca@reiss.co.uk>
 */
class ProductOptionTranslation extends AbstractTranslation implements ProductOptionTranslationInterface
{
    /**
     * @var mixed
     */
    protected $id;

    /**
     * @var string
     */
    protected $name;

    /**
     * {@inheritdoc}
     */
    public function getId()
    {
        return $this->id;
    }

    /**
     * {@inheritdoc}
     */
    public function getName()
    {
        return $this->name;
    }

    /**
     * {@inheritdoc}
     */
    public function setName($name)
    {
        $this->name = $name;
    }
}


text:
=head1 LICENSE

Copyright [1999-2014] Wellcome Trust Sanger Institute and the EMBL-European Bioinformatics Institute

Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at

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

Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.

=cut

package EnsEMBL::Web::Object::Biotype;

use strict;

use base qw(EnsEMBL::Web::Object::DbFrontend);

### ### ### ### ### ### ### ### ###
### Inherited method overriding ###
### ### ### ### ### ### ### ### ###

sub manager_class {
  ## @overrides
  return shift->rose_manager(qw(Production Biotype));
}

sub show_fields {
  ## @overrides
  my $self = shift;
  return [
    name              => {
      'type'      => 'string',
      'label'     => 'Name'
    },
    object_type       => {
      'type'      => 'dropdown',
      'label'     => 'Object Type',
    },
    db_type           => {
      'type'      => 'dropdown',
      'label'     => 'Database Type',
    },
    biotype_group => {
      'type'      => 'dropdown',
      'label'     => 'Biotype Group',
    },
    attrib_type       => {
      'type'      => 'dropdown',
      'label'     => 'Attribute code (if the biotype is included in density feature calculations)',
      'is_null'   => 'None',
    },
    is_dumped         => {
      'type'      => 'dropdown',
      'label'     => 'Is this biotype dumped?',
      'values'    => [{'value' => '1', 'caption' => 'Yes'}, {'value' => '0', 'caption' => 'No'}]
    },
    description       => {
      'type'      => 'text',
      'label'     => 'Description',
    }
  ];
}

sub show_columns {
  ## @overrides
  return [
    name        => 'Name',
    object_type => 'Object Type',
    db_type     => 'Database Type'
  ];
}

sub record_name {
  ## @overrides
  return {
    'singular' => 'biotype',
    'plural'   => 'biotypes'
  };
}

sub permit_delete {
  ## @overrides
  ## Record can not be deleted, but can be set inactive
  return 'retire';
}

1;


text:
/*jshint esversion: 6 */

import { Template } from 'meteor/templating';
import './text.html';
import { attsToggleInvalidClass } from '../../utilities/attsToggleInvalidClass';

Template.afInputText_materialize.helpers({
  atts: attsToggleInvalidClass,
  value() {
    const instance = Template.instance();
    return instance.data.value?instance.data.value:instance.data.atts.default;
  }
});


text:
package benchmarkdp.datagenerator.app;

import java.io.BufferedWriter;
import java.io.File;
import java.io.FileWriter;
import java.io.IOException;

import org.slf4j.LoggerFactory;

import benchmarkdp.datagenerator.properties.ExperimentProperties;
import benchmarkdp.datagenerator.core.TestCase;

public class LinuxExecutor extends AbstractVMExecutor {

	public LinuxExecutor(int numbProc, long timeout, boolean visible) {
		super(numbProc, timeout, visible);
		log = LoggerFactory.getLogger(LinuxExecutor.class);

		dropbPathIn = "/home/kresimir/Dropbox/Work/Projects/BenchmarkDP/publications/"
				+ "INFSOF/experiments/ComunicationFolder/ToVM/";
		dropbPathOut = "/home/kresimir/Dropbox/Work/Projects/BenchmarkDP/publications/"
				+ "INFSOF/experiments/ComunicationFolder/FromVM/";

		tmpFolder = "/home/kresimir/Desktop/temp/";

	}

	@Override
	protected void initializeExecution(ExperimentProperties ep, String platform, String experiment) {

		String folderScriptXLC = "/home/kresimir/.config/libreoffice/4/user/basic";

		String xlcFile = folderScriptXLC + File.separator
				+ "script.xlc";

		String xlbFile = ep.getFullFolderPath() + ep.getMacroFolder() + File.separator + platform + File.separator
				+ "script.xlb";
		//log.info("Creating script.xlc file");
		//log.info(xlcFile);
		//log.info(xlbFile);
		saveScriptXLC(xlcFile, xlbFile);

	}

	@Override
	protected Runnable getRunnable(ExperimentProperties ep, TestCase tc, long timeout, boolean visible) {
		return new LinuxVMProc(ep, tc, timeout, visible);
	}

	private void saveScriptXLC(String xlcFile, String xlbFile) {

		StringBuilder sb = new StringBuilder();
		//String linuxPath = path.replaceFirst("Users", "home"); // quick hack for adapting to the linux path
		sb.append("<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n");
		sb.append("<!DOCTYPE library:libraries PUBLIC \"-//OpenOffice.org//DTD OfficeDocument 1.0//EN\" \"libraries.dtd\">\n");
		sb.append("<library:libraries xmlns:library=\"http://openoffice.org/2000/library\" xmlns:xlink=\"http://www.w3.org/1999/xlink\">\n");
		sb.append("<library:library library:name=\"Standard\" xlink:href=\"$(USER)/basic/Standard/script.xlb/\" xlink:type=\"simple\" library:link=\"false\"/>\n");
		sb.append("<library:library library:name=\"Experiment\" xlink:href=\"file://"+ xlbFile +"\" xlink:type=\"simple\" library:link=\"true\" library:readonly=\"false\"/>\n");
		sb.append("</library:libraries>\n");

		try {
			//String file = path + "script.xlc";
			//System.out.println(path);
			File f = new File(xlcFile);
			BufferedWriter bw = new BufferedWriter(new FileWriter(f));
			bw.write(sb.toString());
			bw.close();
		} catch (IOException e1) {
			// TODO Auto-generated catch block
			e1.printStackTrace();
		}

	}

}


text:
extern NSString* const kSignInButtonAccessibilityIdentifier;
extern NSString* const kSignInSkipButtonAccessibilityIdentifier;

@class FirstRunConfiguration;
@class TabModel;

namespace ios {
class ChromeBrowserState;
}

// A ChromeSigninViewController that is used during the run.
@interface FirstRunChromeSigninViewController : ChromeSigninViewController

// Designated initialzer.
- (instancetype)initWithBrowserState:(ios::ChromeBrowserState*)browserState
                            tabModel:(TabModel*)tabModel
                      firstRunConfig:(FirstRunConfiguration*)firstRunConfig
                      signInIdentity:(ChromeIdentity*)identity;

@end

#endif  // IOS_CHROME_BROWSER_UI_FIRST_RUN_FIRST_RUN_CHROME_SIGNIN_VIEW_CONTROLLER_H_


text:
Remote Controlled Ship Kata
===========================

Develop an program that moves a ship around Earth seas.
Earth is represented as a grid.

Following requirements should be fulfilled one at a time using TDD approach.

Req. 01: You are given the initial starting point (x, y) of a ship and the direction (n, s, e, w) it is facing.

Req. 02: Implement commands that move the ship forward and backward (f, b).

Req. 03: Implement commands that turn the ship left and right (l, r).

Req. 04: The ship can receive a string with commands ("lrfb" is equivalent to left, right, forward, backwards).

Req. 05: Earth, as any other planet is a sphere. Implement wrapping from one edge of the grid to another.

Req. 06: Not the whole planet consists of seas. Roughly 30% is surface are islands and continents. Implement surface detection before each move to a new position. If a command encounters surface, the ship aborts the move, stays on the current position and reports the obstacle.


text:
<!DOCTYPE frameset SYSTEM "frameset.dtd">
<frameset>
    <predicate lemma="abet">

        <roleset framnet="Assistance" id="abet.01" name="aid" vncls="72">
            <roles>
                <role descr="agent of abetting" f="" n="0">
                    <vnrole vncls="72-1" vntheta="agent"/>
                </role>
                <role descr="thing helped, action" f="" n="1">
                    <vnrole vncls="72-1" vntheta="beneficiary"/>
                </role>
                <note/>
            </roles>

            <example name="active, normal" src="" type="">
                <inflection aspect="ns" form="gerund" person="ns" tense="ns" voice="ns"/>
                <text>In addition to *trace*-1 abetting in the alleged criminal breach of
                    trust, [Kwek Hong Png]-1 was also charged with dishonestly receiving
                    S$500,000 that had been stolen.
                </text>
                <arg f="" n="0">*trace*-1     (= [Kwek Hong Png])</arg>
                <rel f="">abetting</rel>
                <arg f="" n="1">in the alleged criminal breach of trust</arg>
                <note/>
            </example>

            <example name="passive" src="" type="">
                <inflection aspect="ns" form="participle" person="ns" tense="present" voice="passive"/>
                <text>Civilized discourse and an environment where compromise can begin
                    are lost in [a hostile posture]-1 abetted *trace*-1 by superficial media
                    interviews.
                </text>
                <rel f="">abetted</rel>
                <arg f="" n="1">*trace*-1     (= a hostile posture)</arg>
                <arg f="" n="0">by superficial media interviews</arg>
                <note/>
            </example>

            <example name="very awkward active" src="" type="">
                <inflection aspect="ns" form="gerund" person="ns" tense="ns" voice="ns"/>
                <text>[Eight admissions representatives at two of Wilfred's former
                    Massachusetts schools]-1 previously pleaded guilty to charges of
                    *trace*-1 aiding, abetting and counseling students to submit false
                    financial-aid applications.
                </text>
                <arg f="" n="0">*trace*-1</arg>
                <rel f="">abetting</rel>
                <arg f="" n="1">students to submit false financial-aid applications</arg>

                <note>The action (submitting applications) is really connected with the PAS
                    of 'counsel' more than aid or abet.
                </note>
            </example>

            <note>Member of Vncls help-72-1. FNcls Assistance.</note>
        </roleset>
        <note>Frames file for 'abet' based on sentences in wsj.</note>
    </predicate>
    <note/>
</frameset>