Dataset Viewer
prompt
stringlengths 1.3k
3.64k
| language
stringclasses 16
values | label
int64 -1
5
| text
stringlengths 14
130k
|
|---|---|---|---|
Below is an extract from a Rust program. Evaluate whether it has a high educational value and could help teach coding. Use the additive 5-point scoring system described below. Points are accumulated based on the satisfaction of each criterion:
- Add 1 point if the program contains valid Rust code, even if it's not educational, like boilerplate code, configurations, or niche concepts.
- Add another point if the program addresses practical Rust concepts, even if it lacks comments.
- Award a third point if the program is suitable for educational use and introduces key concepts in programming, even if the topic is advanced (e.g., ownership, lifetimes). The code should be well-structured and contain some comments.
- Give a fourth point if the program is self-contained and highly relevant to teaching Rust. It should be similar to a school exercise, a tutorial, or a Rust course section.
- Grant a fifth point if the program is outstanding in its educational value and is perfectly suited for teaching Rust. It should be well-written, easy to understand, and contain step-by-step explanations and comments.
The extract:
use arrow2::array::*;
#[test]
fn primitive() {
let data = vec![
Some(vec![Some(1i32), Some(2), Some(3)]),
Some(vec![None, None, None]),
Some(vec![Some(4), None, Some(6)]),
];
let mut list = MutableFixedSizeListArray::new(MutablePrimitiveArray::<i32>::new(), 3);
list.try_extend(data).unwrap();
let list: FixedSizeListArray = list.into();
let a = list.value(0);
let a = a.as_any().downcast_ref::<Int32Array>().unwrap();
let expected = Int32Array::from(vec![Some(1i32), Some(2), Some(3)]);
assert_eq!(a, &expected);
let a = list.value(1);
let a = a.as_any().downcast_ref::<Int32Array>().unwrap();
let expected = Int32Array::from(vec![None, None, None]);
assert_eq!(a, &expected)
}
After examining the extract:
- Briefly justify your total score, up to 100 words.
- Conclude with the score using the format: "Educational score: <total points>"
| rust | 3 | use arrow2::array::*;
#[test]
fn primitive() {
let data = vec![
Some(vec![Some(1i32), Some(2), Some(3)]),
Some(vec![None, None, None]),
Some(vec![Some(4), None, Some(6)]),
];
let mut list = MutableFixedSizeListArray::new(MutablePrimitiveArray::<i32>::new(), 3);
list.try_extend(data).unwrap();
let list: FixedSizeListArray = list.into();
let a = list.value(0);
let a = a.as_any().downcast_ref::<Int32Array>().unwrap();
let expected = Int32Array::from(vec![Some(1i32), Some(2), Some(3)]);
assert_eq!(a, &expected);
let a = list.value(1);
let a = a.as_any().downcast_ref::<Int32Array>().unwrap();
let expected = Int32Array::from(vec![None, None, None]);
assert_eq!(a, &expected)
}
|
Below is an extract from a JavaScript program. Evaluate whether it has a high educational value and could help teach coding. Use the additive 5-point scoring system described below. Points are accumulated based on the satisfaction of each criterion:
- Add 1 point if the program contains valid JavaScript code, even if it's not educational, like boilerplate code, configurations, or niche concepts.
- Add another point if the program addresses practical JavaScript concepts, even if it lacks comments.
- Award a third point if the program is suitable for educational use and introduces key concepts in programming, even if the topic is advanced (e.g., asynchronous programming). The code should be well-structured and contain some comments.
- Give a fourth point if the program is self-contained and highly relevant to teaching JavaScript. It should be similar to a school exercise, a tutorial, or a JavaScript course section.
- Grant a fifth point if the program is outstanding in its educational value and is perfectly suited for teaching JavaScript. It should be well-written, easy to understand, and contain step-by-step explanations and comments.
The extract:
/*
For pagination:
Have a global page number variable:
var pageNumber = 1;
- This page number variable will be reset every time the user hits search... this means the first line of runQuery can be :
pageNumber = 1;
The below for loop will look like this:
const numberOfResultsPerPage = 5;
for (var i = 0 + numberOfResultsPerPage * (pageNumber - 1); i < numberOfResultsPerPage * (pageNumber); i++) {
console.log(filteredBorrowers.length);
fetchBlob(filteredBorrowers[i]);
}
Next steps:
Create next page button
onclick = function() {
// extra credit: Don't let the pages be too big or small
pageNumber = pageNumber + 1;
renderResults();
// same as pageNumber += 1;
}
*/
// create a borrowers variable to later assign it to borrowers.json database
var borrowers;
$(function () {
//initAutocomplete() to execute Google Map functionalities
$(document).ready(function ($) {
initAutocomplete();
});
// use fetch to retrieve borrowers.json database, and report any errors that occur in the fetch operation
// once the borrowers have been successfully loaded and formatted as a JSON object
// using response.json(), run the initialize() function
fetch('borrowers.json').then(function (response) {
if (response.ok) {
response.json().then(function (json) {
borrowers = json;
initialize();
});
} else {
console.log('Network request for borrowers.json failed with response '
+ response.status + ': ' + response.statusText);
}
});
})
// Reset button that clears all search filters and returns all borrowers info //
// SEARCH FEATURES //
// reads filters and searchbox then filter json
function runQuery() {
var borrowerType = document.querySelector('.borrower-type').value;
let doesBorrowerTypeExist;
if (borrowerType === '') {
doesBorrowerTypeExist = false;
} else {
doesBorrowerTypeExist = true;
After examining the extract:
- Briefly justify your total score, up to 100 words.
- Conclude with the score using the format: "Educational score: <total points>"
| javascript | 2 | /*
For pagination:
Have a global page number variable:
var pageNumber = 1;
- This page number variable will be reset every time the user hits search... this means the first line of runQuery can be :
pageNumber = 1;
The below for loop will look like this:
const numberOfResultsPerPage = 5;
for (var i = 0 + numberOfResultsPerPage * (pageNumber - 1); i < numberOfResultsPerPage * (pageNumber); i++) {
console.log(filteredBorrowers.length);
fetchBlob(filteredBorrowers[i]);
}
Next steps:
Create next page button
onclick = function() {
// extra credit: Don't let the pages be too big or small
pageNumber = pageNumber + 1;
renderResults();
// same as pageNumber += 1;
}
*/
// create a borrowers variable to later assign it to borrowers.json database
var borrowers;
$(function () {
//initAutocomplete() to execute Google Map functionalities
$(document).ready(function ($) {
initAutocomplete();
});
// use fetch to retrieve borrowers.json database, and report any errors that occur in the fetch operation
// once the borrowers have been successfully loaded and formatted as a JSON object
// using response.json(), run the initialize() function
fetch('borrowers.json').then(function (response) {
if (response.ok) {
response.json().then(function (json) {
borrowers = json;
initialize();
});
} else {
console.log('Network request for borrowers.json failed with response '
+ response.status + ': ' + response.statusText);
}
});
})
// Reset button that clears all search filters and returns all borrowers info //
// SEARCH FEATURES //
// reads filters and searchbox then filter json
function runQuery() {
var borrowerType = document.querySelector('.borrower-type').value;
let doesBorrowerTypeExist;
if (borrowerType === '') {
doesBorrowerTypeExist = false;
} else {
doesBorrowerTypeExist = true;
}
var sector = document.querySelector('.sector').value;
let doesSectorExist;
if (sector === '') {
doesSectorExist = false;
} else {
doesSectorExist = true;
}
var searchTerm = document.querySelector('.search-term').value;
let doesSearchTermsExist;
if (searchTerm === '') {
doesSearchTermsExist = false;
} else {
doesSearchTermsExist = true;
}
let filteredBorrowers
// Filter by type
filteredBorrowers = borrowers.filter(function (borrower) {
// if (doesBorrowerTypeExist) {
// if (borrower.type !== borrowerType) {
// return false;
// }
// }
if (doesBorrowerTypeExist && (borrower.type !== borrowerType)) {
return false;
}
// Then Filter by sector
if (doesSectorExist && (borrower.sector !== sector)) {
return false;
}
// Then Filter by search term
if (doesSearchTermsExist && (!borrower.keywords.includes(searchTerm))) {
return false;
}
return true;
});
finalGroup = filteredBorrowers;
renderResults();
}
// clear and generate new results //
function renderResults() {
// start the process of updating the display with the new set of borrowers
// remove the previous contents of the <main> element
while (main.firstChild) {
main.removeChild(main.firstChild);
}
// if no borrowers match the search term, display a "No results to display" message
if (finalGroup.length === 0) {
var para = document.createElement('p');
para.textContent = 'No results to display!';
main.appendChild(para);
// for each borrower we want to display, pass its borrower object to fetchBlob()
} else {
for (var i = 0; i < finalGroup.length; i++) {
fetchBlob(finalGroup[i]);
}
}
}
function fetchBlob(borrower) {
showResult(borrower);
}
// Display a borrower inside the <main> element
function showResult(borrower) {
// create sub-elements inside <main>
var section = document.createElement('section');
var heading = document.createElement('h1');
var titles = document.createElement('h2');
var description = document.createElement('p2');
var para = document.createElement('p');
var image = document.createElement('img');
var website = document.createElement('a1');
var kiva = document.createElement('a2');
// give the <section> a classname equal to the borrower "type" property so it will display the correct icon
// section.setAttribute('class', borrower.type);
// Give values to newly created elements
heading.textContent = borrower.name;
description.innerText = borrower.sector;
titles.innerText = "Business Name:" + "\n" + "Address:" + "\n" + " " + "\n" + "Phone:" + "\n" + "Email:";
para.innerText = borrower.businessName + "\n" + borrower.address1 + "\n" +
borrower.address2 + "\n" + borrower.phone + "\n" + borrower.email;
image.src = borrower.image;
website.innerHTML = ("Website").link(borrower.website);
kiva.innerHTML = ("<NAME>").link(borrower.kivaLink);
// append the elements to the DOM as appropriate, to add the borrower to the UI
main.appendChild(section);
section.appendChild(heading);
section.appendChild(titles);
section.appendChild(description);
section.appendChild(para);
section.appendChild(image);
section.appendChild(website);
section.appendChild(kiva);
}
// sets up the app logic, declares required variables, contains all the other functions
function initialize() {
var borrowerType = document.querySelector('.borrower-type');
var sector = document.querySelector('.sector');
var searchTerm = document.querySelector('.search-term');
var searchButton = document.querySelector('.search-button');
main = document.querySelector('main');
// keep a record of what the last filters entered were
var lastBorrowerType = borrowerType.value;
var lastSector = sector.value;
var lastSearchTerm = ''; //since no search term had been entered yet
// typeGroup and sectorGroup contain results after filtering by borrower type, sector, and search term
// finalGroup will contain the borrowers that need to be displayed after
// the searching has been done. Each will be an array containing objects.
// Each object will represent a borrower
var typeGroup;
var sectorGroup;
var finalGroup;
// To start with, set finalGroup to equal the entire borrowers.json database
// then run updateDisplay(), so ALL borrowers are displayed initially.
finalGroup = borrowers;
updateDisplay();
// Set both to equal an empty array, in time for searches to be run
typeGroup = [];
sectorGroup = [];
finalGroup = [];
// when the search button is clicked, invoke selectCategory() to start
// a search running to select the category of products we want to display
$(document).on('click', '.search-button', function () {
/* Homework
1. runQuery() here and save the filtered results as a global `filteredResults`
2. Fill out a renderResults() function and have it clear out `.main` and re-generate the results from the global `filteredResults`
*/
selectType();
});
// when the reset button is clicked, set finalGroup equals to database
//then invoke UpdateDisplay() to display all borrowers
$(document).on('click', '.reset-button', function () {
finalGroup = borrowers;
updateDisplay();
// also reset the selected value and entered search term to default
$(".borrower-type").each(function () { this.selectedIndex = 0 });
$(".sector").each(function () { this.selectedIndex = 0 });
$(".search-term").val("");
});
function selectType() {
// Set these back to empty arrays, to clear out the previous search
typeGroup = [];
sectorGroup = [];
finalGroup = [];
// if the category and search term are the same as they were the last time a
// search was run, the results will be the same, so there is no point running
// it again — just return out of the function
if (borrowerType.value === lastBorrowerType && sector.value ===
lastSector && searchTerm.value.trim() === lastSearchTerm) {
return;
} else {
// update the record of last category and search term
lastBorrowerType = borrowerType.value;
lastSector = sector.value;
lastSearchTerm = searchTerm.value.trim();
// In this case we want to select all borrowerss, then filter them by the search
// term, so we just set categoryGroup to the entire JSON object, then run selectSector()
if (borrowerType.value === 'All' || borrowerType.value === 'Borrower Type') {
typeGroup = borrowers;
selectSector();
// If a specific category is chosen, we need to filter out the borrowerss not in that
// category, then put the remaining borrowerss inside categoryGroup, before running
// selectSecotr()
} else {
// the values in the <option> elements are uppercase, whereas the categories
// store in the JSON (under "type") are lowercase. We therefore need to convert
// to lower case before we do a comparison
for (var i = 0; i < borrowers.length; i++) {
// If a borrower's type property is the same as the chosen category, we want to
// dispay it, so we push it onto the categoryGroup array
if (borrowers[i].type === borrowerType.value) {
typeGroup.push(borrowers[i]);
}
}
// Run selectSector() after the filtering has been done
selectSector();
}
}
}
function selectSector() {
lastBorrowerType = borrowerType.value;
lastSector = sector.value;
lastSearchTerm = searchTerm.value.trim();
if (sector.value === 'All' || sector.value === 'Business Sector') {
finalGroup = typeGroup;
updateDisplay();
// If a specific category is chosen, we need to filter out the borrowers not in that
// category, then put the remaining borrowers inside categoryGroup, before running
// selectTerms()
} else {
for (var i = 0; i < borrowers.length; i++) {
// If a borrower's type property is the same as the chosen category, we want to
// dispay it, so we push it onto the categoryGroup array
if (borrowers[i].sector === sector.value) {
sectorGroup.push(typeGroup[i]);
}
// run selectTerms() after this second round of filtering has been done
selectTerms();
}
}
}
// selectTerms() Takes the group of borrowers selected by selectCategory(), and further
// filters them by the tnered search term (if one has bene entered)
function selectTerms() {
lastBorrowerType = borrowerType.value;
lastSector = sector.value;
lastSearchTerm = searchTerm.value.trim();
// If no search term has been entered, just make the finalGroup array equal to the categoryGroup
// array — we don't want to filter the borrowers further — then run updateDisplay().
if (searchTerm.value.trim() === '') {
finalGroup = sectorGroup;
updateDisplay();
} else {
// Make sure the search term is converted to lower case before comparison. We've kept the
// borrower names all lower case to keep things simple
var lowerCaseSearchTerm = searchTerm.value.trim().toLowerCase();
// For each borrower in categoryGroup, see if the search term is contained inside the borrower name
// (if the indexOf() result doesn't return -1, it means it is) — if it is, then push the borrower
// onto the finalGroup array -- sectorGroup[i].keywords.indexOf(lowerCaseSearchTerm) !== -1
for (var i = 0; i < sectorGroup.length; i++) {
if (sectorGroup.includes(sectorGroup[i].keywords)) {
finalGroup.push(sectorGroup[i]);
}
}
// run updateDisplay() after this last round of filtering has been done
updateDisplay();
}
}
// start the process of updating the display with the new set of borrowers
function updateDisplay() {
// remove the previous contents of the <main> element
while (main.firstChild) {
main.removeChild(main.firstChild);
}
// if no borrowers match the search term, display a "No results to display" message
if (finalGroup.length === 0) {
var para = document.createElement('p');
para.textContent = 'No results to display!';
main.appendChild(para);
// for each borrower we want to display, pass its borrower object to fetchBlob()
} else {
for (var i = 0; i < finalGroup.length; i++) {
fetchBlob(finalGroup[i]);
}
}
}
function fetchBlob(borrower) {
showResult(borrower);
}
// Display a borrower inside the <main> element
function showResult(borrower) {
// create sub-elements inside <main>
var section = document.createElement('section');
var heading = document.createElement('h1');
var titles = document.createElement('h2');
var description = document.createElement('p2');
var para = document.createElement('p');
var image = document.createElement('img');
var website = document.createElement('a1');
var kiva = document.createElement('a2');
// give the <section> a classname equal to the borrower "type" property so it will display the correct icon
// section.setAttribute('class', borrower.type);
// Give values to newly created elements
heading.textContent = borrower.name;
description.innerText = borrower.sector;
titles.innerText = "Business Name:" + "\n" + "Address:" + "\n" + " " + "\n" + "Phone:" + "\n" + "Email:";
para.innerText = borrower.businessName + "\n" + borrower.address1 + "\n" +
borrower.address2 + "\n" + borrower.phone + "\n" + borrower.email;
image.src = borrower.image;
website.innerHTML = ("Website").link(borrower.website);
kiva.innerHTML = ("<NAME>").link(borrower.kivaLink);
// append the elements to the DOM as appropriate, to add the borrower to the UI
main.appendChild(section);
section.appendChild(heading);
section.appendChild(titles);
section.appendChild(description);
section.appendChild(para);
section.appendChild(image);
section.appendChild(website);
section.appendChild(kiva);
}
}
// MAP //
function initAutocomplete() {
var map = new google.maps.Map(document.getElementById('map'), {
center: { lat: 37.321488, lng: -121.878506 },
zoom: 13,
mapTypeId: 'roadmap'
});
// Create the search box and link it to the UI element.
var input = document.getElementById('pac-input');
var searchBox = new google.maps.places.SearchBox(input);
map.controls[google.maps.ControlPosition.TOP_LEFT].push(input);
// Bias the SearchBox results towards current map's viewport.
map.addListener('bounds_changed', function () {
searchBox.setBounds(map.getBounds());
});
var markers = [];
// Listen for the event fired when the user selects a prediction and retrieve
// more details for that place.
searchBox.addListener('places_changed', function () {
var places = searchBox.getPlaces();
if (places.length == 0) {
return;
}
// Clear out the old markers.
markers.forEach(function (marker) {
marker.setMap(null);
});
markers = [];
// For each place, get the icon, name and location.
var bounds = new google.maps.LatLngBounds();
places.forEach(function (place) {
if (!place.geometry) {
console.log("Returned place contains no geometry");
return;
}
var icon = {
url: place.icon,
size: new google.maps.Size(71, 71),
origin: new google.maps.Point(0, 0),
anchor: new google.maps.Point(17, 34),
scaledSize: new google.maps.Size(25, 25)
};
// Create a marker for each place.
markers.push(new google.maps.Marker({
map: map,
icon: icon,
title: place.name,
position: place.geometry.location
}));
if (place.geometry.viewport) {
// Only geocodes have viewport.
bounds.union(place.geometry.viewport);
} else {
bounds.extend(place.geometry.location);
}
});
map.fitBounds(bounds);
});
} |
Below is an extract from a PHP program. Evaluate whether it has a high educational value and could help teach coding. Use the additive 5-point scoring system described below. Points are accumulated based on the satisfaction of each criterion:
- Add 1 point if the program contains valid PHP code, even if it's not educational, like boilerplate code, configurations, or niche concepts.
- Add another point if the program addresses practical PHP concepts, even if it lacks comments.
- Award a third point if the program is suitable for educational use and introduces key concepts in programming, even if the topic is advanced (e.g., object-oriented programming, namespaces). The code should be well-structured and contain some comments.
- Give a fourth point if the program is self-contained and highly relevant to teaching PHP. It should be similar to a school exercise, a tutorial, or a PHP course section.
- Grant a fifth point if the program is outstanding in its educational value and is perfectly suited for teaching PHP. It should be well-written, easy to understand, and contain step-by-step explanations and comments.
The extract:
<?php
namespace SuusApi\Client;
class LineAddress
{
/**
* @var string $lp
*/
protected $lp = null;
/**
* @var string $type
*/
protected $type = null;
/**
* @var string $name
*/
protected $name = null;
/**
* @var string $street
*/
protected $street = null;
/**
* @var string $streetNo
*/
protected $streetNo = null;
/**
* @var string $postCode
*/
protected $postCode = null;
/**
* @var string $city
*/
protected $city = null;
/**
* @var string $country
*/
protected $country = null;
/**
* @var date $dateFrom
*/
protected $dateFrom = null;
/**
* @var string $timeFrom
*/
protected $timeFrom = null;
/**
* @var string $dateTo
*/
protected $dateTo = null;
/**
* @var string $timeTo
*/
protected $timeTo = null;
/**
* @var string $cargo
*/
protected $cargo = null;
/**
* @var boolean $fullTruck
*/
protected $fullTruck = null;
/**
* @var string $symbol
*/
protected $symbol = null;
/**
* @var int $quantity
*/
protected $quantity = null;
/**
* @var float $weightKg
*/
protected $weightKg = null;
/**
* @var float $lenghtM
*/
protected $lenghtM = null;
/**
* @var float $widthM
*/
protected $widthM = null;
/**
* @var float $heightM
*/
protected $heightM = null;
/**
* @var float $loadingMeters
*/
protected $loadingMeters = null;
/**
* @var string $reference
*/
protected $reference = null;
/**
* @param string $lp
* @param string $type
* @param string $name
* @param string $street
* @param string $streetNo
* @param string $postCode
* @param string $city
* @param string $country
* @param boolean $fullTruck
* @param string $sy
After examining the extract:
- Briefly justify your total score, up to 100 words.
- Conclude with the score using the format: "Educational score: <total points>"
| php | 2 | <?php
namespace SuusApi\Client;
class LineAddress
{
/**
* @var string $lp
*/
protected $lp = null;
/**
* @var string $type
*/
protected $type = null;
/**
* @var string $name
*/
protected $name = null;
/**
* @var string $street
*/
protected $street = null;
/**
* @var string $streetNo
*/
protected $streetNo = null;
/**
* @var string $postCode
*/
protected $postCode = null;
/**
* @var string $city
*/
protected $city = null;
/**
* @var string $country
*/
protected $country = null;
/**
* @var date $dateFrom
*/
protected $dateFrom = null;
/**
* @var string $timeFrom
*/
protected $timeFrom = null;
/**
* @var string $dateTo
*/
protected $dateTo = null;
/**
* @var string $timeTo
*/
protected $timeTo = null;
/**
* @var string $cargo
*/
protected $cargo = null;
/**
* @var boolean $fullTruck
*/
protected $fullTruck = null;
/**
* @var string $symbol
*/
protected $symbol = null;
/**
* @var int $quantity
*/
protected $quantity = null;
/**
* @var float $weightKg
*/
protected $weightKg = null;
/**
* @var float $lenghtM
*/
protected $lenghtM = null;
/**
* @var float $widthM
*/
protected $widthM = null;
/**
* @var float $heightM
*/
protected $heightM = null;
/**
* @var float $loadingMeters
*/
protected $loadingMeters = null;
/**
* @var string $reference
*/
protected $reference = null;
/**
* @param string $lp
* @param string $type
* @param string $name
* @param string $street
* @param string $streetNo
* @param string $postCode
* @param string $city
* @param string $country
* @param boolean $fullTruck
* @param string $symbol
* @param int $quantity
* @param float $weightKg
* @param float $lenghtM
* @param float $widthM
* @param float $heightM
* @param float $loadingMeters
* @param string $reference
*/
public function __construct($lp, $type, $name, $street, $streetNo, $postCode, $city, $country, $fullTruck, $symbol, $quantity, $weightKg, $lenghtM, $widthM, $heightM, $loadingMeters, $reference)
{
$this->lp = $lp;
$this->type = $type;
$this->name = $name;
$this->street = $street;
$this->streetNo = $streetNo;
$this->postCode = $postCode;
$this->city = $city;
$this->country = $country;
$this->fullTruck = $fullTruck;
$this->symbol = $symbol;
$this->quantity = $quantity;
$this->weightKg = $weightKg;
$this->lenghtM = $lenghtM;
$this->widthM = $widthM;
$this->heightM = $heightM;
$this->loadingMeters = $loadingMeters;
$this->reference = $reference;
}
/**
* @return string
*/
public function getLp()
{
return $this->lp;
}
/**
* @param string $lp
* @return \SuusApi\Client\LineAddress
*/
public function setLp($lp)
{
$this->lp = $lp;
return $this;
}
/**
* @return string
*/
public function getType()
{
return $this->type;
}
/**
* @param string $type
* @return \SuusApi\Client\LineAddress
*/
public function setType($type)
{
$this->type = $type;
return $this;
}
/**
* @return string
*/
public function getName()
{
return $this->name;
}
/**
* @param string $name
* @return \SuusApi\Client\LineAddress
*/
public function setName($name)
{
$this->name = $name;
return $this;
}
/**
* @return string
*/
public function getStreet()
{
return $this->street;
}
/**
* @param string $street
* @return \SuusApi\Client\LineAddress
*/
public function setStreet($street)
{
$this->street = $street;
return $this;
}
/**
* @return string
*/
public function getStreetNo()
{
return $this->streetNo;
}
/**
* @param string $streetNo
* @return \SuusApi\Client\LineAddress
*/
public function setStreetNo($streetNo)
{
$this->streetNo = $streetNo;
return $this;
}
/**
* @return string
*/
public function getPostCode()
{
return $this->postCode;
}
/**
* @param string $postCode
* @return \SuusApi\Client\LineAddress
*/
public function setPostCode($postCode)
{
$this->postCode = $postCode;
return $this;
}
/**
* @return string
*/
public function getCity()
{
return $this->city;
}
/**
* @param string $city
* @return \SuusApi\Client\LineAddress
*/
public function setCity($city)
{
$this->city = $city;
return $this;
}
/**
* @return string
*/
public function getCountry()
{
return $this->country;
}
/**
* @param string $country
* @return \SuusApi\Client\LineAddress
*/
public function setCountry($country)
{
$this->country = $country;
return $this;
}
/**
* @return date
*/
public function getDateFrom()
{
return $this->dateFrom;
}
/**
* @param date $dateFrom
* @return \SuusApi\Client\LineAddress
*/
public function setDateFrom($dateFrom)
{
$this->dateFrom = $dateFrom;
return $this;
}
/**
* @return string
*/
public function getTimeFrom()
{
return $this->timeFrom;
}
/**
* @param string $timeFrom
* @return \SuusApi\Client\LineAddress
*/
public function setTimeFrom($timeFrom)
{
$this->timeFrom = $timeFrom;
return $this;
}
/**
* @return string
*/
public function getDateTo()
{
return $this->dateTo;
}
/**
* @param string $dateTo
* @return \SuusApi\Client\LineAddress
*/
public function setDateTo($dateTo)
{
$this->dateTo = $dateTo;
return $this;
}
/**
* @return string
*/
public function getTimeTo()
{
return $this->timeTo;
}
/**
* @param string $timeTo
* @return \SuusApi\Client\LineAddress
*/
public function setTimeTo($timeTo)
{
$this->timeTo = $timeTo;
return $this;
}
/**
* @return string
*/
public function getCargo()
{
return $this->cargo;
}
/**
* @param string $cargo
* @return \SuusApi\Client\LineAddress
*/
public function setCargo($cargo)
{
$this->cargo = $cargo;
return $this;
}
/**
* @return boolean
*/
public function getFullTruck()
{
return $this->fullTruck;
}
/**
* @param boolean $fullTruck
* @return \SuusApi\Client\LineAddress
*/
public function setFullTruck($fullTruck)
{
$this->fullTruck = $fullTruck;
return $this;
}
/**
* @return string
*/
public function getSymbol()
{
return $this->symbol;
}
/**
* @param string $symbol
* @return \SuusApi\Client\LineAddress
*/
public function setSymbol($symbol)
{
$this->symbol = $symbol;
return $this;
}
/**
* @return int
*/
public function getQuantity()
{
return $this->quantity;
}
/**
* @param int $quantity
* @return \SuusApi\Client\LineAddress
*/
public function setQuantity($quantity)
{
$this->quantity = $quantity;
return $this;
}
/**
* @return float
*/
public function getWeightKg()
{
return $this->weightKg;
}
/**
* @param float $weightKg
* @return \SuusApi\Client\LineAddress
*/
public function setWeightKg($weightKg)
{
$this->weightKg = $weightKg;
return $this;
}
/**
* @return float
*/
public function getLenghtM()
{
return $this->lenghtM;
}
/**
* @param float $lenghtM
* @return \SuusApi\Client\LineAddress
*/
public function setLenghtM($lenghtM)
{
$this->lenghtM = $lenghtM;
return $this;
}
/**
* @return float
*/
public function getWidthM()
{
return $this->widthM;
}
/**
* @param float $widthM
* @return \SuusApi\Client\LineAddress
*/
public function setWidthM($widthM)
{
$this->widthM = $widthM;
return $this;
}
/**
* @return float
*/
public function getHeightM()
{
return $this->heightM;
}
/**
* @param float $heightM
* @return \SuusApi\Client\LineAddress
*/
public function setHeightM($heightM)
{
$this->heightM = $heightM;
return $this;
}
/**
* @return float
*/
public function getLoadingMeters()
{
return $this->loadingMeters;
}
/**
* @param float $loadingMeters
* @return \SuusApi\Client\LineAddress
*/
public function setLoadingMeters($loadingMeters)
{
$this->loadingMeters = $loadingMeters;
return $this;
}
/**
* @return string
*/
public function getReference()
{
return $this->reference;
}
/**
* @param string $reference
* @return \SuusApi\Client\LineAddress
*/
public function setReference($reference)
{
$this->reference = $reference;
return $this;
}
}
|
Below is an extract from a Java program. Evaluate whether it has a high educational value and could help teach coding. Use the additive 5-point scoring system described below. Points are accumulated based on the satisfaction of each criterion:
- Add 1 point if the program contains valid Java code, even if it's not educational, like boilerplate code, configurations, or niche concepts.
- Add another point if the program addresses practical Java concepts, even if it lacks comments.
- Award a third point if the program is suitable for educational use and introduces key concepts in programming, even if the topic is advanced (e.g., concurrent programming). The code should be well-structured and contain some comments.
- Give a fourth point if the program is self-contained and highly relevant to teaching Java. It should be similar to a school exercise, a tutorial, or a Java course section.
- Grant a fifth point if the program is outstanding in its educational value and is perfectly suited for teaching Java. It should be well-written, easy to understand, and contain step-by-step explanations and comments.
The extract:
import java.util.Scanner;
public class Family
{
private static String sur_name;
private String first_name, last_name;
private int year_of_birth;
public static void getSurName()
{
Scanner inputTaker = new Scanner(System.in);
System.out.println("Enter the family name : ");
sur_name = inputTaker.nextLine();
}
public void input()
{
Scanner myScanner = new Scanner(System.in);
System.out.println("\nFirstName : ");
first_name = myScanner.nextLine();
System.out.println("\nLastName : ");
last_name = myScanner.nextLine();
System.out.println("\nYear of birth : ");
year_of_birth =myScanner.nextInt();
}
public void output()
{
System.out.println("\nLastName : "+last_name);
System.out.println("\nFirstName : "+first_name);
System.out.println("\nSurName : "+sur_name);
System.out.println("\nYear of Birth : "+year_of_birth);
}
}
After examining the extract:
- Briefly justify your total score, up to 100 words.
- Conclude with the score using the format: "Educational score: <total points>"
| java | 2 | import java.util.Scanner;
public class Family
{
private static String sur_name;
private String first_name, last_name;
private int year_of_birth;
public static void getSurName()
{
Scanner inputTaker = new Scanner(System.in);
System.out.println("Enter the family name : ");
sur_name = inputTaker.nextLine();
}
public void input()
{
Scanner myScanner = new Scanner(System.in);
System.out.println("\nFirstName : ");
first_name = myScanner.nextLine();
System.out.println("\nLastName : ");
last_name = myScanner.nextLine();
System.out.println("\nYear of birth : ");
year_of_birth =myScanner.nextInt();
}
public void output()
{
System.out.println("\nLastName : "+last_name);
System.out.println("\nFirstName : "+first_name);
System.out.println("\nSurName : "+sur_name);
System.out.println("\nYear of Birth : "+year_of_birth);
}
}
|
Below is an extract from a Rust program. Evaluate whether it has a high educational value and could help teach coding. Use the additive 5-point scoring system described below. Points are accumulated based on the satisfaction of each criterion:
- Add 1 point if the program contains valid Rust code, even if it's not educational, like boilerplate code, configurations, or niche concepts.
- Add another point if the program addresses practical Rust concepts, even if it lacks comments.
- Award a third point if the program is suitable for educational use and introduces key concepts in programming, even if the topic is advanced (e.g., ownership, lifetimes). The code should be well-structured and contain some comments.
- Give a fourth point if the program is self-contained and highly relevant to teaching Rust. It should be similar to a school exercise, a tutorial, or a Rust course section.
- Grant a fifth point if the program is outstanding in its educational value and is perfectly suited for teaching Rust. It should be well-written, easy to understand, and contain step-by-step explanations and comments.
The extract:
use crate::{
components::{GridLocation, Thing, ThingTape},
resources::RewindableClock,
utils::{move_tape_backwards, move_tape_forwards},
};
use amethyst::{
derive::SystemDesc,
ecs::prelude::{Join, Read, System, SystemData, WriteStorage},
};
#[derive(SystemDesc)]
pub struct ThingTapeSystem;
impl<'s> System<'s> for ThingTapeSystem {
type SystemData = (
Read<'s, RewindableClock>,
WriteStorage<'s, Thing>,
WriteStorage<'s, GridLocation>,
WriteStorage<'s, ThingTape>,
);
fn run(&mut self, (clock, mut things, mut grid_locations, mut thing_tapes): Self::SystemData) {
if clock.velocity == 0 {
return;
}
for (thing, thing_grid_location, thing_tape) in
(&mut things, &mut grid_locations, &mut thing_tapes).join()
{
let snapshots = &mut thing_tape.snapshots;
if clock.going_forwards() {
debug!("Going forwards");
move_tape_forwards(snapshots, thing_grid_location, thing);
} else {
debug!("Going backward");
move_tape_backwards(snapshots, thing_grid_location, thing);
}
}
}
}
After examining the extract:
- Briefly justify your total score, up to 100 words.
- Conclude with the score using the format: "Educational score: <total points>"
| rust | 2 | use crate::{
components::{GridLocation, Thing, ThingTape},
resources::RewindableClock,
utils::{move_tape_backwards, move_tape_forwards},
};
use amethyst::{
derive::SystemDesc,
ecs::prelude::{Join, Read, System, SystemData, WriteStorage},
};
#[derive(SystemDesc)]
pub struct ThingTapeSystem;
impl<'s> System<'s> for ThingTapeSystem {
type SystemData = (
Read<'s, RewindableClock>,
WriteStorage<'s, Thing>,
WriteStorage<'s, GridLocation>,
WriteStorage<'s, ThingTape>,
);
fn run(&mut self, (clock, mut things, mut grid_locations, mut thing_tapes): Self::SystemData) {
if clock.velocity == 0 {
return;
}
for (thing, thing_grid_location, thing_tape) in
(&mut things, &mut grid_locations, &mut thing_tapes).join()
{
let snapshots = &mut thing_tape.snapshots;
if clock.going_forwards() {
debug!("Going forwards");
move_tape_forwards(snapshots, thing_grid_location, thing);
} else {
debug!("Going backward");
move_tape_backwards(snapshots, thing_grid_location, thing);
}
}
}
}
|
Below is an extract from a JavaScript program. Evaluate whether it has a high educational value and could help teach coding. Use the additive 5-point scoring system described below. Points are accumulated based on the satisfaction of each criterion:
- Add 1 point if the program contains valid JavaScript code, even if it's not educational, like boilerplate code, configurations, or niche concepts.
- Add another point if the program addresses practical JavaScript concepts, even if it lacks comments.
- Award a third point if the program is suitable for educational use and introduces key concepts in programming, even if the topic is advanced (e.g., asynchronous programming). The code should be well-structured and contain some comments.
- Give a fourth point if the program is self-contained and highly relevant to teaching JavaScript. It should be similar to a school exercise, a tutorial, or a JavaScript course section.
- Grant a fifth point if the program is outstanding in its educational value and is perfectly suited for teaching JavaScript. It should be well-written, easy to understand, and contain step-by-step explanations and comments.
The extract:
import React, { Component } from 'react';
import styled from 'styled-components';
import { BrowserRouter, Route, Switch } from 'react-router-dom';
import ScrollToTop from './ScrollToTop';
import PokemonList from './PokemonList';
import PokemonDetails from './PokemonDetails';
import Header from './Header';
const StyledApp = styled.div`
text-align: center;
margin: 0 auto;
.page {
margin-top: 80px;
margin-left: 5%;
margin-right: 5%;
z-index: 0;
}
`;
class App extends Component {
render() {
return (
<BrowserRouter>
<ScrollToTop>
<StyledApp>
<Header />
<div className="page">
<Switch>
<Route path="/" exact component={PokemonList} />
<Route path="/pokemon/:name" component={PokemonDetails} />
</Switch>
</div>
</StyledApp>
</ScrollToTop>
</BrowserRouter>
);
}
}
export default App;
After examining the extract:
- Briefly justify your total score, up to 100 words.
- Conclude with the score using the format: "Educational score: <total points>"
| javascript | 2 | import React, { Component } from 'react';
import styled from 'styled-components';
import { BrowserRouter, Route, Switch } from 'react-router-dom';
import ScrollToTop from './ScrollToTop';
import PokemonList from './PokemonList';
import PokemonDetails from './PokemonDetails';
import Header from './Header';
const StyledApp = styled.div`
text-align: center;
margin: 0 auto;
.page {
margin-top: 80px;
margin-left: 5%;
margin-right: 5%;
z-index: 0;
}
`;
class App extends Component {
render() {
return (
<BrowserRouter>
<ScrollToTop>
<StyledApp>
<Header />
<div className="page">
<Switch>
<Route path="/" exact component={PokemonList} />
<Route path="/pokemon/:name" component={PokemonDetails} />
</Switch>
</div>
</StyledApp>
</ScrollToTop>
</BrowserRouter>
);
}
}
export default App;
|
Below is an extract from an HTML document. Evaluate whether it has a high educational value and could help teach web development. Use the additive 5-point scoring system described below. Points are accumulated based on the satisfaction of each criterion:
- Add 1 point if the document contains valid HTML markup, even if it's not educational, like boilerplate code or standard tags.
- Add another point if the document addresses practical HTML concepts and uses semantic elements appropriately.
- Award a third point if the document is suitable for educational use and introduces key web concepts, even if the topic is somewhat advanced (e.g., forms, metadata). The code should be well-structured and use clear, descriptive naming.
- Give a fourth point if the document is self-contained and highly relevant to teaching HTML. It should be similar to a school exercise, a tutorial, or an HTML course section for early learners.
- Grant a fifth point if the document is outstanding in its educational value and is perfectly suited for teaching HTML to beginners. It should be well-organized, easy to understand, and ideally include some explanatory comments or demonstrate best practices in HTML structure.
The extract:
---
layout: post
title: 登録日と更新日のフィールドがあって、その中で一番新しい日付を一発でセレクトするクエリー（CASE文とMAX）
date: '2012-07-01T06:55:00.001+09:00'
author: <NAME>
tags:
- Postgres
modified_time: '2012-07-01T06:55:30.409+09:00'
blogger_id: tag:blogger.com,1999:blog-2052559951721308867.post-380298435368333858
blogger_orig_url: http://uedatakeshi.blogspot.com/2012/07/casemax.html
---
<h1>登録日と更新日のフィールドがあって、その中で一番新しい日付を一発でセレクトするクエリー（CASE文とMAX）</h1><p>登録日が created で、更新日が modified で、データを新規登録した時にね、<br />
created には insert するけど、modified にはしない。<br />
本当に編集した時だけ modified に入れるようなプログラムになってたとするじゃないですか。<br />
</p><p>そうするとデータはこんな感じになる訳で。<br />
<br />
<pre class="brush: shell"> created | modified
----------------------------+----------------------------
2009-03-17 10:18:24.792449 | 2009-03-17 10:32:55.900294
2009-03-25 19:32:18.205694 |
2009-03-26 14:44:18.787866 |
2009-03-30 16:56:56.128813 |
2012-06-22 18:26:11.540513 |
2012-06-23 12:18:09.649044 |
2012-06-22 18:26:37.815316 | 2012-06-26 15:07:45.34223
2012-06-21 12:46:03.151537 | 2012-06-26 16:44:05.811683
2012-06-26 19:05:44.473284 | 2012-06-26 20:15:18.196717
</pre> <br />
modified は NULL になってるデータがある訳です。</p><p>こういう状態で、更新があった一番新しい日付をセレクトせよ、ってことなんですが。。。</p> <br />
<pre class="brush: sql"> SELECT MAX(CASE WHEN modified IS NULL THEN created ELSE modified END) AS dates FROM items;
</pre> <br />
<p>これでこうなる。 <br />
<pre class="brush: shell"> dates
----------------------------
2012-06-26 20:15:18.196717
(1 row)
</pre>まあ、最初っから両方入れとけよって話ですね。</p><br />
<br />
After examining the extract:
- Briefly justify your total score, up to 100 words.
- Conclude with the score using the format: "Educational score: <total points>"
| html | 1 | ---
layout: post
title: 登録日と更新日のフィールドがあって、その中で一番新しい日付を一発でセレクトするクエリー（CASE文とMAX）
date: '2012-07-01T06:55:00.001+09:00'
author: <NAME>
tags:
- Postgres
modified_time: '2012-07-01T06:55:30.409+09:00'
blogger_id: tag:blogger.com,1999:blog-2052559951721308867.post-380298435368333858
blogger_orig_url: http://uedatakeshi.blogspot.com/2012/07/casemax.html
---
<h1>登録日と更新日のフィールドがあって、その中で一番新しい日付を一発でセレクトするクエリー（CASE文とMAX）</h1><p>登録日が created で、更新日が modified で、データを新規登録した時にね、<br />
created には insert するけど、modified にはしない。<br />
本当に編集した時だけ modified に入れるようなプログラムになってたとするじゃないですか。<br />
</p><p>そうするとデータはこんな感じになる訳で。<br />
<br />
<pre class="brush: shell"> created | modified
----------------------------+----------------------------
2009-03-17 10:18:24.792449 | 2009-03-17 10:32:55.900294
2009-03-25 19:32:18.205694 |
2009-03-26 14:44:18.787866 |
2009-03-30 16:56:56.128813 |
2012-06-22 18:26:11.540513 |
2012-06-23 12:18:09.649044 |
2012-06-22 18:26:37.815316 | 2012-06-26 15:07:45.34223
2012-06-21 12:46:03.151537 | 2012-06-26 16:44:05.811683
2012-06-26 19:05:44.473284 | 2012-06-26 20:15:18.196717
</pre> <br />
modified は NULL になってるデータがある訳です。</p><p>こういう状態で、更新があった一番新しい日付をセレクトせよ、ってことなんですが。。。</p> <br />
<pre class="brush: sql"> SELECT MAX(CASE WHEN modified IS NULL THEN created ELSE modified END) AS dates FROM items;
</pre> <br />
<p>これでこうなる。 <br />
<pre class="brush: shell"> dates
----------------------------
2012-06-26 20:15:18.196717
(1 row)
</pre>まあ、最初っから両方入れとけよって話ですね。</p><br />
<br /> |
Below is an extract from a JavaScript program. Evaluate whether it has a high educational value and could help teach coding. Use the additive 5-point scoring system described below. Points are accumulated based on the satisfaction of each criterion:
- Add 1 point if the program contains valid JavaScript code, even if it's not educational, like boilerplate code, configurations, or niche concepts.
- Add another point if the program addresses practical JavaScript concepts, even if it lacks comments.
- Award a third point if the program is suitable for educational use and introduces key concepts in programming, even if the topic is advanced (e.g., asynchronous programming). The code should be well-structured and contain some comments.
- Give a fourth point if the program is self-contained and highly relevant to teaching JavaScript. It should be similar to a school exercise, a tutorial, or a JavaScript course section.
- Grant a fifth point if the program is outstanding in its educational value and is perfectly suited for teaching JavaScript. It should be well-written, easy to understand, and contain step-by-step explanations and comments.
The extract:
import CustomerDataShareApi from '../customerDataShareApi';
describe("customerDataShareApi", () => {
it('renders Default Page correctly', () => {
expect(true).toBe(true);
});
});
After examining the extract:
- Briefly justify your total score, up to 100 words.
- Conclude with the score using the format: "Educational score: <total points>"
| javascript | 1 |
import CustomerDataShareApi from '../customerDataShareApi';
describe("customerDataShareApi", () => {
it('renders Default Page correctly', () => {
expect(true).toBe(true);
});
});
|
Below is an extract from a C program. Evaluate whether it has a high educational value and could help teach coding. Use the additive 5-point scoring system described below. Points are accumulated based on the satisfaction of each criterion:
- Add 1 point if the program contains valid C code, even if it's not educational, like boilerplate code, configurations, or niche concepts.
- Add another point if the program addresses practical C concepts, even if it lacks comments.
- Award a third point if the program is suitable for educational use and introduces key concepts in programming, even if the topic is advanced (e.g., kernel development and compiler design). The code should be well-structured and contain some comments.
- Give a fourth point if the program is self-contained and highly relevant to teaching C. It should be similar to a school exercise, a tutorial, or a C course section.
- Grant a fifth point if the program is outstanding in its educational value and is perfectly suited for teaching C. It should be well-written, easy to understand, and contain step-by-step explanations and comments.
The extract:
/*
INPUT : FAKE_FLAG_HACK_THE_BOX_01234567
111111111111111111111111111111
COMMAND : gdb -q --args ./coffee_invocation $INPUT
b *0x0000555555554000+0x00001ead
b *0x0000555555554000+0x00001f0a
b *0x0000555555554000+0x00001f2a
b *0x0000555555554000+0x00001b52
b *0x0000555555554000+0x00001b6f
b *0x0000555555554000+0x00001b24
b *0x0000555555554000+0x00001b3b
b *0x5555555556ae
b *0x55555555574e
b *0x555555555793
*/
char peer1_0[] = { /* Packet 1135 */
0x91, 0x03, 0x34, 0xf1, 0x1d, 0x76, 0x44, 0xe3 };
char peer1_1[] = { /* Packet 1142 */
0x01, 0xc1, 0xcc, 0x4b, 0xc0, 0x79, 0xbf, 0x77,
0x70, 0x67, 0x72, 0x3f, 0x82, 0x92, 0x52, 0x13,
0xcb, 0x16, 0x77, 0x2d, 0xd6, 0xdd, 0x4a, 0xca,
0xee, 0xe7, 0xa6, 0x69, 0x3f, 0xef, 0x4e, 0x4c,
0x8d, 0x75, 0xce, 0x31, 0xec, 0xf4, 0xf5, 0x0e,
0xce, 0x7f, 0xd9, 0x9f, 0x84, 0xad, 0xd5, 0xfa,
0xef, 0xee, 0x39, 0x8a, 0x1e, 0x6a, 0xe8, 0x82,
0xf1, 0x00, 0x48, 0x15, 0x95, 0x62, 0x13, 0xa8,
0x06, 0xb9, 0x3b, 0x39, 0xa2, 0xec, 0xf1, 0x0f,
0x1b, 0x1a, 0x0a, 0xf0, 0x7f, 0x84, 0x08, 0xf5,
0x30, 0xa3, 0xdd, 0x53, 0x2c, 0x6e, 0x90, 0x15,
0x18, 0x6e, 0x78, 0x3a, 0x44, 0x32, 0x2e, 0xcd,
0x76, 0x10, 0x37, 0x20, 0x70, 0xf3, 0x95, 0x43,
0x9d, 0xb5, 0xd5, 0x83, 0x14, 0xc2, 0xa4, 0xa9,
0x76, 0x08, 0xb3, 0x0d, 0x08, 0xeb, 0xe3, 0x2c,
0x6d, 0x0c, 0x68, 0xde, 0x12, 0x85, 0x0b, 0x34,
0x93, 0xf9, 0xb2, 0x93, 0xdc, 0xb8, 0x08, 0xd6,
0xd2, 0x6e, 0x74, 0xab, 0x28, 0xc2, 0xd4, 0x3b,
0x8f, 0xc6, 0x04, 0x7a, 0x71, 0x4d, 0x1c, 0x6e,
0x2d, 0xfd, 0xe7, 0x9b, 0xf2, 0x5f, 0xc6, 0x05,
0x1a, 0x98, 0x87, 0x37, 0x15, 0x57, 0xa6, 0x0d,
0x65, 0x37, 0x94, 0x97, 0x84, 0xb1, 0x90, 0x89,
0x27, 0x88, 0x1e, 0xd6, 0x66, 0xbe, 0xfe, 0x9a,
0x9f, 0x89, 0x29, 0x5f, 0x5d, 0x43, 0xd4, 0x80,
0x24, 0xf7, 0x62, 0x68, 0x60, 0xdd, 0x79, 0x4d,
0x69, 0x3f, 0xaf, 0xa8, 0x9f, 0x58, 0xa8, 0xcf,
0xc3, 0xde, 0x03, 0x67, 0xc5, 0x51, 0x1f, 0x6f,
0x36, 0x83, 0x0a, 0xf5, 0xa5, 0xa1, 0xb4, 0x6f,
0x61, 0x19, 0x6d, 0xd2, 0xdf, 0xdc, 0xf4, 0x8e,
0x7d, 0x5d, 0x8f, 0xc3, 0xcd, 0x92, 0
After examining the extract:
- Briefly justify your total score, up to 100 words.
- Conclude with the score using the format: "Educational score: <total points>"
| c | 1 | /*
INPUT : FAKE_FLAG_HACK_THE_BOX_01234567
111111111111111111111111111111
COMMAND : gdb -q --args ./coffee_invocation $INPUT
b *0x0000555555554000+0x00001ead
b *0x0000555555554000+0x00001f0a
b *0x0000555555554000+0x00001f2a
b *0x0000555555554000+0x00001b52
b *0x0000555555554000+0x00001b6f
b *0x0000555555554000+0x00001b24
b *0x0000555555554000+0x00001b3b
b *0x5555555556ae
b *0x55555555574e
b *0x555555555793
*/
char peer1_0[] = { /* Packet 1135 */
0x91, 0x03, 0x34, 0xf1, 0x1d, 0x76, 0x44, 0xe3 };
char peer1_1[] = { /* Packet 1142 */
0x01, 0xc1, 0xcc, 0x4b, 0xc0, 0x79, 0xbf, 0x77,
0x70, 0x67, 0x72, 0x3f, 0x82, 0x92, 0x52, 0x13,
0xcb, 0x16, 0x77, 0x2d, 0xd6, 0xdd, 0x4a, 0xca,
0xee, 0xe7, 0xa6, 0x69, 0x3f, 0xef, 0x4e, 0x4c,
0x8d, 0x75, 0xce, 0x31, 0xec, 0xf4, 0xf5, 0x0e,
0xce, 0x7f, 0xd9, 0x9f, 0x84, 0xad, 0xd5, 0xfa,
0xef, 0xee, 0x39, 0x8a, 0x1e, 0x6a, 0xe8, 0x82,
0xf1, 0x00, 0x48, 0x15, 0x95, 0x62, 0x13, 0xa8,
0x06, 0xb9, 0x3b, 0x39, 0xa2, 0xec, 0xf1, 0x0f,
0x1b, 0x1a, 0x0a, 0xf0, 0x7f, 0x84, 0x08, 0xf5,
0x30, 0xa3, 0xdd, 0x53, 0x2c, 0x6e, 0x90, 0x15,
0x18, 0x6e, 0x78, 0x3a, 0x44, 0x32, 0x2e, 0xcd,
0x76, 0x10, 0x37, 0x20, 0x70, 0xf3, 0x95, 0x43,
0x9d, 0xb5, 0xd5, 0x83, 0x14, 0xc2, 0xa4, 0xa9,
0x76, 0x08, 0xb3, 0x0d, 0x08, 0xeb, 0xe3, 0x2c,
0x6d, 0x0c, 0x68, 0xde, 0x12, 0x85, 0x0b, 0x34,
0x93, 0xf9, 0xb2, 0x93, 0xdc, 0xb8, 0x08, 0xd6,
0xd2, 0x6e, 0x74, 0xab, 0x28, 0xc2, 0xd4, 0x3b,
0x8f, 0xc6, 0x04, 0x7a, 0x71, 0x4d, 0x1c, 0x6e,
0x2d, 0xfd, 0xe7, 0x9b, 0xf2, 0x5f, 0xc6, 0x05,
0x1a, 0x98, 0x87, 0x37, 0x15, 0x57, 0xa6, 0x0d,
0x65, 0x37, 0x94, 0x97, 0x84, 0xb1, 0x90, 0x89,
0x27, 0x88, 0x1e, 0xd6, 0x66, 0xbe, 0xfe, 0x9a,
0x9f, 0x89, 0x29, 0x5f, 0x5d, 0x43, 0xd4, 0x80,
0x24, 0xf7, 0x62, 0x68, 0x60, 0xdd, 0x79, 0x4d,
0x69, 0x3f, 0xaf, 0xa8, 0x9f, 0x58, 0xa8, 0xcf,
0xc3, 0xde, 0x03, 0x67, 0xc5, 0x51, 0x1f, 0x6f,
0x36, 0x83, 0x0a, 0xf5, 0xa5, 0xa1, 0xb4, 0x6f,
0x61, 0x19, 0x6d, 0xd2, 0xdf, 0xdc, 0xf4, 0x8e,
0x7d, 0x5d, 0x8f, 0xc3, 0xcd, 0x92, 0xa8, 0xf9,
0xcb, 0x7e, 0x3d, 0xa1, 0xb9, 0xf0, 0x41, 0x71,
0x90, 0xc8, 0x3a, 0x9d, 0x1d, 0xec, 0x1e, 0x9c,
0x8d, 0x7e, 0x37, 0xd0, 0x6b, 0x5a, 0xc8, 0x22,
0x75, 0x6b, 0x61, 0xcc, 0xa8, 0x89, 0x43, 0x0a,
0x2a, 0x7a, 0x21, 0xbb, 0x07, 0x21, 0x39, 0x1a,
0x36, 0x53, 0x76, 0x39, 0xa4, 0x4a, 0x22, 0xd2,
0x7e, 0x4b, 0x71, 0xfe, 0x48, 0x21, 0x2e, 0x82,
0xf4, 0x4d, 0x74, 0xe4, 0xcf, 0xff, 0xd5, 0x62,
0x1c, 0xab, 0x88, 0xc0, 0xcd, 0xac, 0x3c, 0x22,
0x49, 0xe2, 0x95, 0xac, 0x50, 0xf8, 0x9f, 0x08,
0xe7, 0x03, 0x9e, 0x7f, 0xd0, 0x0b, 0x98, 0x7a,
0x18, 0x2d, 0x21, 0x00, 0x83, 0x51, 0x42, 0xf6,
0xda, 0x25, 0x9d, 0x07, 0x98, 0xac, 0xfb, 0x6f,
0x9e, 0xf3, 0x79, 0xb8, 0x56, 0xb8, 0x85, 0x55,
0x00, 0x19, 0x77, 0x6e, 0xec, 0x75, 0x00, 0x6a,
0x84, 0x7c, 0x3c, 0x5c, 0x78, 0x15, 0x0e, 0x8a,
0x51, 0x78, 0xb8, 0x0d, 0x0b, 0xc8, 0xc5, 0x82,
0xd8, 0xbf, 0xca, 0x47, 0xec, 0x2d, 0x0a, 0xca,
0x95, 0xdb, 0x8d, 0x51, 0x43, 0x4e, 0x14, 0x90,
0xf3, 0xfb, 0x68, 0xb6, 0xa1, 0xa2, 0x52, 0xcd,
0xc1, 0x8a, 0x7e, 0xbb, 0xb8, 0xb8, 0xa4, 0x3c,
0x79, 0xaa, 0xf0, 0xbc, 0x4f, 0xd3, 0x86, 0x1c,
0xb8, 0x3d, 0x5e, 0x19, 0xeb, 0x45, 0xaa, 0xf3,
0x6d, 0x1c, 0xfa, 0x62, 0xa4, 0x28, 0x9a, 0xfd,
0x32, 0x80, 0x6f, 0x1f, 0x9e, 0x5d, 0xaa, 0xc2,
0xcc, 0x53, 0x2d, 0x71, 0xd5, 0xea, 0x66, 0x0e,
0x6f, 0x3f, 0xce, 0x00, 0xc9, 0x25, 0x09, 0x18,
0x7c, 0x1f, 0xc8, 0x4d, 0x36, 0x6e, 0x27, 0xe4,
0x68, 0xd6, 0xb8, 0x19, 0x09, 0x76, 0x93, 0xbf,
0x1e, 0x99, 0x35, 0x95, 0x02, 0xd8, 0x9a, 0x42,
0xf0, 0x1e, 0xd5, 0x2b, 0x19, 0x46, 0x9c, 0x35,
0x91, 0x32, 0x0f, 0xe9, 0xc4, 0xa7, 0x7d, 0x16,
0xdf, 0xfe, 0x86, 0x1f, 0xd6, 0xb3, 0x93, 0xaa,
0x67, 0x89, 0x4e, 0x0e, 0xbe, 0x38, 0xb5, 0xa2,
0xce, 0x00, 0xb2, 0x22, 0x0b, 0xa4, 0x24, 0xe8,
0xcc, 0x1a, 0x57, 0x0d, 0x11, 0xa5, 0x24, 0x78,
0x89, 0x20, 0x86, 0x69, 0xb0, 0x1f, 0xb1, 0xa1,
0xeb, 0xfe, 0x2f, 0xe9, 0x8f, 0xef, 0x29, 0x89,
0xeb, 0xcb, 0x72, 0x35, 0xfa, 0xb2, 0x27, 0xf5,
0x3b, 0x35, 0xb0, 0x12, 0x0f, 0xa6, 0x50, 0x2a,
0x0e, 0x67, 0xda, 0xac, 0xde, 0x00, 0x8b, 0x2b,
0x2c, 0xc8, 0x25, 0xa7, 0xb3, 0xb6, 0xea, 0x7d,
0xd0, 0x0a, 0x14, 0x26, 0x31, 0xd3, 0xab, 0x45,
0xff, 0x66, 0xca, 0x97, 0x47, 0xab, 0xa6, 0x4a,
0x48, 0xd3, 0x95, 0x64, 0x3c, 0xe2, 0xd6, 0xab,
0x7b, 0x5e, 0xc8, 0x1b, 0x37, 0x49, 0x5e, 0x87,
0xfb, 0x0b, 0x76, 0x50, 0xda, 0xfc, 0x1c, 0x03,
0x17, 0x9d, 0x63, 0x05, 0xfe, 0x99, 0xfe, 0xba,
0x0c, 0x64, 0xab, 0x91, 0xb8, 0x6e, 0x9f, 0x73,
0x0f, 0x46, 0x08, 0x20, 0x7e, 0x2d, 0x7b, 0x07,
0x16, 0x88, 0x78, 0x86, 0x62, 0x8d, 0x94, 0x14,
0x73, 0x4e, 0x7b, 0xdb, 0xe2, 0x6a, 0xfe, 0x20,
0x60, 0x56, 0x57, 0x0d, 0x66, 0xd6, 0x86, 0xa2,
0x99, 0xca, 0xea, 0x08, 0x22, 0x9f, 0x8e, 0x62,
0xe6, 0x1c, 0xe8, 0x5e, 0x0b, 0x83, 0x25, 0xb6,
0xba, 0x2d, 0xf2, 0x95, 0x24, 0x90, 0xe2, 0x55,
0xb7, 0x54, 0x99, 0xd2, 0x6e, 0xbf, 0xc7, 0x8c,
0x54, 0x56, 0xf9, 0x5b, 0x60, 0xea, 0x43, 0xd6,
0xe7, 0xf5, 0x77, 0x86, 0x0b, 0x03, 0x26, 0xe3,
0xec, 0x81, 0xe6, 0xef, 0x2d, 0xee, 0x15, 0x62,
0x05, 0x02, 0xa6, 0xa2, 0xdc, 0x75, 0x9e, 0x72,
0x51, 0x8c, 0x4a, 0x74, 0xa7, 0xf9, 0x2a, 0x05,
0x1e, 0xcf, 0x7c, 0xde, 0xf3, 0xd0, 0x55, 0x8c,
0xe8, 0x5c, 0x35, 0xec, 0xd4, 0x4e, 0x0a, 0xd5,
0x5c, 0x54, 0x81, 0x1c, 0x6e, 0x4e, 0x1d, 0x03,
0x3d, 0xb4, 0x17, 0x7b, 0xd5, 0x75, 0xa1, 0xfa,
0xab, 0xb9, 0x6c, 0x67, 0x7f, 0x8a, 0x0c, 0xf5,
0xa5, 0xde, 0x9b, 0xbb, 0x99, 0xe2, 0x63, 0x65,
0x19, 0xca, 0x0b, 0x7e, 0x62, 0x26, 0x55, 0x78,
0xf2, 0x0b, 0x64, 0x9e, 0xa5, 0x3b, 0x6a, 0x4e,
0xe5, 0x2c, 0x64, 0x90, 0x80, 0xc6, 0x55, 0x15,
0x42, 0x42, 0x69, 0x42, 0xb7, 0xa9, 0x3a, 0x54,
0xf5, 0x0c, 0x42, 0xf7, 0xe8, 0x11, 0xd1, 0x82,
0x41, 0xd9, 0x3e, 0x7a, 0xf5, 0xec, 0xb1, 0x92,
0x17, 0xac, 0xea, 0x3d, 0x8f, 0xa3, 0x22, 0x09,
0x96, 0x0e, 0xae, 0xd1, 0x3b, 0x18, 0xd3, 0x73,
0x7b, 0x5b, 0x28, 0x76, 0x11, 0xa8, 0x3d, 0x79,
0xe5, 0x1d, 0x6a, 0x41, 0x41, 0xec, 0x9a, 0xc3,
0xdc, 0x11, 0x9d, 0x94, 0x7a, 0x93, 0x35, 0x81,
0x85, 0xd8, 0xc1, 0xf8, 0xaa, 0x9e, 0xc1, 0x6b,
0xd4, 0xc6, 0x9c, 0xfa, 0xef, 0x35, 0x65, 0x80,
0x1d, 0xea, 0xcd, 0x01, 0xdb, 0x42, 0xd0, 0x22,
0x6d, 0x62, 0xc5, 0xb6, 0x5d, 0xbf, 0x6b, 0x72,
0xbd, 0x4f, 0x0f, 0x39, 0x93, 0xe5, 0xb9, 0xa2,
0x23, 0xc6, 0x39, 0x5d, 0x2e, 0x3c, 0x42, 0x35,
0x17, 0x80, 0xef, 0x7f, 0x63, 0x00, 0x7f, 0x88,
0x4b, 0x95, 0x6e, 0x3e, 0xf2, 0xba, 0x37, 0xa2,
0x89, 0x49, 0xa2, 0x81, 0x35, 0x59, 0x53, 0xed,
0x07, 0x50, 0x03, 0xf9, 0x9e, 0x6a, 0x80, 0xb3,
0x68, 0x2d, 0xe2, 0xfe, 0xbe, 0x3f, 0x74, 0xc6,
0xc1, 0x19, 0xcb, 0xc7, 0x0d, 0x94, 0x88, 0x66,
0x88, 0xc8, 0x18, 0xc8, 0x08, 0x0f, 0x84, 0x15,
0x55, 0xb9, 0xa0, 0x23, 0xce, 0xaf, 0x5e, 0x6c,
0x41, 0x0e, 0x7f, 0x06, 0x2c, 0x75, 0xed, 0xd8,
0xd2, 0xa8, 0xcf, 0x03, 0x32, 0x43, 0x9b, 0x9d,
0x1a, 0x92, 0x9e, 0xd5, 0x88, 0x19, 0x59, 0x1f,
0x7f, 0x5b, 0x17, 0x8b, 0x6e, 0x0a, 0x33, 0x4b,
0x4e, 0x2f, 0xf0, 0xfd, 0x60, 0x08, 0x0d, 0xda,
0xe3, 0x93, 0x27, 0x41, 0x87, 0xcc, 0xd8, 0xb6,
0x34, 0x8f, 0x30, 0x86, 0xd2, 0xd5, 0xba, 0xd8,
0xbc, 0x2f, 0x66, 0xe2, 0x6a, 0x36, 0x91, 0x5d,
0x68, 0xf9, 0x8a, 0x91, 0x47, 0x3e, 0x46, 0xc4,
0x93, 0xc9, 0xcf, 0xde, 0x9c, 0xfb, 0x36, 0xec,
0xbe, 0x5b, 0x1e, 0x2f, 0x1b, 0xd6, 0x99, 0x20,
0xbb, 0x4f, 0x54, 0x5a, 0x7b, 0x56, 0x9f, 0x96,
0xb4, 0x87, 0x3c, 0x08, 0x1f, 0xc0, 0x31, 0xa3,
0xfb, 0x74, 0x94, 0x01, 0x33, 0xfa, 0x3b, 0xc0,
0x0f, 0x7d, 0x55, 0x22, 0x23, 0x29, 0xa5, 0xb1,
0x52, 0x34, 0xb5, 0x85, 0x08, 0xff, 0xf2, 0xb4,
0xdd, 0x7a, 0xd0, 0xba, 0x65, 0xb1, 0x5f, 0x77,
0x23, 0xb3, 0xbf, 0x32, 0x7a, 0x47, 0x4d, 0x25,
0xf8, 0x08, 0x76, 0x46, 0x97, 0x82, 0x07, 0x06,
0x71, 0xcc, 0x68, 0x8f, 0x6d, 0x76, 0x26, 0x24,
0xf1, 0x32, 0xd4, 0xbe, 0x51, 0xd0, 0x4e, 0x7b,
0x64, 0xad, 0x50, 0x0e, 0xfc, 0x03, 0x49, 0xdc,
0x96, 0x11, 0x6b, 0x52, 0x53, 0x71, 0xd4, 0xc6,
0x17, 0x05, 0x15, 0x16, 0x4b, 0x9a, 0xb6, 0xa8,
0x27, 0x18, 0x6e, 0xae, 0x53, 0x6b, 0xba, 0xcd,
0x73, 0x58, 0x53, 0xda, 0x7a, 0x2b, 0x4d, 0x7b,
0xe0, 0x83, 0x4c, 0xac, 0x77, 0x8a, 0xda, 0x3c,
0x4a, 0xc9, 0x96, 0x6d, 0x40, 0xb1, 0x91, 0xe4,
0x1a, 0x5f, 0xbf, 0x88, 0xff, 0x72, 0xee, 0x56,
0x67, 0x22, 0xb8, 0x6d, 0x69, 0xfb, 0x18, 0x6f,
0x0f, 0x51, 0xf9, 0xaf, 0xee, 0x22, 0x31, 0x2a,
0x71, 0xf1, 0xae, 0x68, 0xb4, 0x97, 0xee, 0x27,
0x5a, 0x96, 0x08, 0x9d, 0x41, 0xf1, 0x7d, 0xb4,
0x55, 0xd1, 0xfa, 0x79, 0x2a, 0x4b, 0xbf, 0x3c,
0x35, 0xc9, 0xa1, 0x17, 0xf4, 0x99, 0x5d, 0xc8,
0x5d, 0x84, 0x76, 0x02, 0x65, 0xfe, 0xb8, 0xdd,
0xb2, 0x08, 0xc6, 0x15, 0x74, 0x59, 0xc9, 0x9a,
0x6b, 0xe3, 0xa6, 0xfb, 0xa1, 0xa7, 0x8e, 0x42,
0x5c, 0x7f, 0x5d, 0xca, 0xa2, 0xa3, 0xc3, 0x80,
0xdb, 0x36, 0x3e, 0xe2, 0x2d, 0xaa, 0x02, 0x29,
0x52, 0x08, 0x17, 0x67, 0x0e, 0x4d, 0x8d, 0xbc,
0x28, 0x7b, 0x0e, 0xde, 0x17, 0x9c, 0x0c, 0x9d,
0x13, 0x20, 0xaa, 0xfa, 0x59, 0x84, 0x7e, 0x25,
0x6e, 0xcb, 0x54, 0xe6, 0x50, 0xe5, 0xd3, 0xf5,
0xd0, 0x88, 0xb3, 0x7b, 0xf5, 0xa3, 0x16, 0x48,
0x36, 0x85, 0xbe, 0xda, 0xf7, 0x28, 0x8f, 0xc9,
0xb7, 0x0c, 0xdd, 0x6a, 0x15, 0xd1, 0x00, 0xa9,
0xa1, 0xdf, 0x73, 0x40, 0x6d, 0x55, 0xdb, 0xbe,
0xdc, 0x7e, 0xd7, 0x70, 0xd0, 0x59, 0xc0, 0xf4,
0x6c, 0xfb, 0x69, 0xb8, 0xa7, 0xa5, 0xe8, 0x89,
0x2c, 0xd4, 0x28, 0x8f, 0x2d, 0xb6, 0x60, 0x12,
0x80, 0x40, 0x15, 0xa8, 0xbf, 0xfb, 0x84, 0x1d,
0x97, 0x18, 0xba, 0x6e, 0xc5, 0xaf, 0x37, 0x0b,
0xbb, 0xe6, 0xbd, 0xb8, 0x19, 0xf6, 0x51, 0x13,
0xf9, 0x5e, 0xb9, 0xb0, 0x09, 0x53, 0xb9, 0x93,
0x6b, 0xb6, 0x9f, 0x71, 0x64, 0x84, 0xf2, 0x21,
0x4d, 0xc8, 0x3a, 0x85, 0xb3, 0xef, 0x61, 0x68,
0x80, 0x93, 0x33, 0x36, 0xef, 0x8b, 0x99, 0xb9,
0xf0, 0xe7, 0xb1, 0x52, 0x2b, 0xc1, 0x57, 0x1e,
0x3c, 0xf0, 0xba, 0x9b };
char peer1_2[] = { /* Packet 1143 */
0xce, 0xcc, 0xad, 0xe0, 0xa2, 0xde, 0x14, 0x6e,
0x8a, 0xb5, 0xe2, 0x46, 0xba, 0xca, 0x19, 0x67,
0x90, 0xdc, 0x43, 0xe0, 0x1e, 0x56, 0xee, 0x11,
0xa8, 0xff, 0xad, 0x51, 0xce, 0xa2, 0x87, 0x37,
0xa9, 0xb9, 0x80, 0x62, 0xfc, 0x88, 0xd9, 0x4f,
0xb7, 0x18, 0x1d, 0xb2, 0x6e, 0x23, 0x04, 0x0c,
0x02, 0x36, 0x54, 0x41, 0x61, 0x4e, 0x9f, 0x11,
0xd0, 0xdd, 0xa2, 0xa8, 0xec, 0xa9, 0xa1, 0x52,
0xaf, 0x32, 0xc9, 0x4d, 0x00, 0x8f, 0x4b, 0x66,
0xd1, 0xa0, 0x49, 0x63, 0xe9, 0x0d, 0xc3, 0x90,
0x30, 0xa4, 0xae, 0x50, 0x9b, 0x77, 0x8f, 0x92,
0x24, 0xd4, 0x29, 0x91, 0x5c, 0x1a, 0x43, 0x5a,
0x33, 0xe6, 0xd2, 0xfe, 0xf6, 0xbb, 0xdb, 0x9d,
0x21, 0xdc, 0x20, 0x78, 0x1b, 0x3c, 0xbb, 0xd6,
0xf7, 0x02, 0x4c, 0x12, 0x10, 0x98, 0xfd, 0xa9,
0x66, 0x00, 0x3c, 0xe9, 0x00, 0xc0, 0x50, 0x9b,
0x88, 0xe2, 0xba, 0x63, 0xcb, 0x03, 0xec, 0xd0,
0xa5, 0xf0, 0x61, 0x64, 0xfe, 0x51, 0x2c, 0x18,
0x3b, 0x45, 0x94, 0xa1, 0xcf, 0xc4, 0xa1, 0x5f,
0xcf, 0x8d, 0x87, 0x22, 0x89, 0x86, 0xb9, 0xf2,
0xe8, 0x99, 0x6c, 0x74, 0x8e, 0x01, 0x20, 0xc0,
0x7b, 0x15, 0x15, 0x2f, 0xcf, 0xe5, 0x28, 0x05,
0x85, 0xb9, 0x5d, 0xa4, 0x3a, 0xf1, 0xe9, 0x36,
0x61, 0xf5, 0x99, 0x71, 0xc2, 0x32, 0x18, 0x93,
0x64, 0x71, 0x7e, 0xad, 0x62, 0xaa, 0xea, 0xf2,
0x14, 0xaa, 0x95, 0x69, 0x55, 0xc9, 0x69, 0xc1,
0x18, 0x38, 0x75, 0x86, 0x05, 0x55, 0x93, 0xa0,
0xb3, 0x9f, 0xc0, 0x63, 0x86, 0x31, 0x93, 0x34,
0x8d, 0x6b, 0x04, 0x50, 0x62, 0xc9, 0x5f, 0xdb,
0xa4, 0xa0, 0x10, 0x37, 0x1a, 0x01, 0xa9, 0x24,
0xbe, 0x09, 0xcc, 0x3c, 0xa2, 0x84, 0x5e, 0xbf,
0x99, 0xf2, 0x57, 0x7f, 0x7b, 0x38, 0x6f, 0x9f,
0xca, 0xe0, 0xd8, 0x6e, 0xc5, 0xe8, 0x73, 0x65,
0x1c, 0xf1, 0xa8, 0x1e, 0x28, 0x5d, 0xec, 0x79,
0xa5, 0x97, 0x82, 0x9c, 0x0c, 0xc6, 0xe3, 0xea,
0xd7, 0x8f, 0x2c, 0x53, 0xa5, 0xea, 0x76, 0x0c,
0xbd, 0xd5, 0x6e, 0xeb, 0x59, 0xa2, 0x91, 0xb1,
0x62, 0xfe, 0x49, 0x2a, 0x20, 0xe9, 0x8b, 0x86,
0xc5, 0x76, 0x71, 0x1a, 0xeb, 0x98, 0x12, 0x65,
0x11, 0x4a, 0x6c, 0x98, 0x72, 0x5a, 0xd3, 0x9a,
0xaf, 0x93, 0x2b, 0xec, 0x37, 0x05, 0x8a, 0xb7,
0xd4, 0xfa, 0xe9, 0x9f, 0xd8, 0xfd, 0x1e, 0x0f,
0xe5, 0x29, 0xa1, 0x5b, 0xba, 0xb8, 0x42, 0x67,
0x7b, 0xf1, 0x1c, 0x2c, 0x3b, 0xef, 0xdc, 0x0a,
0x06, 0x72, 0x61, 0xe3, 0x59, 0x83, 0xc3, 0x36,
0x3f, 0xd2, 0xb9, 0x3f, 0x33, 0x97, 0xbe, 0x8c,
0xf1, 0xae, 0xfe, 0xaf, 0xf0, 0xc5, 0xf3, 0xb6,
0x88, 0x2a, 0x56, 0xd1, 0xcd, 0x0d, 0xa9, 0xb2,
0x02, 0x62, 0x20, 0x27, 0x7d, 0x2b, 0x52, 0x19,
0x00, 0x46, 0x83, 0xd3, 0x11, 0x03, 0xb4, 0x7e,
0x92, 0x58, 0xf5, 0x8b, 0xa2, 0x3e, 0x9e, 0x26,
0x31, 0x87, 0x44, 0xa6, 0xd3, 0x09, 0xc6, 0x3e,
0x55, 0xac, 0x5a, 0xbb, 0x3a, 0xf6, 0xc5, 0x08,
0x1c, 0x04, 0xfb, 0x47, 0x44, 0x78, 0xfb, 0x2d,
0x61, 0xf8, 0xcd, 0xe5, 0xef, 0x9d, 0xfb, 0x81,
0xd3, 0x98, 0xd2, 0x65, 0x7e, 0xff, 0x14, 0x24,
0xca, 0x8e, 0xe0, 0xcd, 0x9e, 0xaa, 0x06, 0x75,
0xd5, 0x88, 0x01, 0x62, 0xd6, 0x32, 0x41, 0x98,
0xa4, 0x4f, 0x96, 0x54, 0x86, 0x94, 0xfc, 0xbb,
0xe2, 0x4a, 0xf2, 0x64, 0x21, 0xa9, 0x79, 0x7d,
0x70, 0x11, 0x30, 0xd4, 0xc0, 0xd2, 0x6f, 0x11,
0x4f, 0x31, 0xf2, 0xcf, 0xf5, 0x02, 0xe9, 0x3c,
0x4e, 0xa3, 0xe2, 0x5b, 0xae, 0x9b, 0x73, 0x2d,
0xfc, 0x51, 0x1f, 0x8a, 0x83, 0x5c, 0x8d, 0x57,
0x42, 0xc9, 0xef, 0xaa, 0x22, 0x64, 0x9f, 0x2b,
0xfe, 0x25, 0x26, 0xcf, 0xdc, 0x38, 0xb9, 0x5e,
0xc7, 0xf2, 0xe3, 0x31, 0xf7, 0xdf, 0x47, 0xc8,
0xe6, 0x23, 0xe5, 0x0a, 0xb2, 0x6a, 0xb5, 0xb3,
0x07, 0xbc, 0x9b, 0xde, 0x55, 0x07, 0x6a, 0xcd,
0xa8, 0x70, 0x83, 0x83, 0x87, 0x89, 0x4e, 0xc1,
0xed, 0xc5, 0x74, 0xa8, 0xe9, 0x74, 0x4b, 0xe0,
0xcc, 0x85, 0x6c, 0xfc, 0x94, 0x2e, 0xac, 0x23,
0x69, 0x3a, 0xb7, 0xb2, 0xd0, 0xc4, 0xab, 0x53,
0xcb, 0xfb, 0xdf, 0x27, 0x2a, 0x9c, 0x48, 0xeb,
0x71, 0x3c, 0x25, 0x30, 0x0f, 0xf3, 0xa0, 0x96,
0xc9, 0x2c, 0xc4, 0xfe, 0x30, 0x7e, 0x10, 0xd7,
0xfd, 0xa6, 0x82, 0x08, 0x39, 0x73, 0xc8, 0x87,
0x85, 0x3e, 0x44, 0xdf, 0xe8, 0xe7, 0xf7, 0x6a,
0xeb, 0xef, 0x70, 0xa2, 0x46, 0x67, 0x31, 0x28,
0xeb, 0x91, 0x83, 0xda, 0x91, 0x22, 0x27, 0x63,
0xc7, 0x98, 0xcb, 0x76, 0x25, 0x51, 0x49, 0xeb,
0x17, 0x5d, 0x91, 0xc2, 0x5f, 0xae, 0xf4, 0xb7,
0xf5, 0xea, 0x6c, 0x50, 0x7e, 0x8c, 0x7e, 0xc2,
0x36, 0xc8, 0x72, 0x16, 0x08, 0x75, 0x6b, 0x75,
0x3e, 0xa5, 0xd8, 0x12, 0xbc, 0xbe, 0x3e, 0x28,
0x55, 0x36, 0x95, 0xd4, 0x0c, 0xa7, 0x45, 0x5c,
0xa3, 0xff, 0x44, 0x54, 0xcf, 0x94, 0x3b, 0x95,
0xe7, 0xe7, 0x1e, 0x8f, 0x5a, 0xd3, 0x81, 0x44,
0xe8, 0x25, 0x69, 0x59, 0xa5, 0xcd, 0x2d, 0x02,
0x2d, 0x77, 0x5e, 0x3a, 0x28, 0x25, 0xa9, 0xfd,
0x33, 0x14, 0xd2, 0x68, 0x0e, 0x02, 0xfb, 0xc9,
0xa3, 0x99, 0xba, 0xa5, 0x2f, 0xb5, 0xcf, 0x56,
0xb7, 0x52, 0x29, 0xa1, 0xe3, 0xb3, 0xd1, 0x9a,
0x7f, 0x8d, 0xba, 0x1d, 0xe3, 0x0a, 0x57, 0x1a,
0x30, 0x89, 0x23, 0x4f, 0xb5, 0xa7, 0x02, 0x9f,
0x1e, 0x5d, 0xf0, 0x4d, 0xf0, 0x18, 0xea, 0x0b,
0x21, 0xe3, 0xd0, 0xb5, 0x6f, 0xfd, 0xcd, 0x04,
0xb6, 0x52, 0xf1, 0xc8, 0x1a, 0x41, 0x84, 0x0d,
0xbf, 0x6c, 0xdf, 0x23, 0x5c, 0x16, 0x6f, 0x1e,
0x24, 0xe9, 0x76, 0x6d, 0xd3, 0x39, 0x89, 0x67,
0xe7, 0xc8, 0xd5, 0xfd, 0x8e, 0x9b, 0x57, 0xac,
0xab, 0x24, 0x1b, 0x53, 0xdc, 0x88, 0x5c, 0x16,
0x97, 0x1b, 0x84, 0x96, 0x6c, 0x05, 0xe8, 0xc4,
0xa3, 0x49, 0xe4, 0x18, 0x6e, 0xcd, 0x5d, 0x06,
0x6f, 0xb8, 0x3c, 0xd0, 0x72, 0x53, 0x9e, 0xda,
0x04, 0xfc, 0x66, 0x5c, 0xe2, 0x35, 0xd7, 0x4c,
0x85, 0x29, 0xab, 0x68, 0x6f, 0xdf, 0x61, 0xb4,
0x85, 0x27, 0xc4, 0xa7, 0x3b, 0x0a, 0x75, 0x3b,
0x68, 0x37, 0x56, 0xad, 0x6e, 0xe6, 0xad, 0x8c,
0xb3, 0xcd, 0x1c, 0x99, 0x51, 0x3d, 0xc3, 0x8e,
0x32, 0x5e, 0x0f, 0xca, 0x4a, 0x1f, 0xbb, 0x65,
0xf8, 0xcd, 0x21, 0xcb, 0x79, 0x03, 0x75, 0x6e,
0xde, 0xcc, 0x72, 0x8c, 0xa4, 0xb2, 0x2b, 0x42,
0x72, 0xdb, 0x87, 0xbf, 0xb2, 0xa4, 0xc3, 0xc4,
0x8b, 0xe5, 0xea, 0xdc, 0x75, 0xab, 0x1a, 0xfb,
0x16, 0xb6, 0x76, 0xf0, 0x05, 0x4f, 0x56, 0x2a,
0x39, 0x09, 0x00, 0xc8, 0xa2, 0xdd, 0x8c, 0x34,
0xfd, 0xe3, 0x17, 0x91, 0xdc, 0xab, 0x9e, 0x24,
0x28, 0xc8, 0x07, 0xff, 0x55, 0x79, 0xaa, 0xab,
0x1f, 0x14, 0xf3, 0xcd, 0xfa, 0x94, 0x2c, 0xed,
0xc4, 0xa8, 0x65, 0x61, 0x6e, 0x9d, 0x00, 0xde,
0xda, 0xb1, 0xe5, 0x6b, 0xcf, 0xd8, 0x41, 0x63,
0x27, 0x8c, 0x26, 0x38, 0xf2, 0x3a, 0x85, 0x3b,
0x8b, 0xe7, 0x8c, 0x5f, 0x7a, 0x18, 0x81, 0xfb,
0xe4, 0x0e, 0xec, 0xe2, 0xf8, 0xda, 0x05, 0x02,
0xa7, 0x6d, 0xd6, 0x09, 0xbb, 0x4f, 0xe5, 0x21,
0x25, 0x8d, 0xfa, 0x50, 0x74, 0xa0, 0xe9, 0xa0,
0xfe, 0xf8, 0xde, 0xe8, 0x8d, 0x1e, 0x40, 0x45,
0xdc, 0xf9, 0xdb, 0x36, 0x68, 0xad, 0xbb, 0x88,
0x9f, 0x94, 0x47, 0xcf, 0xdd, 0xe4, 0x19, 0x73,
0xee, 0x2d, 0x00, 0x30, 0x95, 0xdd, 0x26, 0x7a,
0xa8, 0x58, 0xe4, 0x98, 0x7e, 0x35, 0xf5, 0x40,
0xbb, 0xf1, 0xa5, 0xb4, 0xc2, 0xd4, 0x2e, 0x41,
0x25, 0x15, 0x8a, 0x5f, 0xf5, 0xd1, 0xb5, 0xcb,
0x19, 0x7a, 0xc6, 0xef, 0x30, 0xb0, 0x48, 0xe0,
0xc6, 0x30, 0x2b, 0x47, 0x72, 0x4c, 0x3d, 0x05,
0x76, 0x34, 0x80, 0x4d, 0xd9, 0x19, 0x72, 0x6f,
0xac, 0x90, 0x0d, 0xc0, 0x8a, 0x0f, 0x49, 0xda,
0xb7, 0xab, 0xb3, 0x6c, 0xeb, 0x46, 0xff, 0x85,
0x8e, 0x46, 0xf2, 0x20, 0xee, 0x83, 0x89, 0x2e,
0xc1, 0x7a, 0x27, 0x0e, 0xb4, 0x1b, 0x51, 0x98,
0x1c, 0x35, 0x90, 0xdc, 0x04, 0xeb, 0x38, 0xc2,
0x2b, 0x1c, 0xaa, 0x50, 0x1f, 0xc4, 0xa2, 0xdb,
0xae, 0xcb, 0x3c, 0x40, 0x04, 0xf4, 0x9a, 0x10,
0xb6, 0x79, 0x3c, 0xc5, 0x56, 0x99, 0x10, 0xd8,
0x51, 0x19, 0x51, 0x87, 0x05, 0x33, 0x4d, 0xa8,
0x2f, 0xd0, 0xac, 0xc5, 0x66, 0x61, 0xa5, 0x58,
0xdc, 0x65, 0xa9, 0x70, 0x63, 0x90, 0x7c, 0xd9,
0xf7, 0x4e, 0x2d, 0xfb, 0xe5, 0x74, 0x5e, 0xd5,
0x9e, 0xff, 0x0a, 0x9a, 0x9b, 0xe9, 0xd9, 0x07,
0x74, 0x75, 0xfa, 0x42, 0xa2, 0xcf, 0xf7, 0xcd,
0x41, 0x1d, 0x64, 0x1f, 0xb5, 0x31, 0xd0, 0x08,
0x20, 0xa7, 0x32, 0xcf, 0xcd, 0xc5, 0x23, 0x85,
0xbe, 0x5f, 0x2a, 0x38, 0x21, 0x0e, 0xc2, 0xbb,
0x3f, 0x35, 0xbd, 0xf4, 0x1c, 0xc8, 0x1f, 0x6a,
0xeb, 0xc1, 0xcb, 0xd9, 0x5e, 0x5f, 0x2a, 0x85,
0x69, 0xfc, 0x94, 0x1e, 0xe6, 0x62, 0x1b, 0xa6,
0x88, 0xf3, 0xa3, 0xd2, 0x0c, 0xf0, 0xd0, 0xee,
0x18, 0x93, 0x8f, 0x52, 0xee, 0x7b, 0x73, 0x02,
0xb3, 0x53, 0x78, 0x73, 0x9b, 0x30, 0xed, 0x92,
0x29, 0xbf, 0x9d, 0xd5, 0xcd, 0xbe, 0x51, 0x0f,
0xed, 0x35, 0x00, 0x4d, 0xdf, 0x92, 0xfe, 0x8f,
0x51, 0xec, 0xab, 0xbb, 0x72, 0x7e, 0x41, 0x3e,
0xf1, 0x1f, 0x44, 0x8f, 0x0d, 0x17, 0xce, 0x75,
0xdf, 0x56, 0xc5, 0xe5, 0x96, 0xbd, 0xaa, 0x36,
0xb8, 0x24, 0x32, 0x44, 0x3a, 0x55, 0xb8, 0xe8,
0xcd, 0x6b, 0x40, 0xc7, 0x01, 0xe3, 0x8b, 0x1e,
0x0c, 0x0c, 0xe6, 0x61, 0x80, 0xd6, 0xe2, 0xf2,
0xa4, 0xec, 0x77, 0x95, 0xac, 0x83, 0xf3, 0x10,
0x75, 0xc0, 0xa9, 0xb4, 0x0d, 0x66, 0xaf, 0xc5,
0x6f, 0xd8, 0x10, 0xe8, 0x5c, 0xfd, 0x53, 0xb0,
0xe1, 0x84, 0xb0, 0x26, 0xab, 0x3d, 0xe7, 0xe3,
0x17, 0x70, 0x49, 0x4b, 0x4c, 0x0e, 0xaa, 0xdc,
0x43, 0xfe, 0xa1, 0xf1, 0x8a, 0xb5, 0x1e, 0xc4,
0xb9, 0xc8, 0xfb, 0xd9, 0x40, 0xa0, 0x66, 0xab,
0xdf, 0x9a, 0x08, 0x9b, 0x10, 0x87, 0x11, 0xcb,
0x9c, 0x46, 0xb5, 0x0b, 0x2b, 0x5e, 0x86, 0xff,
0xb6, 0x8f, 0x51, 0xe5, 0x9a, 0x08, 0x31, 0xf1,
0xaf, 0x51, 0xf8, 0x8a, 0x81, 0x20, 0x71, 0x81,
0x85, 0x3d, 0x0e, 0xbd, 0x45, 0x26, 0xf4, 0x7b,
0x0b, 0x0c, 0xca, 0x6f, 0xfe, 0x79, 0xa7, 0xae,
0x87, 0x90, 0xe4, 0x7e, 0x03, 0x9c, 0xcf, 0x09,
0x20, 0x34, 0x6a, 0x56 };
char peer1_3[] = { /* Packet 1144 */
0xec, 0x43, 0x8f, 0x32, 0xd5, 0x30, 0x4c, 0x93,
0x2d, 0x0d, 0xbd, 0xbe, 0x03, 0x01, 0xad, 0xbf,
0xd3, 0x22, 0x3e, 0xf3, 0x38, 0x79, 0xb2, 0x11,
0xb1, 0x35, 0xb5, 0x2e, 0xbe, 0x26, 0x28, 0x65,
0x29, 0x28, 0xcf, 0x9c, 0x58, 0x89, 0xe4, 0x1a,
0x79, 0xb8, 0xc1, 0xc4, 0xa9, 0xc3, 0xcf, 0x02,
0x94, 0xd0, 0x8d, 0xcc, 0xa9, 0x97, 0x92, 0xfb,
0x23, 0x0a, 0x68, 0xee, 0x91, 0x61, 0x4d, 0x6e,
0x90, 0xf9, 0x34, 0x80, 0xbe, 0x93, 0x5e, 0x44,
0xa2, 0x71, 0x70, 0xc6, 0x1f, 0x58, 0xcb, 0xcd,
0xbf, 0xdd, 0xcb, 0x86, 0xe2, 0x06, 0x22, 0x6f,
0x0a, 0xed, 0x39, 0xa2, 0xf8, 0xd6, 0x58, 0x19,
0xae, 0x54, 0xa7, 0x2a, 0xf8, 0x5b, 0xb5, 0xc2,
0x71, 0x5c, 0xc2, 0x50, 0x62, 0x73, 0xf9, 0xe0,
0x1e, 0x76, 0x6b, 0xef, 0x49, 0x21, 0xe1, 0x02,
0xbb, 0x28, 0xed, 0xef, 0x06, 0x06, 0xaa, 0x26,
0xee, 0x8e, 0xdd, 0xc3, 0x58, 0x82, 0x38, 0xb2,
0x41, 0xc3, 0x19, 0x54, 0x2c, 0xd1, 0x2e, 0xc5,
0xa1, 0x2a, 0x84, 0xc5, 0x1d, 0xe9, 0x36, 0xd1,
0x83, 0x95, 0xee, 0x63, 0x94, 0x7d, 0x3e, 0xcb,
0xc3, 0xcc, 0xd3, 0x96, 0xbf, 0x04, 0x38, 0xe6,
0xf8, 0x14, 0x35, 0x56, 0x34, 0x53, 0x8b, 0x64,
0x52, 0x0e, 0xea, 0x87, 0xeb, 0xdd, 0x77, 0x91,
0x6f, 0x95, 0xf1, 0xcc, 0xf8, 0xdd, 0x4b, 0x09,
0x0c, 0x8b, 0x78, 0x6a, 0xc4, 0xf3, 0x18, 0x3e,
0x3d, 0x8b, 0x44, 0x17, 0x19, 0x5a, 0xf5, 0x39,
0x19, 0xc6, 0xdf, 0x82, 0xa2, 0x81, 0x19, 0x9a,
0x5f, 0x6d, 0xfe, 0x6b, 0x6f, 0x37, 0x41, 0x62,
0x38, 0xfd, 0x02, 0xfe, 0x7f, 0xfa, 0x15, 0x0a,
0x69, 0xa4, 0x7e, 0x15, 0x46, 0x88, 0x16, 0xc8,
0x9d, 0x4c, 0x59, 0x5f, 0xbf, 0x0b, 0x79, 0xc8,
0x62, 0xcc, 0x47, 0x9d, 0x01, 0x55, 0x1c, 0x9b,
0x01, 0x8f, 0x3e, 0xe3, 0xec, 0x2b, 0x70, 0xdb,
0xcc, 0x24, 0xf5, 0x85, 0x03, 0xa7, 0xa3, 0x15,
0xb1, 0xe9, 0xc8, 0x06, 0x29, 0xb1, 0x0f, 0xde,
0x3f, 0xc2, 0xeb, 0x40, 0x81, 0xab, 0x62, 0x3d,
0x33, 0xb2, 0x73, 0x26, 0x4f, 0x6b, 0xe9, 0x29,
0x57, 0x21, 0xf6, 0x14, 0x4f, 0x1d, 0x0b, 0x0c,
0x08, 0x03, 0xf2, 0x1a, 0x44, 0x21, 0x3b, 0x86,
0x55, 0xdc, 0x90, 0x03, 0xd8, 0xa3, 0x34, 0x34,
0xa9, 0xe7, 0x79, 0x14, 0x60, 0xc3, 0x3f, 0x7b,
0x4f, 0x16, 0x48, 0xfc, 0xd6, 0x4a, 0x1a, 0x46,
0xfb, 0xb2, 0x1b, 0xca, 0xb8, 0x42, 0xd6, 0x9e,
0x21, 0xdb, 0x20, 0x97, 0xce, 0xdf, 0xf0, 0xc8,
0xa6, 0xeb, 0x69, 0x6c, 0x82, 0xbc, 0x84, 0x19,
0x0a, 0x4a, 0x13, 0x48, 0x2a, 0x3b, 0xda, 0xaa,
0xd3, 0xa9, 0xa3, 0x79, 0x4d, 0x44, 0x84, 0xe8,
0xc3, 0x90, 0x00, 0xc0, 0x0f, 0x11, 0xe4, 0x86,
0x7f, 0x17, 0x5c, 0x1d, 0xa4, 0x25, 0xb7, 0xb9,
0x1f, 0xee, 0x70, 0x46, 0xa6, 0x20, 0xf4, 0xb1,
0x1b, 0x9f, 0x25, 0x13, 0x07, 0x60, 0x0a, 0x0e,
0xe1, 0xf6, 0xad, 0x64, 0x36, 0xeb, 0x7d, 0x48,
0xb5, 0x20, 0x23, 0xf5, 0x03, 0xb6, 0x20, 0xb7,
0xdb, 0x3f, 0x52, 0x18, 0x19, 0x3f, 0x11, 0x67,
0xdd, 0x29, 0x78, 0x88, 0x0c, 0x3a, 0x0c, 0x7d,
0xa1, 0xed, 0xc3, 0x1c, 0x9f, 0xa6, 0x06, 0x57,
0x9e, 0x91, 0x7e, 0xb9, 0xf0, 0x41, 0x8c, 0x19,
0xe2, 0x8e, 0xc9, 0x65, 0x68, 0x2b, 0xa5, 0x81,
0xc7, 0x10, 0xe0, 0xc9, 0xbc, 0x6e, 0x2d, 0x5e,
0xe6, 0xf1, 0x03, 0x8c, 0x97, 0x57, 0xb9, 0x67,
0x05, 0x94, 0xa7, 0x4d, 0x56, 0xfc, 0x5d, 0xc3,
0x13, 0x92, 0x2c, 0xf2, 0x13, 0x2e, 0x66, 0x85,
0x53, 0xdc, 0x99, 0x32, 0xdd, 0x9d, 0x9b, 0x12,
0x27, 0x4a, 0xee, 0xe1, 0xa9, 0xca, 0x8f, 0x2c,
0x48, 0x49, 0xf9, 0x04, 0x65, 0x8d, 0x98, 0x3a,
0xe1, 0x94, 0x97, 0x2d, 0x07, 0x6c, 0x74, 0x86,
0xbf, 0x65, 0x7d, 0xed, 0xa8, 0x0a, 0xb3, 0xd4,
0x2f, 0xd8, 0x68, 0x9f, 0x60, 0xbf, 0x75, 0xaf,
0x9d, 0xf3, 0xc9, 0x57, 0xbd, 0xac, 0x0f, 0x33,
0x9f, 0xd0, 0x2b, 0xf2, 0x3d, 0xa7, 0x20, 0xec,
0xa2, 0x8d, 0x01, 0x37, 0x2a, 0x76, 0xaf, 0xa3,
0x72, 0x16, 0x3a, 0xf7, 0xbf, 0xa3, 0xad, 0x85,
0xbc, 0x59, 0xfc, 0x0b, 0x03, 0xb4, 0x7f, 0x45,
0x44, 0xa4, 0x87, 0xa9, 0xa5, 0x4b, 0xea, 0x3f,
0xcf, 0x7c, 0xab, 0x09, 0x0b, 0xe8, 0xfa, 0x48,
0x3e, 0xad, 0xdd, 0x56, 0x31, 0x80, 0x7f, 0x93,
0x3f, 0x4f, 0xdf, 0xc2, 0x15, 0xba, 0xe4, 0x80,
0xac, 0x07, 0x5c, 0xb6, 0x0f, 0x44, 0x6d, 0xf8,
0x80, 0x93, 0x37, 0xc1, 0xfd, 0xe7, 0x1f, 0x55,
0xcc, 0x1e, 0x79, 0xbc, 0x57, 0x01, 0xde, 0x15,
0x41, 0xfe, 0xc0, 0xa4, 0x16, 0x48, 0xf6, 0xeb,
0x0c, 0xb3, 0x21, 0x27, 0x4f, 0xd3, 0x42, 0x02,
0xdd, 0x98, 0x6f, 0x3b, 0x56, 0xfa, 0x52, 0x45,
0x84, 0x0f, 0x56, 0x72, 0x65, 0xab, 0x11, 0x3c,
0x8f, 0xde, 0x07, 0x8c, 0x3e, 0x59, 0x4a, 0x2b,
0x3b, 0x67, 0x5f, 0xc8, 0x37, 0xd8, 0xba, 0x5f,
0x48, 0xf5, 0xb9, 0x91, 0x29, 0xbc, 0x6d, 0x13,
0xc8, 0x71, 0x41, 0x5e, 0xca, 0xd8, 0x05, 0x02,
0xff, 0x94, 0x30, 0x05, 0xce, 0x95, 0x3a, 0xd5,
0xf1, 0x35, 0xaf, 0x9c, 0x48, 0x27, 0x3a, 0x7b,
0x81, 0xfe, 0x9f, 0xdf, 0xa8, 0xec, 0x97, 0x94,
0xaa, 0xd0, 0xab, 0x7b, 0x0b, 0x9a, 0x8c, 0x95,
0xea, 0xd7, 0x40, 0xbc, 0x8c, 0x2f, 0x28, 0xe3,
0xea, 0xff, 0x48, 0x18, 0xc4, 0x91, 0x6d, 0x86,
0xca, 0xa0, 0xa7, 0x57, 0xff, 0x17, 0xe7, 0xd1,
0x95, 0xb4, 0x07, 0xcc, 0x37, 0x7a, 0x94, 0x4a,
0x63, 0xae, 0x4e, 0x8f, 0x89, 0xb2, 0xfd, 0xca,
0x45, 0x82, 0x82, 0xdc, 0xc7, 0x5a, 0x6f, 0xde,
0x58, 0x27, 0xb7, 0xa9, 0x49, 0xaa, 0xe1, 0x15,
0xd4, 0x5a, 0xe0, 0x69, 0x91, 0xdf, 0x9b, 0x9d,
0x6a, 0x78, 0x5b, 0x1a, 0x29, 0x25, 0x63, 0xd8,
0x16, 0xc8, 0xe3, 0x58, 0x59, 0xf5, 0x21, 0x80,
0x26, 0x1c, 0xd9, 0xdb, 0x07, 0x5d, 0x24, 0x70,
0x88, 0x9a, 0xc8, 0x00, 0x26, 0xf9, 0xb2, 0x92,
0xfb, 0xe7, 0x65, 0x06, 0x6b, 0x28, 0x63, 0xf7,
0xbd, 0x02, 0xe9, 0xa9, 0x6f, 0x7d, 0xca, 0x1f,
0x79, 0x93, 0xbd, 0x43, 0x9e, 0x95, 0x89, 0x2c,
0x07, 0x61, 0x96, 0x88, 0x22, 0x35, 0xc4, 0x34,
0x22, 0x1f, 0xde, 0x74, 0xeb, 0x07, 0xd6, 0x86,
0xad, 0xde, 0x51, 0x00, 0xf2, 0xc5, 0xe3, 0xef,
0xac, 0xbb, 0xfb, 0x95, 0x18, 0x04, 0x6b, 0x33,
0x17, 0xea, 0x6f, 0x78, 0x39, 0x6c, 0x96, 0x6f,
0x6e, 0xfe, 0x64, 0xba, 0xac, 0x40, 0x63, 0xb1,
0x97, 0x32, 0x5b, 0xee, 0xf2, 0x40, 0x54, 0xb2,
0x31, 0xa7, 0x6d, 0xd8, 0xdb, 0x80, 0x5d, 0x1e,
0x3f, 0x42, 0x0f, 0x95, 0x33, 0x0f, 0xbe, 0x20,
0xd5, 0x15, 0xe1, 0x94, 0x04, 0x45, 0x6a, 0xa4,
0x24, 0xf2, 0x58, 0x61, 0x41, 0x18, 0xa5, 0x02,
0xc2, 0xb6, 0x29, 0xd4, 0xaa, 0x9d, 0x7a, 0xb8,
0xda, 0x61, 0x62, 0x57, 0x6c, 0x03, 0x5a, 0x7d,
0x5b, 0xd6, 0xb1, 0xef, 0x14, 0x27, 0x9c, 0x18,
0x07, 0x85, 0xbc, 0xbe, 0x82, 0x41, 0x64, 0x5e,
0xf9, 0x47, 0xb2, 0x5c, 0x41, 0x27, 0x6c, 0xee,
0x5d, 0x7e, 0x91, 0x09, 0x48, 0xc1, 0x9d, 0xaa,
0x3e, 0x82, 0xcb, 0x53, 0xa7, 0x38, 0x81, 0x06,
0x16, 0xc7, 0x0f, 0x0c, 0xad, 0x96, 0x0b, 0x22,
0x03, 0x97, 0x84, 0xfd, 0x02, 0x38, 0xec, 0x9c,
0x71, 0x30, 0x43, 0xfa, 0x41, 0xc8, 0xcf, 0xfd,
0x22, 0x39, 0xd7, 0xcd, 0x7e, 0x79, 0x00, 0x4b,
0x1c, 0x40, 0xa3, 0x66, 0x23, 0x69, 0xf3, 0x9e,
0x5d, 0x85, 0xf7, 0xcf, 0x9f, 0xee, 0x08, 0x95,
0x75, 0x27, 0x4b, 0x86, 0xde, 0xad, 0x54, 0x9c,
0x4c, 0x6a, 0x5d, 0x94, 0x09, 0x34, 0x58, 0x11,
0x3c, 0x25, 0x0d, 0x7a, 0x90, 0xed, 0x2e, 0x7b,
0xee, 0xfe, 0x43, 0x6b, 0x58, 0xe5, 0x59, 0x65,
0x29, 0xe8, 0x22, 0x90, 0x33, 0xab, 0x59, 0x6d,
0x5f, 0xf4, 0xf0, 0x61, 0xba, 0x05, 0xaf, 0xf3,
0xb4, 0xe6, 0xb9, 0x29, 0x0b, 0xf2, 0xf7, 0xee,
0x92, 0xab, 0x4c, 0x7c, 0x63, 0xf7, 0x8f, 0xe0,
0x1e, 0x4e, 0x6c, 0x43, 0xbf, 0x07, 0x09, 0x9f,
0x61, 0x86, 0xc0, 0x3b, 0x2d, 0xf9, 0x2e, 0x1d,
0x85, 0xcb, 0x19, 0xe3, 0xf3, 0xb3, 0xaf, 0x97,
0x8d, 0x8c, 0x42, 0x8a, 0xd3, 0x64, 0x1e, 0xbb,
0x48, 0x78, 0x43, 0x3f, 0x89, 0xa5, 0xa8, 0x6e,
0x1d, 0x21, 0x6c, 0xbc, 0x3e, 0x3c, 0xdb, 0xc0,
0x5f, 0xda, 0x2d, 0x3c, 0xa4, 0xd2, 0xa0, 0xd4,
0x07, 0x55, 0x0f, 0x91, 0x38, 0x2d, 0x49, 0xa5,
0x62, 0x34, 0x1f, 0x26, 0xc9, 0xab, 0x1c, 0x84,
0x90, 0xb2, 0xce, 0xe1, 0x37, 0x37, 0x2b, 0x05,
0x79, 0x5f, 0x8a, 0x6d, 0x6f, 0xb1, 0xe5, 0xea,
0x00, 0xd4, 0x27, 0x19, 0x7f, 0xd2, 0x41, 0xb8,
0x33, 0x45, 0xd1, 0x33, 0x04, 0x69, 0x16, 0x22,
0x6b, 0x0f, 0xaa, 0x74, 0x0f, 0x61, 0x90, 0x53,
0x71, 0x45, 0x6c, 0xce, 0xb7, 0x14, 0x9c, 0x53,
0x2e, 0x20, 0xf5, 0xd9, 0x1b, 0x0c, 0xf3, 0xd5,
0x00, 0xfc, 0x2a, 0x0d, 0xfa, 0xbd, 0x3f, 0x4f,
0xb7, 0xa1, 0x7b, 0x38, 0x2d, 0x46, 0x84, 0xd6,
0x63, 0x90, 0x05, 0x45, 0xb6, 0xd8, 0x20, 0x1a,
0x25, 0x78, 0x37, 0x62, 0x78, 0x77, 0x74, 0x5b,
0x14, 0x4c, 0xfe, 0x52, 0x11, 0xd4, 0x5e, 0xcc,
0x82, 0xb0, 0xd7, 0x1d, 0xe1, 0x02, 0xed, 0x23,
0xb8, 0xa8, 0x20, 0xc6, 0x48, 0x60, 0x87, 0xba,
0x40, 0x20, 0x06, 0xfd, 0x8f, 0xdb, 0xe3, 0x12,
0x3d, 0xd9, 0x51, 0x97, 0xf8, 0xc6, 0x68, 0x98,
0x09, 0x0d, 0xff, 0x37, 0xec, 0x53, 0x61, 0x91,
0x6b, 0x86, 0xdb, 0xe6, 0x3a, 0xd9, 0x07, 0x0a,
0xff, 0x87, 0xaf, 0xd1, 0xbe, 0xfd, 0xa0, 0x44,
0xf7, 0x77, 0xba, 0x95, 0xcd, 0x69, 0xd9, 0xad,
0x1c, 0x85, 0x79, 0xea, 0x30, 0x7d, 0x8f, 0x19,
0x20, 0xfb, 0x23, 0x3d, 0xca, 0xd1, 0xeb, 0x5a,
0x4a, 0x2d, 0x38, 0x1c, 0x7b, 0xc9, 0x70, 0x7e,
0x68, 0x32, 0x99, 0x9f, 0x9d, 0x06, 0x89, 0xaf,
0xfd, 0x5c, 0x32, 0x80, 0x7f, 0x83, 0xfe, 0x24,
0xae, 0xe2, 0xbe, 0x01, 0x65, 0xf5, 0x5c, 0xea,
0xc4, 0x36, 0x66, 0x83, 0x48, 0x53, 0x3e, 0x51,
0x47, 0x59, 0x26, 0x61, 0xd0, 0xa3, 0x1f, 0x13,
0xdb, 0x85, 0x65, 0xc3, 0x33, 0x75, 0x41, 0x88,
0x15, 0xb3, 0x45, 0xbe, 0x51, 0xf2, 0x10, 0x82,
0x0f, 0x83, 0x92, 0x57, 0x68, 0xc9, 0x1b, 0x31,
0x30, 0x69, 0x03, 0x1f, 0x08, 0xb4, 0x9d, 0x87,
0x1b, 0xd0, 0x59, 0x40, 0x2d, 0xd3, 0x84, 0x2e,
0xac, 0x79, 0xa2, 0x6e, 0xda, 0x71, 0x18, 0x38,
0x8a, 0x20, 0x47, 0xa8 };
char peer1_4[] = { /* Packet 1145 */
0x76, 0x4d, 0x8d, 0xac, 0xe3, 0xe7, 0x21, 0xb6,
0x12, 0x5e, 0xc4, 0xa1, 0x30, 0x4d, 0xd0, 0x8d,
0x56, 0x9e, 0x6c, 0x1d, 0xe3, 0x9b, 0x9e, 0x51,
0xc8, 0xf3, 0xe6, 0xfe, 0x1d, 0x06, 0x50, 0x72,
0x55, 0x00, 0x49, 0x5f, 0xb5, 0xfe, 0x22, 0x08,
0x57, 0xe4, 0x1e, 0x08, 0xd4, 0x18, 0x48, 0x89,
0x09, 0x19, 0xe8, 0xd6, 0x4f, 0x4d, 0x20, 0xef,
0x94, 0xf6, 0x15, 0x9d, 0x0d, 0xd1, 0xb6, 0x05,
0x78, 0x2b, 0x6d, 0x63, 0x8d, 0x34, 0x24, 0xe7,
0xd3, 0x90, 0xb2, 0x10, 0x7f, 0x04, 0xcd, 0xc1,
0x71, 0x5b, 0x28, 0xdc, 0x79, 0xcf, 0xb2, 0x29,
0x57, 0xdf, 0x3c, 0xbd, 0xbe, 0x8e, 0x1e, 0x93,
0xb4, 0x94, 0x51, 0xa3, 0x47, 0xcb, 0xb3, 0xed,
0x3c, 0x6b, 0xbf, 0x4a, 0xf8, 0x74, 0x46, 0xb7,
0xc0, 0xc8, 0xe4, 0x98, 0x09, 0xb6, 0x7e, 0xde,
0xd7, 0x42, 0x65, 0x27, 0x3d, 0x0f, 0x5b, 0x1f,
0xf5, 0x1c, 0x52, 0x34, 0xda, 0xfd, 0x1d, 0x19,
0x43, 0x64, 0xa3, 0x0a, 0xf4, 0x57, 0x2f, 0x91,
0xce, 0xf6, 0xcf, 0x03, 0x69, 0xcf, 0x3f, 0xf0,
0xe8, 0xef, 0xbb, 0x29, 0x49, 0x35, 0xa9, 0x44,
0x87, 0x95, 0x59, 0x2b, 0x84, 0x79, 0xcf, 0xdb,
0xf7, 0x31, 0xcd, 0x26, 0xf6, 0xbd, 0x11, 0x0d,
0x1b, 0x62, 0x57, 0x82, 0xc6, 0xe7, 0x36, 0x68,
0xcb, 0xa3, 0xed, 0x78, 0xf3, 0x10, 0x17, 0x91,
0x20, 0xb5, 0x70, 0x80, 0x1a, 0x17, 0xd0, 0xd7,
0xba, 0xee, 0x22, 0x68, 0xde, 0x96, 0xcd, 0xd0,
0x83, 0x72, 0xa1, 0x25, 0xb6, 0x9e, 0xa6, 0xe4,
0x2c, 0x92, 0x13, 0x4c, 0x94, 0x6f, 0x55, 0x6f,
0xbc, 0x25, 0xb0, 0xc9, 0x12, 0x2a, 0x1b, 0x87,
0x3e, 0xfd, 0xb0, 0xa8, 0x2a, 0x11, 0xa0, 0x44,
0x90, 0x86, 0x39, 0x92, 0x55, 0xc0, 0xbb, 0x0e,
0xc5, 0x38, 0x9e, 0xd1, 0x54, 0x30, 0xc0, 0x10,
0xe2, 0xa5, 0x24, 0xa4, 0x4d, 0x54, 0x40, 0x8e,
0xbe, 0x79, 0xc6, 0x0f, 0x26, 0x01, 0x96, 0x5c,
0x18, 0xfc, 0x4a, 0x4b, 0x9c, 0xe7, 0xe1, 0x7d,
0x45, 0x66, 0x42, 0x30, 0x2f, 0xa3, 0xde, 0x8e,
0x02, 0xc7, 0xf1, 0x19, 0x6f, 0x29, 0x7b, 0x50,
0xdb, 0xbf, 0x8b, 0x26, 0x1c, 0x52, 0xee, 0xec,
0x92, 0x58, 0x6a, 0x01, 0x82, 0xe3, 0x7b, 0x9d,
0xd3, 0xef, 0x72, 0xd2, 0xf2, 0xeb, 0x87, 0x32,
0x88, 0x00, 0x8d, 0x71, 0xce, 0xe1, 0x47, 0xf7,
0xb1, 0x3e, 0x96, 0x8a, 0x5d, 0x75, 0x69, 0xfb,
0x00, 0xfb, 0x47, 0xe2, 0xe4, 0xe3, 0x2e, 0xbb,
0x26, 0xeb, 0x13, 0x2e, 0x74, 0x03, 0x9b, 0xf2,
0xee, 0x96, 0xa9, 0x46, 0xc9, 0xa8, 0x5c, 0xa6,
0x08, 0x6e, 0x61, 0x38, 0xf4, 0x0f, 0x24, 0xa1,
0x8d, 0x35, 0x59, 0x18, 0xe7, 0x19, 0xed, 0x6f,
0x41, 0xdc, 0x28, 0x85, 0x42, 0x13, 0xd6, 0xae,
0xda, 0x1e, 0xb2, 0x8c, 0x31, 0x0a, 0x78, 0xe7,
0x76, 0x4e, 0x38, 0x0e, 0x03, 0x30, 0xb7, 0xe4,
0x97, 0x49, 0x9d, 0xca, 0x92, 0x73, 0x97, 0x58,
0x3c, 0x90, 0x5a, 0x07, 0xd0, 0x75, 0xc7, 0x4f,
0x1e, 0x58, 0xa3, 0x02, 0x56, 0xb1, 0xf9, 0x86,
0xa9, 0xd3, 0xf8, 0xc6, 0xc8, 0xd7, 0x0e, 0x9d,
0xa7, 0xe1, 0xcc, 0x6c, 0x15, 0xee, 0x2d, 0xc2,
0x27, 0x3d, 0x21, 0xb5, 0x82, 0x1e, 0x6d, 0xf0,
0xcb, 0x3a, 0x72, 0xdc, 0x5a, 0x6f, 0x76, 0x22,
0x42, 0xd7, 0x97, 0xc6, 0x04, 0x54, 0x14, 0xf6,
0xb1, 0x92, 0x6c, 0x69, 0xdc, 0x27, 0xb7, 0xcd,
0x62, 0x98, 0xee, 0x10, 0x0e, 0x9c, 0xa8, 0xd4,
0x3e, 0xdf, 0x5a, 0xc1, 0xcd, 0xe7, 0x21, 0xa9,
0x82, 0x17, 0xaa, 0x04, 0x9a, 0x1b, 0x22, 0x90,
0x82, 0x08, 0x28, 0x0a, 0x5d, 0xaa, 0xb4, 0x2c,
0xbe, 0x10, 0x5c, 0xfd, 0x32, 0x77, 0x76, 0x97,
0x1e, 0xa2, 0xc8, 0xa6, 0xca, 0xe3, 0xfb, 0x51,
0x46, 0xc3, 0xef, 0xe6, 0x9b, 0x5d, 0x83, 0x43,
0x04, 0x6e, 0xad, 0x48, 0x39, 0x58, 0x64, 0xb9,
0x57, 0xba, 0xd1, 0xa2, 0x5e, 0x90, 0xf7, 0x80,
0x15, 0xba, 0x78, 0x32, 0x35, 0x20, 0x3c, 0xcb,
0xcc, 0x1f, 0xc4, 0x18, 0xa4, 0x4e, 0x15, 0x81,
0x69, 0x5e, 0xeb, 0xae, 0x39, 0x7e, 0x87, 0xf2,
0x82, 0x22, 0x29, 0xa6, 0xf0, 0xc4, 0x61, 0xca,
0x01, 0x7a, 0x7f, 0xfe, 0x86, 0xd2, 0x39, 0x33,
0x1b, 0x4f, 0x30, 0xd3, 0xdd, 0x16, 0x64, 0xf6,
0x50, 0xb3, 0x6f, 0x8e, 0x42, 0xb1, 0xfc, 0x73,
0x8b, 0x68, 0xf0, 0xfe, 0x14, 0x13, 0x92, 0x21,
0x4d, 0xfd, 0xa0, 0x11, 0x3c, 0x25, 0x16, 0x33,
0x3f, 0xca, 0xec, 0x42, 0xd8, 0xbe, 0xbf, 0xc8,
0x32, 0x17, 0xad, 0xac, 0x32, 0x4c, 0x7d, 0x7a,
0xc0, 0x34, 0x8f, 0xcc, 0xc1, 0x4d, 0x29, 0x4b,
0x3b, 0x08, 0x7a, 0x6b, 0x36, 0x7b, 0x25, 0x7c,
0xed, 0x60, 0x55, 0x0d, 0xcf, 0x8b, 0x76, 0x39,
0x8d, 0xba, 0x50, 0xe6, 0xc9, 0x58, 0x80, 0xbd,
0x9d, 0xf0, 0x62, 0x1a, 0x4e, 0xae, 0xa0, 0xea,
0xa2, 0xe8, 0x8d, 0x42, 0x50, 0x62, 0x0c, 0x1c,
0xbd, 0xa5, 0xa1, 0xf6, 0x9d, 0x10, 0x49, 0xf2,
0x8d, 0xc4, 0x3f, 0xf3, 0x1c, 0xc0, 0xce, 0x18,
0x25, 0x71, 0xe2, 0xe5, 0xa6, 0x46, 0x79, 0x2e,
0x21, 0x53, 0xd9, 0xe1, 0xd7, 0x83, 0x3f, 0x57,
0x54, 0x32, 0x75, 0xe1, 0x29, 0x22, 0x8c, 0xa2,
0x74, 0xe1, 0x07, 0x0d, 0xb3, 0x48, 0x51, 0x83,
0x0a, 0x17, 0xf3, 0x75, 0x68, 0x5b, 0xa9, 0x8f,
0xef, 0x06, 0xc2, 0xda, 0xb4, 0xde, 0xad, 0xe4,
0x9e, 0xed, 0x75, 0x13, 0xa5, 0xfd, 0xe3, 0xc8,
0x35, 0x87, 0x62, 0xf9, 0x1c, 0x80, 0x1a, 0x15,
0x07, 0xd8, 0x6b, 0xc6, 0x6d, 0xa2, 0x1a, 0x0f,
0xf6, 0x2d, 0x11, 0xfc, 0x65, 0x35, 0x96, 0xa6,
0xb4, 0x5b, 0x9d, 0x18, 0x9d, 0x8d, 0xd2, 0x6d,
0x65, 0x86, 0xf8, 0xae, 0x88, 0x7f, 0x81, 0xbc,
0x3a, 0xc3, 0xc5, 0x6f, 0xb0, 0x6f, 0x33, 0x7f,
0xcc, 0xc5, 0x29, 0xf1, 0x9c, 0x9c, 0x04, 0xd9,
0xee, 0x67, 0x51, 0x1f, 0xab, 0xe2, 0x3c, 0xaf,
0xaa, 0x85, 0x9c, 0xd1, 0xf8, 0x37, 0xca, 0x35,
0x77, 0x26, 0xa5, 0x5e, 0x1e, 0xf6, 0x39, 0xbb,
0xe7, 0xe0, 0x3e, 0xe1, 0x4f, 0x55, 0xf4, 0x29,
0xbb, 0x64, 0xc9, 0x7b, 0x21, 0x37, 0x15, 0xa9,
0xde, 0x6b, 0x64, 0x54, 0xb6, 0xb4, 0xf8, 0xc1,
0x0a, 0x87, 0x96, 0xa0, 0x8d, 0xc1, 0xa6, 0x2c,
0xea, 0x3a, 0xdf, 0x26, 0x90, 0xb0, 0x96, 0x01,
0x67, 0xaa, 0xda, 0x33, 0x7d, 0x4e, 0x6a, 0x83,
0x2e, 0xee, 0xcb, 0x07, 0xef, 0x9e, 0xfa, 0xac,
0x37, 0x5b, 0xa3, 0xb3, 0x9c, 0xab, 0x23, 0x3d,
0x6a, 0x02, 0x3c, 0x3e, 0x79, 0x05, 0x36, 0x2f,
0xbd, 0x7a, 0xc1, 0xc9, 0x6b, 0xf2, 0x5f, 0x24,
0x22, 0x9e, 0xe9, 0x24, 0xe7, 0x09, 0x79, 0xc0,
0xea, 0xe2, 0xa1, 0x11, 0xbb, 0x02, 0xc1, 0xa8,
0x36, 0x3b, 0xf8, 0x7b, 0x0b, 0x94, 0xd0, 0x2b,
0xdc, 0xb3, 0x4b, 0x13, 0xdf, 0x8a, 0xd4, 0xcb,
0x4d, 0x0d, 0x4e, 0xc8, 0x77, 0xb3, 0x1d, 0x93,
0xfa, 0x0f, 0xd5, 0x0f, 0x38, 0xa6, 0x81, 0x11,
0x43, 0x5c, 0xc8, 0xef, 0x19, 0xff, 0x55, 0x38,
0x20, 0x64, 0x3c, 0x59, 0xec, 0x4c, 0xf8, 0x81,
0x89, 0x11, 0x3f, 0x01, 0xa3, 0xf5, 0xce, 0xf6,
0x56, 0x82, 0x41, 0xa5, 0x09, 0xda, 0x45, 0x9f,
0xcf, 0xff, 0xe8, 0x8e, 0xa6, 0x55, 0xad, 0x08,
0xed, 0x7e, 0xa9, 0xe1, 0x7c, 0x52, 0x19, 0xf0,
0x72, 0x65, 0x52, 0x3d, 0x60, 0xcb, 0x7f, 0xe5,
0xee, 0xa0, 0x95, 0x9c, 0x6d, 0xd8, 0xcd, 0xfa,
0xfd, 0x20, 0x38, 0xf1, 0x33, 0x5c, 0xa8, 0x1d,
0x6e, 0xea, 0x8e, 0x87, 0xe6, 0x98, 0x73, 0x1d,
0xb8, 0xd7, 0x88, 0xec, 0xdd, 0x54, 0x94, 0x5f,
0x84, 0x53, 0x83, 0x68, 0x08, 0x75, 0xe9, 0x70,
0xc2, 0x31, 0x8f, 0x1a, 0x77, 0x6a, 0xea, 0x0e,
0x71, 0x86, 0x3a, 0x26, 0x12, 0x28, 0x71, 0x4a,
0x29, 0x02, 0x12, 0xd4, 0x19, 0x85, 0xf2, 0x42,
0x0d, 0x22, 0x31, 0x71, 0x33, 0xa7, 0xc1, 0x79,
0x41, 0x46, 0x6b, 0x3d, 0x52, 0x17, 0x65, 0x0e,
0xd7, 0x9b, 0xb4, 0x04, 0xdf, 0x96, 0x8f, 0x0f,
0x46, 0x75, 0xb8, 0x58, 0x69, 0x4e, 0x5e, 0x95,
0x50, 0xe7, 0x41, 0xea, 0x83, 0x5c, 0x7b, 0x58,
0xc5, 0x51, 0xc0, 0xf4, 0xdd, 0xb2, 0xa2, 0x4c,
0x11, 0xf0, 0x61, 0x0a, 0xab, 0x3b, 0xa6, 0x27,
0x73, 0x24, 0x92, 0xe4, 0x32, 0xf4, 0x6d, 0xb2,
0x21, 0xee, 0x4f, 0x0d, 0x20, 0x89, 0x53, 0x33,
0xaf, 0x78, 0x9e, 0x6c, 0xdd, 0xa1, 0xea, 0x4e,
0x95, 0xaf, 0x57, 0x6d, 0x4a, 0xe6, 0x64, 0x6c,
0xa8, 0xa1, 0xe1, 0x11, 0x25, 0xd7, 0x19, 0x13,
0xcc, 0x48, 0xaa, 0x75, 0x87, 0xc6, 0x05, 0x28,
0xeb, 0x3b, 0xde, 0x38, 0x65, 0x0e, 0x30, 0x4b,
0x8d, 0x33, 0xcf, 0x73, 0xb2, 0xf8, 0x17, 0x54,
0xf0, 0x96, 0x9f, 0xf2, 0x25, 0x4c, 0xce, 0x56,
0x21, 0x10, 0x0a, 0xef, 0x15, 0xac, 0xd9, 0x1a,
0x10, 0xf3, 0xae, 0xc3, 0xc5, 0xbc, 0xdf, 0xef,
0x73, 0xd5, 0x20, 0xd8, 0x31, 0x22, 0x60, 0x3a,
0xc3, 0xe3, 0x95, 0x6f, 0x93, 0x90, 0xe8, 0x0d,
0x5f, 0x0c, 0xee, 0x85, 0xfb, 0xda, 0xd3, 0xad,
0x70, 0xbc, 0x02, 0x53, 0xed, 0xe6, 0xec, 0x71,
0x63, 0x16, 0x18, 0x81, 0x61, 0x67, 0x50, 0x6b,
0xd5, 0x83, 0xbc, 0x8f, 0xeb, 0x7f, 0x93, 0x92,
0x4e, 0x5d, 0x6c, 0x19, 0x09, 0x55, 0x2a, 0xf7,
0x64, 0x91, 0x99, 0x16, 0xda, 0xad, 0xbd, 0x02,
0x72, 0xb7, 0xc4, 0x48, 0xb5, 0x70, 0xd3, 0x4a,
0x0f, 0x3a, 0x22, 0x41, 0x38, 0xd2, 0x06, 0xa5,
0x20, 0x69, 0xdc, 0xb3, 0xb8, 0x74, 0xcb, 0xc5,
0xed, 0x42, 0x5f, 0x3e, 0x61, 0x07, 0xc2, 0x96,
0x17, 0x4b, 0xc2, 0x1f, 0x1f, 0xf7, 0xad, 0x47,
0xb9, 0xd7, 0x2f, 0x9b, 0x95, 0xd6, 0x0b, 0x97,
0xfb, 0xd7, 0xf4, 0x34, 0xf6, 0x3d, 0x88, 0xfa,
0xf5, 0x5f, 0xe5, 0x6a, 0x2c, 0xfb, 0x74, 0x66,
0x01, 0x96, 0x73, 0x46, 0xf0, 0xf8, 0x86, 0x29,
0x14, 0x5e, 0x30, 0x7f, 0x48, 0x3d, 0x3c, 0xb1,
0xde, 0xa3, 0x4d, 0x73, 0x53, 0xda, 0xd4, 0x8f,
0xf8, 0xda, 0x7e, 0x12, 0x17, 0x8a, 0xae, 0xbc,
0x45, 0xb8, 0xa1, 0xe8, 0xc0, 0x8b, 0x7b, 0xe5,
0xae, 0xe7, 0xf4, 0x09, 0xf9, 0x83, 0xfa, 0x86,
0xfa, 0xc8, 0xd9, 0xf5, 0x22, 0x0d, 0x2f, 0xc5,
0xc4, 0xac, 0xb0, 0x85, 0xee, 0xf3, 0x80, 0x97,
0xe3, 0x02, 0xee, 0x3c, 0x8b, 0x31, 0xe0, 0x3c,
0x27, 0xa0, 0x72, 0xdc, 0x08, 0xfb, 0x4e, 0xeb,
0x75, 0xa9, 0xf5, 0x77, 0x09, 0xa6, 0xdb, 0xb3,
0xab, 0xca, 0x1e, 0xbf, 0x2d, 0xf2, 0x74, 0x7a,
0x30, 0x71, 0x9d, 0xc9, 0x4e, 0x91, 0x78, 0x8c,
0x35, 0xda, 0x9e, 0xf1 };
char peer1_5[] = { /* Packet 1146 */
0xd5, 0x76, 0x98, 0x10, 0x46, 0x3f, 0xb8, 0x3a,
0xff, 0xec, 0xa4, 0x71, 0xa2, 0xbb, 0x14, 0xdc,
0x76, 0x03, 0xa1, 0x6b, 0xa9, 0x59, 0xd8, 0x66,
0xed, 0x3f, 0x6b, 0x46, 0xe2, 0x3b, 0x15, 0xf7,
0xfc, 0xac, 0x1d, 0x2d, 0xce, 0x9c, 0x2b, 0x38,
0x53, 0x87, 0x6c, 0x03, 0xd1, 0x50, 0x0d, 0xcb,
0xa1, 0xde, 0xbb, 0x63, 0x71, 0x60, 0x6f, 0x40,
0x49, 0xc5, 0x68, 0xd2, 0x9b, 0x8d, 0x2b, 0xd4,
0xad, 0x7c, 0x9e, 0x18, 0xb2, 0xdc, 0x8a, 0xb7,
0x3d, 0x33, 0xbf, 0x5c, 0x90, 0x11, 0xfe, 0x6d,
0xd6, 0x9a, 0xa7, 0x55, 0x87, 0xf9, 0xda, 0xe9,
0x24, 0xa8, 0x42, 0x38, 0x06, 0x61, 0x48, 0x34,
0xa0, 0x09, 0xe8, 0x90, 0x9c, 0x12, 0xf0, 0xdf,
0x22, 0xe4, 0x12, 0xac, 0x18, 0x56, 0xfd, 0x38,
0x81, 0xfe, 0xdd, 0xf9, 0xa1, 0x21, 0xab, 0x20,
0x27, 0x25, 0x0f, 0x24, 0x9c, 0x2d, 0x04, 0xdb,
0xe5, 0x25, 0x20, 0xfa, 0xda, 0xfe, 0xc6, 0x8f,
0xf1, 0x99, 0x29, 0xe1, 0xd1, 0x32, 0x7b, 0x54,
0xe5, 0x01, 0xca, 0xad, 0xed, 0xcd, 0x4f, 0xb6,
0xd0, 0xdd, 0xfa, 0x70, 0xa0, 0xd4, 0x9f, 0x07,
0xb6, 0xd0, 0xc1, 0x09, 0x79, 0x29, 0x51, 0x48,
0x57, 0x5c, 0x7b, 0x3b, 0x6e, 0x45, 0x3b, 0xb3,
0xf5, 0xeb, 0x63, 0x47, 0xa4, 0xd4, 0x10, 0x71,
0x27, 0xf4, 0x2b, 0x8d, 0xc7, 0x16, 0xfd, 0xc9,
0xd7, 0x60, 0x96, 0x33, 0x22, 0x41, 0xc1, 0x5e,
0xbc, 0xaa, 0x83, 0xd0, 0x1f, 0xc1, 0x7b, 0x4f,
0x55, 0xe9, 0x91, 0x7e, 0x9e, 0x01, 0x2d, 0x78,
0x13, 0xdc, 0xff, 0x77, 0x61, 0x51, 0x15, 0x55,
0x61, 0xa2, 0xb3, 0xe8, 0x21, 0x7a, 0x7c, 0x72,
0xb0, 0xcb, 0x55, 0xec, 0xa3, 0x49, 0x00, 0x70,
0x2b, 0xdb, 0x8e, 0xe4, 0x3a, 0xbc, 0x70, 0x54,
0x2d, 0x34, 0x8a, 0x72, 0xd6, 0xb3, 0x3e, 0x12,
0xaf, 0x82, 0xc1, 0x21, 0x83, 0x67, 0xa6, 0x8d,
0xe6, 0x93, 0xf1, 0x12, 0x61, 0xe4, 0xff, 0x8d,
0xbc, 0xb8, 0x17, 0xa9, 0x72, 0x55, 0xb7, 0x7c,
0x32, 0xa6, 0x8b, 0xc3, 0x7a, 0xef, 0x57, 0xb5,
0x59, 0x4a, 0xc9, 0x1c, 0xee, 0xfd, 0x78, 0xf6,
0x87, 0x32, 0x02, 0x1c, 0xd3, 0xdd, 0x6b, 0x9e,
0xa1, 0x06, 0xd8, 0x00, 0xbd, 0xe8, 0xe4, 0xe1,
0x27, 0x43, 0xba, 0x71, 0x86, 0x38, 0xda, 0x5b,
0xb5, 0x01, 0xf2, 0x4d, 0x93, 0x3f, 0xc8, 0xd4,
0xaa, 0xb4, 0x2a, 0x79, 0x59, 0x5b, 0xc0, 0x14,
0xb3, 0xe6, 0x1a, 0x0d, 0x4e, 0x77, 0x9f, 0xfb,
0x67, 0x1e, 0x12, 0x71, 0x16, 0x07, 0x06, 0xd6,
0x1c, 0xb1, 0x78, 0x9d, 0xf5, 0xe7, 0x46, 0xa4,
0x22, 0xaf, 0x89, 0xd6, 0x8d, 0x17, 0xc7, 0xe0,
0x7e, 0xd0, 0x83, 0xd2, 0xa0, 0x17, 0x6a, 0xc1,
0x4f, 0xef, 0x6a, 0xe2, 0x62, 0xfe, 0xbd, 0x8b,
0x70, 0x8c, 0x77, 0xf0, 0xd7, 0x4d, 0x25, 0x93,
0xb1, 0xf8, 0xd7, 0x46, 0xd6, 0x14, 0x87, 0x21,
0x11, 0x44, 0x5f, 0xa6, 0x7e, 0xb7, 0x83, 0x75,
0x14, 0x2f, 0x77, 0xb1, 0xdf, 0x6b, 0x23, 0xbe,
0x4f, 0x14, 0xc2, 0x60, 0x78, 0x47, 0xf5, 0xc7,
0x4c, 0x5b, 0xd8, 0x4f, 0xe4, 0xb4, 0xbf, 0xc3,
0xbc, 0xae, 0x11, 0x1d, 0x22, 0xe8, 0xf3, 0x59,
0xde, 0x47, 0x5a, 0x9f, 0x39, 0xd0, 0x63, 0x7c,
0xa0, 0x55, 0x49, 0xed, 0xcb, 0xaa, 0xa0, 0xd0,
0x16, 0xf4, 0xaa, 0x0b, 0x16, 0x06, 0xd6, 0x15,
0x27, 0x3a, 0xe8, 0x85, 0x6f, 0x14, 0x9d, 0x76,
0x41, 0x2e, 0xb5, 0x2d, 0x7d, 0x4e, 0x09, 0xf3,
0x94, 0x6f, 0xd9, 0xc9, 0x1e, 0x68, 0x9f, 0xc7,
0x32, 0x97, 0x10, 0x1d, 0x31, 0x87, 0x36, 0x02,
0xfe, 0x75, 0x36, 0x12, 0x92, 0x2d, 0x99, 0xea,
0xc3, 0x62, 0x1d, 0xf7, 0x72, 0x72, 0x44, 0x27,
0x13, 0xf3, 0xdb, 0x25, 0x9a, 0x8c, 0x54, 0x5f,
0xb5, 0x72, 0x75, 0xb8, 0xaf, 0x9b, 0x9a, 0x38,
0xf4, 0x06, 0x7d, 0x9b, 0x52, 0xe0, 0x26, 0x1b,
0x23, 0x8f, 0xf2, 0x5d, 0x2b, 0x49, 0xef, 0xb5,
0x41, 0x3b, 0x16, 0xbc, 0x2a, 0x17, 0x31, 0x92,
0xff, 0xb1, 0x0f, 0x30, 0x7b, 0x1c, 0x94, 0x8b,
0x49, 0x0d, 0x05, 0xa3, 0xb9, 0x59, 0x10, 0x57,
0xc3, 0xe3, 0x76, 0xb0, 0x57, 0x6f, 0xb0, 0x70,
0x4a, 0x0f, 0x8f, 0xea, 0x83, 0x8a, 0xf4, 0xcc,
0xb4, 0x29, 0x5b, 0xc3, 0x61, 0x8b, 0x81, 0xda,
0x43, 0x5f, 0xfb, 0x4d, 0x61, 0x6c, 0xb0, 0xd9,
0x07, 0xb5, 0x81, 0x46, 0x03, 0x6f, 0xbd, 0x21,
0x96, 0xbf, 0xa4, 0xea, 0xae, 0xaf, 0x35, 0x26,
0x3f, 0x8f, 0x67, 0x70, 0xdc, 0x4a, 0x6e, 0x41,
0x99, 0xe1, 0xb0, 0x5e, 0xad, 0x43, 0x8a, 0x86,
0xed, 0xd7, 0x22, 0xf7, 0x08, 0xb3, 0x5e, 0x96,
0x12, 0xd5, 0x05, 0xa1, 0x9b, 0x11, 0xbf, 0xad,
0xe8, 0x6d, 0xdc, 0xed, 0x83, 0x6b, 0xfb, 0xd0,
0xab, 0xbe, 0x72, 0x81, 0x3e, 0x90, 0x98, 0x13,
0x0c, 0x0a, 0xe3, 0x40, 0x46, 0xd6, 0x73, 0x5f,
0x59, 0x99, 0x2b, 0x87, 0x37, 0x84, 0x65, 0x4a,
0xc5, 0x4a, 0xd9, 0x87, 0x84, 0x01, 0x3b, 0x10,
0xa4, 0xe9, 0x25, 0xe4, 0x02, 0x65, 0xa2, 0x80,
0xbf, 0x9d, 0x4a, 0x52, 0x26, 0x83, 0x22, 0xce,
0xda, 0x0d, 0x1f, 0x16, 0x39, 0x4f, 0xcb, 0x00,
0x3e, 0xdf, 0x23, 0xa3, 0xdf, 0xc0, 0xd3, 0x2d,
0x88, 0x89, 0xb4, 0x3b, 0x5c, 0x2e, 0x66, 0x26,
0x76, 0x9a, 0x2e, 0xc1, 0x8b, 0xdf, 0x7c, 0x95,
0x7b, 0x8e, 0x52, 0x06, 0xe7, 0xae, 0xcd, 0x5a,
0x0f, 0x28, 0x92, 0x14, 0x58, 0x6c, 0x8c, 0xf6,
0x54, 0x33, 0x40, 0x05, 0xd4, 0x7b, 0xfa, 0xbc,
0x0f, 0xae, 0x87, 0xfe, 0x50, 0xd0, 0xa7, 0x53,
0x13, 0xfc, 0x9a, 0x22, 0xde, 0x94, 0x0d, 0x72,
0x00, 0x2c, 0x4c, 0x91, 0xb4, 0x82, 0x0e, 0xdb,
0x24, 0xda, 0x81, 0xc7, 0x59, 0xec, 0x2d, 0x5d,
0xb3, 0x9c, 0x07, 0x94, 0x47, 0xbf, 0x3c, 0xbc,
0xc6, 0xfc, 0x36, 0x4c, 0xfb, 0x2d, 0x1d, 0xfc,
0x72, 0xcf, 0x97, 0x5b, 0xfd, 0xe8, 0x17, 0xce,
0x16, 0x93, 0xf3, 0x29, 0x27, 0xda, 0x6d, 0x93,
0x78, 0xc6, 0x31, 0x51, 0x49, 0xb6, 0xaf, 0x56,
0xc5, 0xfb, 0x6e, 0xc2, 0x24, 0x1d, 0x01, 0x3b,
0x82, 0xbe, 0x79, 0xd0, 0x76, 0xc8, 0x50, 0xe9,
0xac, 0x5e, 0xa2, 0x78, 0xe9, 0xb3, 0x18, 0xaf,
0x4f, 0x90, 0xe7, 0x4d, 0xf4, 0xbb, 0x8d, 0x42,
0x73, 0x65, 0xeb, 0xbe, 0xfd, 0x75, 0x00, 0xcc,
0xcf, 0x3c, 0xd8, 0x5e, 0x36, 0x24, 0x2d, 0xd1,
0x4d, 0xe9, 0x0b, 0x08, 0x11, 0x16, 0x63, 0xb1,
0x39, 0x1c, 0x68, 0x7c, 0x5d, 0x41, 0x04, 0x1c,
0x05, 0x84, 0x8a, 0x89, 0x0d, 0x12, 0x51, 0x96,
0x76, 0xb2, 0xcf, 0x06, 0xd0, 0xa8, 0x63, 0x86,
0x4b, 0x8d, 0x1c, 0xe1, 0xc3, 0xe4, 0x6a, 0x5d,
0x23, 0xa5, 0x98, 0xc8, 0xa3, 0x63, 0xb5, 0x83,
0x23, 0xc3, 0xa2, 0xac, 0x72, 0xdd, 0x82, 0xd2,
0x3e, 0xd8, 0xf3, 0xe8, 0x88, 0xca, 0x32, 0x17,
0xd8, 0xcc, 0x4d, 0xdd, 0xd3, 0x20, 0x37, 0x8f,
0x74, 0x5c, 0xc6, 0x72, 0xde, 0x04, 0x8b, 0x8b,
0x41, 0x19, 0xcc, 0x77, 0x92, 0x38, 0x4f, 0x3c,
0x6b, 0x33, 0x7e, 0xa4, 0xfc, 0x82, 0xea, 0x02,
0x5b, 0x50, 0x98, 0xf4, 0x26, 0x4e, 0x6f, 0xbd,
0x92, 0x53, 0x72, 0x3c, 0xed, 0x29, 0x2c, 0xf3,
0xba, 0x2a, 0x94, 0x69, 0xd1, 0x92, 0xc8, 0x09,
0xde, 0x24, 0xbe, 0x4a, 0xe5, 0x0c, 0x6c, 0xbe,
0x76, 0xef, 0x28, 0x9d, 0xc5, 0xe7, 0x85, 0xbb,
0xfe, 0xbc, 0x77, 0xd3, 0x99, 0x96, 0x66, 0xc3,
0x1b, 0x00, 0x05, 0xc5, 0xc3, 0x3d, 0x53, 0xb1,
0x78, 0x36, 0x73, 0x1f, 0x6f, 0x9d, 0xc1, 0x3a,
0x98, 0x85, 0xf6, 0x65, 0x2e, 0x59, 0x44, 0xcf,
0xb8, 0x53, 0xc0, 0x38, 0xfd, 0xd7, 0x4a, 0x9b,
0x41, 0xe4, 0xe9, 0x9d, 0xb6, 0x8e, 0x15, 0xf2,
0x15, 0x2c, 0x55, 0xe7, 0xc2, 0xd1, 0xed, 0x12,
0x4d, 0x95, 0x29, 0x10, 0xa5, 0x07, 0x5e, 0xcf,
0x5c, 0x95, 0x63, 0x3b, 0xa2, 0x8b, 0xf0, 0xd9,
0x6e, 0x58, 0x63, 0x18, 0xde, 0x5c, 0xfc, 0x69,
0xd8, 0x38, 0x66, 0x5c, 0x72, 0x33, 0x78, 0xfd,
0x87, 0x39, 0xd3, 0xca, 0x0d, 0xb4, 0x80, 0xc6,
0xfe, 0x9a, 0xfe, 0x61, 0x93, 0x4e, 0x91, 0x90,
0x34, 0x7e, 0x09, 0x6b, 0xf2, 0x67, 0xf2, 0x79,
0x92, 0xcb, 0x6b, 0x1b, 0x10, 0xb3, 0x3b, 0x2d,
0x8f, 0x55, 0xd9, 0xe1, 0x54, 0xea, 0x7b, 0x36,
0x67, 0x91, 0xcf, 0xd2, 0x6f, 0x25, 0xaa, 0xad,
0xa1, 0x8e, 0x2b, 0x16, 0xdd, 0xef, 0x21, 0xe3,
0x9d, 0xb1, 0x5e, 0xaf, 0xaa, 0xd8, 0x62, 0x45,
0xd1, 0x7f, 0x90, 0xb3, 0x8c, 0x34, 0x0d, 0x80,
0x6b, 0xef, 0x62, 0x98, 0x42, 0xab, 0x87, 0x09,
0xae, 0x9c, 0xc5, 0xa6, 0x09, 0x40, 0x04, 0x87,
0xa0, 0x14, 0xba, 0xd6, 0x59, 0x5b, 0xf7, 0xbd,
0xc5, 0xb1, 0xc4, 0x35, 0x8b, 0xe6, 0x47, 0x83,
0x32, 0xf4, 0x94, 0xfd, 0x39, 0xd7, 0x46, 0xc6,
0x37, 0xfa, 0x7c, 0x5f, 0x9a, 0xaf, 0x3e, 0xb4,
0xa0, 0xb4, 0x43, 0x07, 0x46, 0xa7, 0xbb, 0xee,
0x36, 0xd6, 0x28, 0x06, 0xf3, 0x22, 0xf6, 0xcd,
0xbe, 0x3a, 0x97, 0x28, 0x6e, 0x76, 0xb1, 0x43,
0xc6, 0xc7, 0xb8, 0x86, 0xa2, 0x5b, 0xe1, 0xf6,
0x65, 0x3a, 0x30, 0x46, 0x90, 0x67, 0x88, 0x83,
0x8f, 0xdb, 0xa0, 0x68, 0xe5, 0x3f, 0x14, 0x76,
0xbc, 0x6e, 0x7d, 0x70, 0x8f, 0x33, 0x35, 0xfe,
0xeb, 0xb3, 0x81, 0xe3, 0x26, 0x1c, 0x30, 0x86,
0xb0, 0x1f, 0x19, 0x1e, 0xdc, 0x73, 0x50, 0x3b,
0xe5, 0xb3, 0x52, 0xbe, 0x64, 0xd2, 0x09, 0x4e,
0xa5, 0x4d, 0x2a, 0x8c, 0xf0, 0xa9, 0xfe, 0xac,
0x2b, 0xde, 0x54, 0x93, 0x99, 0xd8, 0x71, 0xa1,
0x6d, 0x6d, 0xff, 0xb5, 0x97, 0x3f, 0x0c, 0xfe,
0x02, 0x95, 0xfb, 0x9c, 0xee, 0xfb, 0x5b, 0xc2,
0xd7, 0x05, 0xb8, 0x3c, 0xcd, 0x09, 0x13, 0xe3,
0xea, 0x70, 0xee, 0x5c, 0x60, 0x9e, 0x57, 0xe1,
0x4d, 0x70, 0x26, 0xc2, 0xa3, 0x5a, 0x5c, 0x90,
0xc4, 0x53, 0xb6, 0x83, 0x7f, 0x3e, 0x5c, 0x37,
0xe9, 0x6a, 0xbb, 0x91, 0x69, 0x92, 0x40, 0xb5,
0x5b, 0x15, 0xbf, 0xc6, 0x6b, 0xd3, 0xce, 0xd5,
0x7c, 0xa7, 0x97, 0x37, 0x49, 0xbe, 0x30, 0xa2,
0xc0, 0x21, 0xf7, 0x1d, 0x57, 0x0a, 0x49, 0x51,
0x0d, 0x6a, 0xfa, 0x50, 0x03, 0xd6, 0x29, 0x08,
0x83, 0x9a, 0xf4, 0x46, 0x87, 0x1c, 0xa9, 0x6f,
0x27, 0x01, 0x2c, 0x6c, 0x98, 0x1c, 0x3a, 0x9e,
0xbd, 0xe6, 0xe0, 0xa9, 0x23, 0x6c, 0x45, 0x1d,
0x87, 0x03, 0xac, 0xae, 0xfe, 0x7a, 0x6c, 0x7d,
0xcb, 0x43, 0xad, 0xd7, 0xcd, 0x66, 0x62, 0xe6,
0xe4, 0x37, 0x4f, 0xff, 0x9a, 0xf0, 0x35, 0x77,
0xaa, 0x20, 0x9f, 0x4c };
char peer1_6[] = { /* Packet 1147 */
0xd2, 0x60, 0x34, 0xd8, 0x85, 0x24, 0xbe, 0xa9,
0x3f, 0x00, 0xbd, 0x23, 0xde, 0x0a, 0xa7, 0x08,
0x95, 0xe5, 0x91, 0xc7, 0x27, 0x6f, 0x6c, 0x42,
0xaf, 0x0c, 0xd1, 0xfd, 0x57, 0x1f, 0x1d, 0xbb,
0x62, 0x8d, 0x1f, 0x0f, 0x8b, 0xbe, 0xaf, 0x1f,
0xa0, 0x59, 0x2e, 0x65, 0xf0, 0x02, 0x81, 0x1d,
0x4c, 0x13, 0x5f, 0x7c, 0x13, 0x2d, 0x6f, 0x37,
0x68, 0x73, 0x1a, 0xd9, 0xc2, 0xf5, 0x1f, 0xbf,
0xe8, 0x63, 0xb1, 0x8e, 0x45, 0x3e, 0xc0, 0x13,
0x16, 0x64, 0xbc, 0x10, 0x6b, 0x16, 0xcd, 0xfd,
0xb6, 0xc5, 0xe8, 0xe6, 0x0b, 0x30, 0x3f, 0xd3,
0xf4, 0xd8, 0xcf, 0x20, 0x76, 0x72, 0x2e, 0x65,
0xb3, 0x87, 0xcd, 0x94, 0xc7, 0xa9, 0x53, 0x47,
0x8c, 0xef, 0xe8, 0xb6, 0x1f, 0x66, 0x8e, 0x58,
0xb7, 0xa8, 0x7f, 0x8c, 0xbe, 0x5f, 0x14, 0x4f,
0x98, 0xe2, 0x07, 0x15, 0x40, 0x66, 0x2d, 0x92,
0xe4, 0xb3, 0xcb, 0x76, 0x6f, 0xa1, 0xd6, 0x63,
0x1d, 0x03, 0x35, 0xbd, 0xd5, 0x79, 0x26, 0xb5,
0x19, 0xde, 0xf8, 0xcf, 0x7e, 0xe4, 0x70, 0xd2,
0xe1, 0xf3, 0x15, 0xe5, 0x19, 0x50, 0xf7, 0xc8,
0x89, 0x09, 0x9e, 0x52, 0x7e, 0x19, 0x5f, 0x23,
0x56, 0xf4, 0xd2, 0xf7, 0x48, 0xe9, 0xcb, 0x47,
0x09, 0x12, 0x9b, 0x22, 0xe2, 0x5a, 0x83, 0xc2,
0x49, 0x28, 0x12, 0x41, 0x25, 0x31, 0x42, 0xf1,
0xe8, 0xf0, 0xb4, 0xa2, 0x74, 0x61, 0x6f, 0x29,
0xaa, 0x88, 0x81, 0xf5, 0x3f, 0x5b, 0xba, 0x6d,
0x0d, 0x7c, 0x71, 0x22, 0x28, 0xc1, 0x61, 0x0c,
0x4b, 0x73, 0x2b, 0xac, 0x53, 0x7c, 0xc3, 0xe6,
0x6b, 0xa8, 0xa4, 0xa8, 0x94, 0xf2, 0xb9, 0x1d,
0x92, 0xda, 0xdb, 0x7e, 0x91, 0x79, 0x4b, 0x02,
0xa6, 0xcd, 0x21, 0xb2, 0xaa, 0x78, 0x8a, 0x65,
0x9f, 0xd9, 0xb0, 0x48, 0xc3, 0x7c, 0xfd, 0x6f,
0x5c, 0xf9, 0x4f, 0xbd, 0x30, 0x8d, 0x7e, 0x9b,
0xe2, 0x67, 0xbb, 0xc5, 0x94, 0x46, 0xf9, 0x3e,
0x39, 0x8c, 0x40, 0xf0, 0xa6, 0x0b, 0x80, 0xda,
0x76, 0x47, 0x85, 0xc1, 0x94, 0xe3, 0xe7, 0x42,
0x19, 0x46, 0xb1, 0x7f, 0x34, 0x47, 0xe0, 0x50,
0xe2, 0x62, 0x75, 0x95, 0x8c, 0xb3, 0xb6, 0x4b,
0xea, 0x16, 0xe3, 0x74, 0xb3, 0x09, 0xde, 0xbb,
0xa8, 0xca, 0xba, 0x4b, 0xbb, 0x70, 0xb5, 0xdc,
0x80, 0xeb, 0x03, 0x8a, 0x60, 0x9e, 0x42, 0x0a,
0x7e, 0xaf, 0x5e, 0x28, 0xbf, 0xf2, 0xae, 0x90,
0x8d, 0xda, 0x81, 0xbc, 0x1f, 0x74, 0x25, 0x06,
0x56, 0xd7, 0x72, 0xd9, 0x18, 0x66, 0x98, 0xb4,
0x85, 0x1f, 0xb1, 0x4b, 0xfc, 0x14, 0x44, 0x3c,
0x4a, 0x8d, 0xca, 0x58, 0x3e, 0x64, 0x01, 0x26,
0xf7, 0xbd, 0xa0, 0xaf, 0x95, 0xbb, 0x18, 0x2c,
0xe6, 0xf6, 0x90, 0xae };
|
Below is an extract of SQL code. Evaluate whether it has a high educational value and could help teach SQL and database concepts. Use the additive 5-point scoring system described below. Points are accumulated based on the satisfaction of each criterion:
- Add 1 point if the code contains valid SQL syntax, even if it's just basic queries or simple table operations.
- Add another point if the code addresses practical SQL concepts (e.g., JOINs, subqueries), even if it lacks comments.
- Award a third point if the code is suitable for educational use and introduces key concepts in SQL and database management, even if the topic is somewhat advanced (e.g., indexes, transactions). The code should be well-structured and contain some comments.
- Give a fourth point if the code is self-contained and highly relevant to teaching SQL. It should be similar to a database course exercise, demonstrating good practices in query writing and database design.
- Grant a fifth point if the code is outstanding in its educational value and is perfectly suited for teaching SQL and database concepts. It should be well-written, easy to understand, and contain explanatory comments that clarify the purpose and impact of each part of the code.
The extract:
--- MySQL mode ---
select name
from employee
order by name asc;
After examining the extract:
- Briefly justify your total score, up to 100 words.
- Conclude with the score using the format: "Educational score: <total points>"
| sql | 1 | --- MySQL mode ---
select name
from employee
order by name asc; |
Below is an extract from a Rust program. Evaluate whether it has a high educational value and could help teach coding. Use the additive 5-point scoring system described below. Points are accumulated based on the satisfaction of each criterion:
- Add 1 point if the program contains valid Rust code, even if it's not educational, like boilerplate code, configurations, or niche concepts.
- Add another point if the program addresses practical Rust concepts, even if it lacks comments.
- Award a third point if the program is suitable for educational use and introduces key concepts in programming, even if the topic is advanced (e.g., ownership, lifetimes). The code should be well-structured and contain some comments.
- Give a fourth point if the program is self-contained and highly relevant to teaching Rust. It should be similar to a school exercise, a tutorial, or a Rust course section.
- Grant a fifth point if the program is outstanding in its educational value and is perfectly suited for teaching Rust. It should be well-written, easy to understand, and contain step-by-step explanations and comments.
The extract:
use std::{sync::mpsc::Receiver, io::Write, io::stdin, io::stdout, net::IpAddr, process::exit, str, sync::Mutex, sync::mpsc, thread};
use core::convert::TryInto;
use rand::Rng;
use ring::digest;
use termion::input::TermRead;
use crate::{constants, algorithms, crypto, session::Session, kex, terminal, ed25519};
pub struct SSH{
host: IpAddr,
username: String,
client_session: Session,
ciphers: Vec<u8>,
received_ciphers: Vec<u8>,
server_host_key: Vec<u8>,
server_signature: Vec<u8>,
kex_keys: Option<kex::Kex>
}
impl SSH {
pub fn new(username: String, host: IpAddr, port: u16) -> SSH {
SSH {
host,
username,
client_session: Session::new(host, port).unwrap(),
ciphers: Vec::new(),
received_ciphers: Vec::new(),
server_host_key: Vec::new(),
server_signature: Vec::new(),
kex_keys: None,
}
}
fn get_password(&self) -> String {
let stdout = stdout();
let mut stdout = stdout.lock();
let stdin = stdin();
let mut stdin = stdin.lock();
stdout.write_all(b"password: ").unwrap();
stdout.flush().unwrap();
let password = stdin.read_passwd(&mut stdout).unwrap().unwrap();
stdout.write_all(b"\n").unwrap();
password
}
fn protocol_string_exchange(&mut self, client_protocol_string: &str) -> String{
let mut protocol_string = client_protocol_string.to_string();
protocol_string.push_str("\r\n");
self.client_session.write_line(&protocol_string).unwrap();
self.client_session.read_line().unwrap()
}
fn algorithm_exchange(&mut self, received_ciphers: Vec<u8>) {
//let _cookie = &received_ciphers[6..22];
let mut server_algorithms: Vec<&str> = Vec::new();
let mut i = 22;
for _ in 0..8 {
let mut size_bytes: [u8; 4] = [0; 4];
size_bytes.copy_from_slice(&received_ciphers[i
After examining the extract:
- Briefly justify your total score, up to 100 words.
- Conclude with the score using the format: "Educational score: <total points>"
| rust | 2 | use std::{sync::mpsc::Receiver, io::Write, io::stdin, io::stdout, net::IpAddr, process::exit, str, sync::Mutex, sync::mpsc, thread};
use core::convert::TryInto;
use rand::Rng;
use ring::digest;
use termion::input::TermRead;
use crate::{constants, algorithms, crypto, session::Session, kex, terminal, ed25519};
pub struct SSH{
host: IpAddr,
username: String,
client_session: Session,
ciphers: Vec<u8>,
received_ciphers: Vec<u8>,
server_host_key: Vec<u8>,
server_signature: Vec<u8>,
kex_keys: Option<kex::Kex>
}
impl SSH {
pub fn new(username: String, host: IpAddr, port: u16) -> SSH {
SSH {
host,
username,
client_session: Session::new(host, port).unwrap(),
ciphers: Vec::new(),
received_ciphers: Vec::new(),
server_host_key: Vec::new(),
server_signature: Vec::new(),
kex_keys: None,
}
}
fn get_password(&self) -> String {
let stdout = stdout();
let mut stdout = stdout.lock();
let stdin = stdin();
let mut stdin = stdin.lock();
stdout.write_all(b"password: ").unwrap();
stdout.flush().unwrap();
let password = stdin.read_passwd(&mut stdout).unwrap().unwrap();
stdout.write_all(b"\n").unwrap();
password
}
fn protocol_string_exchange(&mut self, client_protocol_string: &str) -> String{
let mut protocol_string = client_protocol_string.to_string();
protocol_string.push_str("\r\n");
self.client_session.write_line(&protocol_string).unwrap();
self.client_session.read_line().unwrap()
}
fn algorithm_exchange(&mut self, received_ciphers: Vec<u8>) {
//let _cookie = &received_ciphers[6..22];
let mut server_algorithms: Vec<&str> = Vec::new();
let mut i = 22;
for _ in 0..8 {
let mut size_bytes: [u8; 4] = [0; 4];
size_bytes.copy_from_slice(&received_ciphers[i..i+4]);
let algo_size = u32::from_be_bytes(size_bytes);
server_algorithms.push(str::from_utf8(&received_ciphers[i+4..i+4+algo_size as usize]).unwrap());
i = i + 4 + algo_size as usize;
}
println!("[+] Server offers: {:?}", server_algorithms);
let mut ciphers: Vec<u8> = Vec::new();
let cookie: [u8; 16] = self.client_session.csprng.gen();
ciphers.push(constants::Message::SSH_MSG_KEXINIT);
ciphers.append(&mut cookie.to_vec());
println!("[+] Client offers: {:?}", algorithms::ALGORITHMS.to_vec());
for algorithm in algorithms::ALGORITHMS.to_vec() {
ciphers.append(&mut (algorithm.len() as u32).to_be_bytes().to_vec());
ciphers.append(&mut (algorithm.as_bytes().to_vec()));
}
ciphers.append(&mut vec![0;13]); // Last bytes - 0000 0000 0000 0
self.client_session.pad_data(&mut ciphers);
self.client_session.write_to_server(&ciphers).unwrap();
self.ciphers = ciphers;
self.received_ciphers = received_ciphers;
}
fn send_public_key(&mut self) {
self.kex_keys = Some(kex::Kex::new(&mut self.client_session));
let mut client_public_key = self.kex_keys.as_ref().unwrap().public_key.as_bytes().to_vec();
let mut key_exchange: Vec<u8> = Vec::new();
key_exchange.push(constants::Message::SSH_MSG_KEX_ECDH_INIT);
key_exchange.append(&mut (client_public_key.len() as u32).to_be_bytes().to_vec());
key_exchange.append(&mut client_public_key);
self.client_session.pad_data(&mut key_exchange);
self.client_session.write_to_server(&key_exchange).unwrap();
}
fn key_exchange(&mut self, received_ecdh: Vec<u8>) -> (Vec<u8>, Vec<u8>, Vec<u8>, Vec<u8>) {
let mut e = Vec::new();
let pub_key = self.kex_keys.as_ref().unwrap().public_key.as_bytes();
e.append(&mut (pub_key.len() as u32).to_be_bytes().to_vec());
e.append(&mut pub_key.to_vec());
let (key_size_slice, received_ecdh) = received_ecdh.split_at(4);
let (key_algorithm_size_slice, received_ecdh) = received_ecdh.split_at(4);
let key_algorithm_size = u32::from_be_bytes(key_algorithm_size_slice.try_into().unwrap());
let (key_name, received_ecdh) = received_ecdh.split_at(key_algorithm_size as usize);
//println!("[+] Host Key Algorithm: {}", str::from_utf8(key_name).unwrap());
let (host_key_size_slice, received_ecdh) = received_ecdh.split_at(4);
let host_key_size = u32::from_be_bytes(host_key_size_slice.try_into().unwrap());
let (host_key, received_ecdh) = received_ecdh.split_at(host_key_size as usize);
self.server_host_key = host_key.to_vec();
if ed25519::host_key_fingerprint_check(
self.host,
&[key_algorithm_size_slice, key_name, host_key_size_slice, host_key].concat()
) == false {
exit(1);
}
let k_s = [
key_size_slice,
key_algorithm_size_slice,
key_name,
host_key_size_slice,
host_key]
.concat();
let (f_size_slice, received_ecdh) = received_ecdh.split_at(4);
let f_size = u32::from_be_bytes(f_size_slice.try_into().unwrap());
let (f, received_ecdh) = received_ecdh.split_at(f_size as usize);
let f: [u8;32] = f.try_into().unwrap();
let (signature_length, received_ecdh) = received_ecdh.split_at(4);
let signature_length = u32::from_be_bytes(signature_length.try_into().unwrap());
let (signature_data, _) = received_ecdh.split_at(signature_length as usize);
let (signature_algo_size, signature_data) = signature_data.split_at(4);
let signature_algo_size = u32::from_be_bytes(signature_algo_size.try_into().unwrap());
let (_, signature_data) = signature_data.split_at(signature_algo_size as usize);
//println!("[+] Signature Algorithm: {}", str::from_utf8(signature_algorithm).unwrap());
let (signature_size, signature_data) = signature_data.split_at(4);
let signature_size = u32::from_be_bytes(signature_size.try_into().unwrap());
let (signature, _) = signature_data.split_at(signature_size as usize);
self.server_signature = signature.to_vec();
let secret = self.kex_keys.as_ref().unwrap().generate_shared_secret(f);
let f = [f_size_slice, f.as_ref()].concat();
(k_s, e.to_vec(), f, self.client_session.mpint(secret.as_bytes()))
}
fn new_keys_message(&mut self){
let mut new_keys: Vec<u8> = Vec::new();
new_keys.push(constants::Message::SSH_MSG_NEWKEYS);
self.client_session.pad_data(&mut new_keys);
self.client_session.write_to_server(&new_keys).unwrap();
self.client_session.encrypted = true;
}
fn service_request_message(&mut self){
let mut service_request: Vec<u8> = Vec::new();
service_request.push(constants::Message::SSH_MSG_SERVICE_REQUEST);
service_request.append(&mut (constants::Strings::SSH_USERAUTH.len() as u32).to_be_bytes().to_vec());
service_request.append(&mut constants::Strings::SSH_USERAUTH.as_bytes().to_vec());
self.client_session.pad_data(&mut service_request);
self.client_session.encrypt_packet(&mut service_request);
self.client_session.write_to_server(&mut service_request).unwrap();
}
fn password_authentication(&mut self, username: String, password: String){
let mut password_auth: Vec<u8> = Vec::new();
password_auth.push(constants::Message::SSH_MSG_USERAUTH_REQUEST);
password_auth.append(&mut (username.len() as u32).to_be_bytes().to_vec());
password_auth.append(&mut username.as_bytes().to_vec());
password_auth.append(&mut (constants::Strings::SSH_CONNECTION.len() as u32).to_be_bytes().to_vec());
password_auth.append(&mut constants::Strings::SSH_CONNECTION.as_bytes().to_vec());
password_auth.append(&mut (constants::Strings::PASSWORD.len() as u32).to_be_bytes().to_vec());
password_auth.append(&mut constants::Strings::PASSWORD.as_bytes().to_vec());
password_auth.push(0);
password_auth.append(&mut (password.len() as u32).to_be_bytes().to_vec());
password_auth.append(&mut password.as_bytes().to_vec());
self.client_session.pad_data(&mut password_auth);
self.client_session.encrypt_packet(&mut password_auth);
self.client_session.write_to_server(&mut password_auth).unwrap();
}
fn open_channel(&mut self) {
let mut open_request: Vec<u8> = Vec::new();
open_request.push(constants::Message::SSH_MSG_CHANNEL_OPEN);
open_request.append(&mut (constants::Strings::SESSION.len() as u32).to_be_bytes().to_vec());
open_request.append(&mut constants::Strings::SESSION.as_bytes().to_vec());
open_request.append(&mut (1 as u32).to_be_bytes().to_vec());
open_request.append(&mut (self.client_session.client_window_size as u32).to_be_bytes().to_vec());
open_request.append(&mut constants::Size::MAX_PACKET_SIZE.to_be_bytes().to_vec());
self.client_session.pad_data(&mut open_request);
self.client_session.encrypt_packet(&mut open_request);
self.client_session.write_to_server(&mut open_request).unwrap();
}
fn channel_request_pty(&mut self){
let terminal_size = terminal::get_terminal_size().unwrap();
let mut channel_request: Vec<u8> = Vec::new();
channel_request.push(constants::Message::SSH_MSG_CHANNEL_REQUEST);
channel_request.append(&mut (0 as u32).to_be_bytes().to_vec());
channel_request.append(&mut (constants::Strings::PTY_REQ.len() as u32).to_be_bytes().to_vec());
channel_request.append(&mut constants::Strings::PTY_REQ.as_bytes().to_vec());
channel_request.push(0);
channel_request.append(&mut (constants::Strings::XTERM_VAR.len() as u32).to_be_bytes().to_vec());
channel_request.append(&mut constants::Strings::XTERM_VAR.as_bytes().to_vec());
channel_request.append(&mut (terminal_size.0 as u32).to_be_bytes().to_vec());
channel_request.append(&mut (terminal_size.1 as u32).to_be_bytes().to_vec());
channel_request.append(&mut (0 as u32).to_be_bytes().to_vec());
channel_request.append(&mut (0 as u32).to_be_bytes().to_vec());
channel_request.append(&mut (11 as u32).to_be_bytes().to_vec());
channel_request.push(0x81);
channel_request.append(&mut (38400 as u32).to_be_bytes().to_vec());
channel_request.push(0x80);
channel_request.append(&mut (38400 as u32).to_be_bytes().to_vec());
channel_request.push(0);
self.client_session.pad_data(&mut channel_request);
self.client_session.encrypt_packet(&mut channel_request);
self.client_session.write_to_server(&mut channel_request).unwrap();
}
fn channel_request_shell(&mut self) {
let mut channel_request: Vec<u8> = Vec::new();
channel_request.push(constants::Message::SSH_MSG_CHANNEL_REQUEST);
channel_request.append(&mut (0 as u32).to_be_bytes().to_vec());
channel_request.append(&mut (constants::Strings::SHELL.len() as u32).to_be_bytes().to_vec());
channel_request.append(&mut constants::Strings::SHELL.as_bytes().to_vec());
channel_request.push(1);
self.client_session.pad_data(&mut channel_request);
self.client_session.encrypt_packet(&mut channel_request);
self.client_session.write_to_server(&mut channel_request).unwrap();
}
fn window_adjust(&mut self) {
let mut window_adjust: Vec<u8> = Vec::new();
window_adjust.push(constants::Message::SSH_MSG_CHANNEL_WINDOW_ADJUST);
window_adjust.append(&mut (0 as u32).to_be_bytes().to_vec());
window_adjust.append(&mut self.client_session.client_window_size.to_be_bytes().to_vec());
self.client_session.pad_data(&mut window_adjust);
self.client_session.encrypt_packet(&mut window_adjust);
self.client_session.write_to_server(&mut window_adjust).unwrap();
}
fn handle_key(&mut self, mut key: Vec<u8>) {
let mut command: Vec<u8> = Vec::new();
command.push(constants::Message::SSH_MSG_CHANNEL_DATA);
command.append(&mut (0 as u32).to_be_bytes().to_vec());
command.append(&mut (key.len() as u32).to_be_bytes().to_vec());
command.append(&mut key);
self.client_session.pad_data(&mut command);
self.client_session.encrypt_packet(&mut command);
self.client_session.write_to_server(&mut command).unwrap();
}
fn get_key(&mut self, rx: &Receiver<Vec<u8>>) {
let result = rx.try_recv();
match result {
Ok(vec) => self.handle_key(vec),
Err(_) => (),
}
}
fn close_channel(&mut self) {
let mut close: Vec<u8> = Vec::new();
close.push(constants::Message::SSH_MSG_CHANNEL_CLOSE);
close.append(&mut (0 as u32).to_be_bytes().to_vec());
self.client_session.pad_data(&mut close);
self.client_session.encrypt_packet(&mut close);
self.client_session.write_to_server(&mut close).unwrap();
}
pub fn ssh_protocol(&mut self) -> std::io::Result<()>{
let (tx, rx) = mpsc::channel();
let mut terminal_launched = false;
// Protocol String Exchange
let server_protocol_string = self.protocol_string_exchange(constants::Strings::CLIENT_VERSION);
println!("[+] Server version: {}", server_protocol_string.trim());
// Main loop
loop {
// If no data is read then queue is empty
let queue = self.client_session.read_from_server();
// Adjust window
if self.client_session.data_received >= self.client_session.client_window_size {
self.client_session.data_received = 0;
self.window_adjust();
}
// Process key strokes
self.get_key(&rx);
for packet in queue {
// To give a chance to process special input
// while processing packets
self.get_key(&rx);
let (_, data_no_size) = packet.split_at(4);
let (_padding, data_no_size) = data_no_size.split_at(1);
let (code, data_no_size) = data_no_size.split_at(1);
// Process each packet by matching the message code
match code[0] {
constants::Message::SSH_MSG_KEXINIT => {
//println!("[+] Received Code {}", constants::Message::SSH_MSG_KEXINIT);
// Algorithm exchange
// TODO - Check if client and server algorithms match
self.algorithm_exchange(packet);
self.send_public_key();
}
constants::Message::SSH_MSG_KEX_ECDH_REPLY => {
let (mut k_s, mut e, mut f, mut k) = self.key_exchange(data_no_size.to_vec());
// Make Session ID
// TODO - Change this when implementing rekey
// Note: Rekey should be triggered every 1GB or every hour
self.client_session.make_session_id(
&digest::SHA256,
server_protocol_string.clone(),
&mut self.ciphers,
&mut self.received_ciphers,
&mut k_s,
&mut e,
&mut f,
&mut k.clone());
let verification = ed25519::verify_server_signature(
&self.server_signature,
&self.server_host_key,
&self.client_session.session_id);
if verification == false { println!("Server's signature does not match!"); exit(1); }
let mut session_id = self.client_session.session_id.clone();
let keys = crypto::Keys::new(
&digest::SHA256,
&mut k,
&mut self.client_session.session_id,
&mut session_id);
let session_keys = crypto::SessionKeys::new(keys);
self.client_session.session_keys = Some(session_keys);
self.new_keys_message();
// Request authentication
self.service_request_message();
}
constants::Message::SSH_MSG_SERVICE_ACCEPT => {
//println!("[+] Received Code: {}", constants::Message::SSH_MSG_SERVICE_ACCEPT);
//let (size, data_no_size) = data_no_size.split_at(4);
//let size = u32::from_be_bytes(size.try_into().unwrap());
//println!("{}", str::from_utf8(&data_no_size[..size as usize]).unwrap());
// Password authentication
// TODO - Implement other types of authentication (keys)
let password = <PASSWORD>();
self.password_authentication(self.username.clone(), password);
}
constants::Message::SSH_MSG_USERAUTH_FAILURE => {
println!("[+] Authentication failed!");
println!("Try again.");
let password = <PASSWORD>();
self.password_authentication(self.username.clone(), password);
}
constants::Message::SSH_MSG_USERAUTH_SUCCESS => {
//println!("[+] Received Code: {}", constants::Message::SSH_MSG_USERAUTH_SUCCESS);
println!("[+] Authentication succeeded.");
self.open_channel();
}
constants::Message::SSH_MSG_GLOBAL_REQUEST => {
// TODO - Handle host key check upon receiving -> <EMAIL>
// Ignore for now
//println!("[+] Received Code: {}", constants::Message::SSH_MSG_GLOBAL_REQUEST);
}
constants::Message::SSH_MSG_CHANNEL_OPEN_CONFIRMATION => {
//println!("[+] Received Code: {}", constants::Message::SSH_MSG_CHANNEL_OPEN_CONFIRMATION);
//let (size, data_no_size) = data_no_size.split_at(4);
//let size = u32::from_be_bytes(size.try_into().unwrap());
//let (recipient_channel, data_no_size) = data_no_size.split_at(4);
//let (sender_channel, data_no_size) = data_no_size.split_at(4);
//let (initial_window_size, data_no_size) = data_no_size.split_at(4);
//let (maximum_window_size, data_no_size) = data_no_size.split_at(4);
// Request pseudo terminal / shell
self.channel_request_pty();
self.channel_request_shell();
terminal_launched = true;
}
constants::Message::SSH_MSG_CHANNEL_OPEN_FAILURE => {
//println!("[+] Received Code: {}", constants::Message::SSH_MSG_CHANNEL_OPEN_FAILURE);
println!("[+] Channel open failed, exiting.");
exit(1);
}
constants::Message::SSH_MSG_CHANNEL_SUCCESS => {
//println!("[+] Received Code: {}", constants::Message::SSH_MSG_CHANNEL_SUCCESS);
println!("[+] Channel open succeeded.");
//let (size, data_no_size) = data_no_size.split_at(4);
//let size = u32::from_be_bytes(size.try_into().unwrap());
//let (recipient_channel, data_no_size) = data_no_size.split_at(4);
}
constants::Message::SSH_MSG_CHANNEL_WINDOW_ADJUST => {
//println!("[+] Received Code: {}", constants::Message::SSH_MSG_CHANNEL_WINDOW_ADJUST);
let (_recipient_channel, data_no_size) = data_no_size.split_at(4);
let (window_bytes, _) = data_no_size.split_at(4);
let mut window_slice = [0u8;4];
window_slice.copy_from_slice(window_bytes);
self.client_session.server_window_size = u32::from_be_bytes(window_slice);
}
constants::Message::SSH_MSG_CHANNEL_DATA => {
//println!("[+] Received Code: {}", constants::Message::SSH_MSG_CHANNEL_DATA);
let (_recipient_channel, data_no_size) = data_no_size.split_at(4);
let (data_size, data_no_size) = data_no_size.split_at(4);
let data_size = u32::from_be_bytes(data_size.try_into().unwrap());
// Launch thread that processes key strokes
if terminal_launched == true {
let clone = tx.clone();
thread::spawn(move ||{
let mut terminal = terminal::Terminal::new(Mutex::new(clone));
terminal.handle_command();
});
terminal_launched = false;
}
// Print data received to screen
stdout().write_all(&data_no_size[..data_size as usize]).unwrap();
stdout().flush().unwrap();
}
constants::Message::SSH_MSG_CHANNEL_EOF => {
//println!("[+] Received Code: {}", constants::Message::SSH_MSG_CHANNEL_EOF);
println!("Server will not send more data!");
}
constants::Message::SSH_MSG_CHANNEL_REQUEST => {
//println!("[+] Received Code: {}", constants::Message::SSH_MSG_CHANNEL_REQUEST);
}
constants::Message::SSH_MSG_IGNORE => {
//println!("[+] Received Code: {}", constants::Message::SSH_MSG_IGNORE);
}
constants::Message::SSH_MSG_CHANNEL_CLOSE => {
// Issue close channel packet
self.close_channel();
println!("Connection closed.");
exit(0);
}
constants::Message::SSH_MSG_DISCONNECT => {
//println!("[+] Received Code: {}", constants::Message::SSH_MSG_DISCONNECT);
println!("Server disconnected...");
exit(1);
}
_ => {
println!("Could not recognize this message -> {}", code[0]);
exit(1);
}
}
}
}
}
} |
Below is an extract from a Markdown document. Evaluate its educational value, considering both Markdown usage and the content itself. Use the additive 5-point scoring system described below. Points are accumulated based on the satisfaction of each criterion:
- Add 1 point if the document uses basic Markdown syntax correctly (e.g., headers, lists, or emphasis), regardless of content.
- Add another point if the document's content has some educational value, even if it's basic or limited in scope. The Markdown usage should be correct but might not be diverse.
- Award a third point if the document demonstrates a good range of Markdown features (e.g., links, images, code blocks) AND the content provides clear, accurate information on a topic. The structure should be logical and easy to follow.
- Give a fourth point if the document is well-suited for teaching both its subject matter and effective Markdown usage. It should use varied Markdown elements to enhance the presentation of educational content, similar to a well-crafted tutorial or lesson.
- Grant a fifth point if the document is exceptional both in its use of Markdown and the educational value of its content. It should demonstrate advanced Markdown features (e.g., tables, task lists, footnotes), have an engaging structure, and provide comprehensive, high-quality educational content on its topic. The document should serve as an excellent example of using Markdown for educational purposes.
The extract:
# T312_Sarangga
Second repository
After examining the extract:
- Briefly justify your total score, up to 100 words.
- Conclude with the score using the format: "Educational score: <total points>"
| markdown | 1 | # T312_Sarangga
Second repository
|
Below is an extract from a PHP program. Evaluate whether it has a high educational value and could help teach coding. Use the additive 5-point scoring system described below. Points are accumulated based on the satisfaction of each criterion:
- Add 1 point if the program contains valid PHP code, even if it's not educational, like boilerplate code, configurations, or niche concepts.
- Add another point if the program addresses practical PHP concepts, even if it lacks comments.
- Award a third point if the program is suitable for educational use and introduces key concepts in programming, even if the topic is advanced (e.g., object-oriented programming, namespaces). The code should be well-structured and contain some comments.
- Give a fourth point if the program is self-contained and highly relevant to teaching PHP. It should be similar to a school exercise, a tutorial, or a PHP course section.
- Grant a fifth point if the program is outstanding in its educational value and is perfectly suited for teaching PHP. It should be well-written, easy to understand, and contain step-by-step explanations and comments.
The extract:
<section class="pcoded-main-container">
<div class="pcoded-wrapper">
<div class="pcoded-content">
<div class="pcoded-inner-content">
<div class="page-header">
<div class="page-block">
<div class="row align-items-center">
<div class="col-md-12">
<div class="page-header-title">
<h5 class="m-b-10">Bank Soal</h5>
</div>
<ul class="breadcrumb">
<li class="breadcrumb-item"><a href="#">
<i class="feather icon-user"></i></a></li>
<li class="breadcrumb-item"><a href="javascript:">Bank Soal</a></li>
<li class="breadcrumb-item"><a href="javascript:">Data</a></li>
</ul>
</div>
</div>
</div>
</div>
<div class="main-body">
<div class="page-wrapper">
<div class="row">
<div class="col-sm-12">
<div class="card">
<div class="card-header">
<h5>Data Bank Soal IPS</h5>
</div>
<div class="card-block">
<div class="col-md-12">
<div class="row mx-auto">
<div class="col-md-3">
<a href="<?php echo base_url('admin/bank_soal/ips_sejarah') ?>" class="btn shadow-2 btn-success btn-block">
<h4 class
After examining the extract:
- Briefly justify your total score, up to 100 words.
- Conclude with the score using the format: "Educational score: <total points>"
| php | 1 | <section class="pcoded-main-container">
<div class="pcoded-wrapper">
<div class="pcoded-content">
<div class="pcoded-inner-content">
<div class="page-header">
<div class="page-block">
<div class="row align-items-center">
<div class="col-md-12">
<div class="page-header-title">
<h5 class="m-b-10">Bank Soal</h5>
</div>
<ul class="breadcrumb">
<li class="breadcrumb-item"><a href="#">
<i class="feather icon-user"></i></a></li>
<li class="breadcrumb-item"><a href="javascript:">Bank Soal</a></li>
<li class="breadcrumb-item"><a href="javascript:">Data</a></li>
</ul>
</div>
</div>
</div>
</div>
<div class="main-body">
<div class="page-wrapper">
<div class="row">
<div class="col-sm-12">
<div class="card">
<div class="card-header">
<h5>Data Bank Soal IPS</h5>
</div>
<div class="card-block">
<div class="col-md-12">
<div class="row mx-auto">
<div class="col-md-3">
<a href="<?php echo base_url('admin/bank_soal/ips_sejarah') ?>" class="btn shadow-2 btn-success btn-block">
<h4 class="text-white my-auto">Sejarah</h4>
</a>
</div>
<div class="col-md-3">
<a href="<?php echo base_url('admin/bank_soal/ips_sosiologi') ?>" class="btn shadow-2 btn-success btn-block">
<h4 class="text-white my-auto">Sosiologi</h4>
</a>
</div>
<div class="col-md-3">
<a href="<?php echo base_url('admin/bank_soal/ips_geografi') ?>" class="btn shadow-2 btn-success btn-block">
<h4 class="text-white my-auto">Geografi</h4>
</a>
</div>
<div class="col-md-3">
<a href="<?php echo base_url('admin/bank_soal/ips_ekonomi') ?>" class="btn shadow-2 btn-success btn-block">
<h4 class="text-white my-auto">Ekonomi</h4>
</a>
</div>
</div>
</div>
</div>
</div>
</div>
</div>
</div>
</div>
</div>
</div>
</div>
</section> |
Below is an extract from a TypeScript program. Evaluate whether it has a high educational value and could help teach coding. Use the additive 5-point scoring system described below. Points are accumulated based on the satisfaction of each criterion:
- Add 1 point if the program contains valid TypeScript code, even if it's not educational, like boilerplate code, configurations, or niche concepts.
- Add another point if the program addresses practical TypeScript concepts, even if it lacks comments.
- Award a third point if the program is suitable for educational use and introduces key concepts in programming, even if the topic is advanced (e.g., generics, decorators). The code should be well-structured and contain some comments.
- Give a fourth point if the program is self-contained and highly relevant to teaching TypeScript. It should be similar to a school exercise, a tutorial, or a TypeScript course section.
- Grant a fifth point if the program is outstanding in its educational value and is perfectly suited for teaching TypeScript. It should be well-written, easy to understand, and contain step-by-step explanations and comments.
The extract:
import { SectionTableRow, CoursePageData } from "src/models/pages";
import { CoursePageScraper } from "src/util/scraper";
import { search } from "../../../src/util/helpers";
describe("CoursePageScraper.ts", () => {
const coursePageScraper = new CoursePageScraper();
beforeAll(() => {
})
it("getData should return data for CPSC 221 and contain section 101 and L1A", async () => {
const cpscSection: SectionTableRow = {
status: expect.any(String),
name: "CPSC 221 101",
subject: "CPSC",
course: "221",
section: "101",
activity: "Web-Oriented Course",
term: "1",
interval: "",
schedule: [
{
day: "Mon",
term: "1",
start_time: "14:00",
end_time: "15:00",
},
{
day: "Wed",
term: "1",
start_time: "14:00",
end_time: "15:00",
},
{
day: "Fri",
term: "1",
start_time: "14:00",
end_time: "15:00",
}
],
comments: "If all the lab and/or tutorial seats are full the department will ensure that there are enough lab/tutorial seats available for the number of students registered in the course by either adding additional lab/tutorial sections or expenadind the number of seats in the activity once we know how many extra students we will need to accommodate. However, there is no guarantee that these seats will fit your preferred time. You may need to change your registration in other courses to get access to a lab/tutorial where there are available seats.",
link: "https://courses.students.ubc.ca/cs/courseschedule?pname=subjarea&tname=subj-section&dept=CPSC&course=221§ion=101&campuscd=UBC"
}
const cpscLab: SectionTableRow = {
status: expect.any(String),
name: "CPSC 221 L1A",
subject: "CPSC",
course: "221",
section: "L1A",
activity: "Laboratory",
term: "1",
interval: "",
schedu
After examining the extract:
- Briefly justify your total score, up to 100 words.
- Conclude with the score using the format: "Educational score: <total points>"
| typescript | 3 | import { SectionTableRow, CoursePageData } from "src/models/pages";
import { CoursePageScraper } from "src/util/scraper";
import { search } from "../../../src/util/helpers";
describe("CoursePageScraper.ts", () => {
const coursePageScraper = new CoursePageScraper();
beforeAll(() => {
})
it("getData should return data for CPSC 221 and contain section 101 and L1A", async () => {
const cpscSection: SectionTableRow = {
status: expect.any(String),
name: "CPSC 221 101",
subject: "CPSC",
course: "221",
section: "101",
activity: "Web-Oriented Course",
term: "1",
interval: "",
schedule: [
{
day: "Mon",
term: "1",
start_time: "14:00",
end_time: "15:00",
},
{
day: "Wed",
term: "1",
start_time: "14:00",
end_time: "15:00",
},
{
day: "Fri",
term: "1",
start_time: "14:00",
end_time: "15:00",
}
],
comments: "If all the lab and/or tutorial seats are full the department will ensure that there are enough lab/tutorial seats available for the number of students registered in the course by either adding additional lab/tutorial sections or expenadind the number of seats in the activity once we know how many extra students we will need to accommodate. However, there is no guarantee that these seats will fit your preferred time. You may need to change your registration in other courses to get access to a lab/tutorial where there are available seats.",
link: "https://courses.students.ubc.ca/cs/courseschedule?pname=subjarea&tname=subj-section&dept=CPSC&course=221§ion=101&campuscd=UBC"
}
const cpscLab: SectionTableRow = {
status: expect.any(String),
name: "CPSC 221 L1A",
subject: "CPSC",
course: "221",
section: "L1A",
activity: "Laboratory",
term: "1",
interval: "",
schedule: [
{
day: "Tue",
term: "1",
start_time: "11:00",
end_time: "13:00",
}
],
comments: "",
link: "https://courses.students.ubc.ca/cs/courseschedule?pname=subjarea&tname=subj-section&dept=CPSC&course=221§ion=L1A&campuscd=UBC"
}
const expected: CoursePageData = {
name: "CPSC 221",
subject: "CPSC",
course: "221",
title: "Basic Algorithms and Data Structures",
description: "Design and analysis of basic algorithms and data structures; algorithm analysis methods, searching and sorting algorithms, basic data structures, graphs and concurrency.",
credits: "4",
comments: ["Choose one section from all 2 activity types. (e.g. Lecture and Laboratory)"],
sections: expect.any(Array),
link: "https://courses.students.ubc.ca/cs/courseschedule?pname=subjarea&tname=subj-course&dept=CPSC&course=221&campuscd=UBC"
}
let result = await coursePageScraper.getData("CPSC", "221");
let lab = search("name", "CPSC 221 L1A", result.sections);
let section = search("name", "CPSC 221 101", result.sections);
expect(result).toMatchObject(expected);
expect(lab).toMatchObject(cpscLab);
expect(section).toMatchObject(cpscSection);
expect(result.sections.length).toBeGreaterThan(20); // definately more than 20 sections... dont know the exact number
})
}) |
Below is an extract of SQL code. Evaluate whether it has a high educational value and could help teach SQL and database concepts. Use the additive 5-point scoring system described below. Points are accumulated based on the satisfaction of each criterion:
- Add 1 point if the code contains valid SQL syntax, even if it's just basic queries or simple table operations.
- Add another point if the code addresses practical SQL concepts (e.g., JOINs, subqueries), even if it lacks comments.
- Award a third point if the code is suitable for educational use and introduces key concepts in SQL and database management, even if the topic is somewhat advanced (e.g., indexes, transactions). The code should be well-structured and contain some comments.
- Give a fourth point if the code is self-contained and highly relevant to teaching SQL. It should be similar to a database course exercise, demonstrating good practices in query writing and database design.
- Grant a fifth point if the code is outstanding in its educational value and is perfectly suited for teaching SQL and database concepts. It should be well-written, easy to understand, and contain explanatory comments that clarify the purpose and impact of each part of the code.
The extract:
Create tables:
1) Create a table with Personentity under Test Schema.
a. PersonentityID auto increment ID,PK
b. PersonFName
c. PersonLName
d. PersonDOB
e. PersonAddress
f. InsertedDate Auto value
2) Create a table with Costumer under Test Schema.
a. CostumerID auto increment ID,PK
b. CostumerFName
c. CostumerLName
d. CostumerAccountNumber
e. InsertedDate Auto Value
3) Create a table with Player under Test Schema.
a. PlayerID
b. PlayerName
c. ManagerName
d. TeamName
e. InsertedDate Auto value
Insertion:
Build some Query from three databases and pick 100 ,200, 300 records and load them into tables.
Personentity Source from Adventureworks2017 DB
Costumer Source from AdventureworksDW2017 DB
Player BaseBall DB
Extract :
join on three table ID and get me some good information from three tables.
After examining the extract:
- Briefly justify your total score, up to 100 words.
- Conclude with the score using the format: "Educational score: <total points>"
| sql | 1 | Create tables:
1) Create a table with Personentity under Test Schema.
a. PersonentityID auto increment ID,PK
b. PersonFName
c. PersonLName
d. PersonDOB
e. PersonAddress
f. InsertedDate Auto value
2) Create a table with Costumer under Test Schema.
a. CostumerID auto increment ID,PK
b. CostumerFName
c. CostumerLName
d. CostumerAccountNumber
e. InsertedDate Auto Value
3) Create a table with Player under Test Schema.
a. PlayerID
b. PlayerName
c. ManagerName
d. TeamName
e. InsertedDate Auto value
Insertion:
Build some Query from three databases and pick 100 ,200, 300 records and load them into tables.
Personentity Source from Adventureworks2017 DB
Costumer Source from AdventureworksDW2017 DB
Player BaseBall DB
Extract :
join on three table ID and get me some good information from three tables.
|
Below is an extract from a TypeScript program. Evaluate whether it has a high educational value and could help teach coding. Use the additive 5-point scoring system described below. Points are accumulated based on the satisfaction of each criterion:
- Add 1 point if the program contains valid TypeScript code, even if it's not educational, like boilerplate code, configurations, or niche concepts.
- Add another point if the program addresses practical TypeScript concepts, even if it lacks comments.
- Award a third point if the program is suitable for educational use and introduces key concepts in programming, even if the topic is advanced (e.g., generics, decorators). The code should be well-structured and contain some comments.
- Give a fourth point if the program is self-contained and highly relevant to teaching TypeScript. It should be similar to a school exercise, a tutorial, or a TypeScript course section.
- Grant a fifth point if the program is outstanding in its educational value and is perfectly suited for teaching TypeScript. It should be well-written, easy to understand, and contain step-by-step explanations and comments.
The extract:
import { Component, OnInit } from '@angular/core';
@Component({
selector: 'app-portfolio-skills',
templateUrl: './portfolio-skills.component.html',
styleUrls: ['./portfolio-skills.component.scss']
})
export class PortfolioSkillsComponent implements OnInit {
static readonly skills = [
'HTML5',
'CSS',
'JavaScript',
'Java',
'Angular',
'TypeScript',
'MySQL',
'Sass',
'Spring',
'REST'
];
constructor() { }
cards: any[] = [];
ngOnInit() {
PortfolioSkillsComponent.skills.forEach(skill => {
this.cards.push( {'image': skill.toLowerCase(), 'name': skill} );
});
}
}
After examining the extract:
- Briefly justify your total score, up to 100 words.
- Conclude with the score using the format: "Educational score: <total points>"
| typescript | 3 | import { Component, OnInit } from '@angular/core';
@Component({
selector: 'app-portfolio-skills',
templateUrl: './portfolio-skills.component.html',
styleUrls: ['./portfolio-skills.component.scss']
})
export class PortfolioSkillsComponent implements OnInit {
static readonly skills = [
'HTML5',
'CSS',
'JavaScript',
'Java',
'Angular',
'TypeScript',
'MySQL',
'Sass',
'Spring',
'REST'
];
constructor() { }
cards: any[] = [];
ngOnInit() {
PortfolioSkillsComponent.skills.forEach(skill => {
this.cards.push( {'image': skill.toLowerCase(), 'name': skill} );
});
}
}
|
Below is an extract from a Markdown document. Evaluate its educational value, considering both Markdown usage and the content itself. Use the additive 5-point scoring system described below. Points are accumulated based on the satisfaction of each criterion:
- Add 1 point if the document uses basic Markdown syntax correctly (e.g., headers, lists, or emphasis), regardless of content.
- Add another point if the document's content has some educational value, even if it's basic or limited in scope. The Markdown usage should be correct but might not be diverse.
- Award a third point if the document demonstrates a good range of Markdown features (e.g., links, images, code blocks) AND the content provides clear, accurate information on a topic. The structure should be logical and easy to follow.
- Give a fourth point if the document is well-suited for teaching both its subject matter and effective Markdown usage. It should use varied Markdown elements to enhance the presentation of educational content, similar to a well-crafted tutorial or lesson.
- Grant a fifth point if the document is exceptional both in its use of Markdown and the educational value of its content. It should demonstrate advanced Markdown features (e.g., tables, task lists, footnotes), have an engaging structure, and provide comprehensive, high-quality educational content on its topic. The document should serve as an excellent example of using Markdown for educational purposes.
The extract:
# Quiz
first android project
After examining the extract:
- Briefly justify your total score, up to 100 words.
- Conclude with the score using the format: "Educational score: <total points>"
| markdown | 1 | # Quiz
first android project
|
Below is an extract from a C++ program. Evaluate whether it has a high educational value and could help teach coding. Use the additive 5-point scoring system described below. Points are accumulated based on the satisfaction of each criterion:
- Add 1 point if the program contains valid C++ code, even if it's not educational, like boilerplate code, configurations, or niche concepts.
- Add another point if the program addresses practical C++ concepts, even if it lacks comments.
- Award a third point if the program is suitable for educational use and introduces key concepts in programming, even if the topic is advanced (e.g., memory management). The code should be well-structured and contain some comments.
- Give a fourth point if the program is self-contained and highly relevant to teaching C++. It should be similar to a school exercise, a tutorial, or a C++ course section.
- Grant a fifth point if the program is outstanding in its educational value and is perfectly suited for teaching C++. It should be well-written, easy to understand, and contain step-by-step explanations and comments.
The extract:
/*
* Copyright 2017 Google Inc.
*
* Use of this source code is governed by a BSD-style license that can be
* found in the LICENSE file.
*/
#include "gm/gm.h"
#include "include/core/SkFont.h"
#include "include/core/SkPaint.h"
#include "include/utils/SkTextUtils.h"
#include <initializer_list>
class SkCanvas;
// http://bug.skia.org/7315
DEF_SIMPLE_GM(text_scale_skew, canvas, 256, 128) {
SkPaint p;
p.setAntiAlias(true);
SkFont font;
font.setSize(18.0f);
float y = 10.0f;
for (float scale : { 0.5f, 0.71f, 1.0f, 1.41f, 2.0f }) {
font.setScaleX(scale);
y += font.getSpacing();
float x = 50.0f;
for (float skew : { -0.5f, 0.0f, 0.5f }) {
font.setSkewX(skew);
SkTextUtils::DrawString(canvas, "Skia", x, y, font, p, SkTextUtils::kCenter_Align);
x += 78.0f;
}
}
}
After examining the extract:
- Briefly justify your total score, up to 100 words.
- Conclude with the score using the format: "Educational score: <total points>"
| cpp | 3 | /*
* Copyright 2017 Google Inc.
*
* Use of this source code is governed by a BSD-style license that can be
* found in the LICENSE file.
*/
#include "gm/gm.h"
#include "include/core/SkFont.h"
#include "include/core/SkPaint.h"
#include "include/utils/SkTextUtils.h"
#include <initializer_list>
class SkCanvas;
// http://bug.skia.org/7315
DEF_SIMPLE_GM(text_scale_skew, canvas, 256, 128) {
SkPaint p;
p.setAntiAlias(true);
SkFont font;
font.setSize(18.0f);
float y = 10.0f;
for (float scale : { 0.5f, 0.71f, 1.0f, 1.41f, 2.0f }) {
font.setScaleX(scale);
y += font.getSpacing();
float x = 50.0f;
for (float skew : { -0.5f, 0.0f, 0.5f }) {
font.setSkewX(skew);
SkTextUtils::DrawString(canvas, "Skia", x, y, font, p, SkTextUtils::kCenter_Align);
x += 78.0f;
}
}
}
|
Below is an extract of SQL code. Evaluate whether it has a high educational value and could help teach SQL and database concepts. Use the additive 5-point scoring system described below. Points are accumulated based on the satisfaction of each criterion:
- Add 1 point if the code contains valid SQL syntax, even if it's just basic queries or simple table operations.
- Add another point if the code addresses practical SQL concepts (e.g., JOINs, subqueries), even if it lacks comments.
- Award a third point if the code is suitable for educational use and introduces key concepts in SQL and database management, even if the topic is somewhat advanced (e.g., indexes, transactions). The code should be well-structured and contain some comments.
- Give a fourth point if the code is self-contained and highly relevant to teaching SQL. It should be similar to a database course exercise, demonstrating good practices in query writing and database design.
- Grant a fifth point if the code is outstanding in its educational value and is perfectly suited for teaching SQL and database concepts. It should be well-written, easy to understand, and contain explanatory comments that clarify the purpose and impact of each part of the code.
The extract:
ALTER TABLE {$NAMESPACE}_metamta.metamta_mail
ADD KEY (status, nextRetry);
ALTER TABLE {$NAMESPACE}_metamta.metamta_mail
ADD KEY (relatedPHID);
After examining the extract:
- Briefly justify your total score, up to 100 words.
- Conclude with the score using the format: "Educational score: <total points>"
| sql | 1 | ALTER TABLE {$NAMESPACE}_metamta.metamta_mail
ADD KEY (status, nextRetry);
ALTER TABLE {$NAMESPACE}_metamta.metamta_mail
ADD KEY (relatedPHID);
|
Below is an extract from a JavaScript program. Evaluate whether it has a high educational value and could help teach coding. Use the additive 5-point scoring system described below. Points are accumulated based on the satisfaction of each criterion:
- Add 1 point if the program contains valid JavaScript code, even if it's not educational, like boilerplate code, configurations, or niche concepts.
- Add another point if the program addresses practical JavaScript concepts, even if it lacks comments.
- Award a third point if the program is suitable for educational use and introduces key concepts in programming, even if the topic is advanced (e.g., asynchronous programming). The code should be well-structured and contain some comments.
- Give a fourth point if the program is self-contained and highly relevant to teaching JavaScript. It should be similar to a school exercise, a tutorial, or a JavaScript course section.
- Grant a fifth point if the program is outstanding in its educational value and is perfectly suited for teaching JavaScript. It should be well-written, easy to understand, and contain step-by-step explanations and comments.
The extract:
/**
* Created by china on 2018/3/16.
*/
/*
当前项目接口ajax请求模块
*/
import ajax from './ajax'
export const reqhome = () => ajax('/home')
export const reqleft = () => ajax('/type/left')
export const reqright = () => ajax('/type/right')
export const reqbrand = () => ajax('/brand')
After examining the extract:
- Briefly justify your total score, up to 100 words.
- Conclude with the score using the format: "Educational score: <total points>"
| javascript | 2 | /**
* Created by china on 2018/3/16.
*/
/*
当前项目接口ajax请求模块
*/
import ajax from './ajax'
export const reqhome = () => ajax('/home')
export const reqleft = () => ajax('/type/left')
export const reqright = () => ajax('/type/right')
export const reqbrand = () => ajax('/brand')
|
Below is an extract from a Go program. Evaluate whether it has a high educational value and could help teach coding. Use the additive 5-point scoring system described below. Points are accumulated based on the satisfaction of each criterion:
- Add 1 point if the program contains valid Go code, even if it's not educational, like boilerplate code, configurations, or niche concepts.
- Add another point if the program addresses practical Go concepts, even if it lacks comments.
- Award a third point if the program is suitable for educational use and introduces key concepts in programming, even if the topic is advanced (e.g., goroutines, interfaces). The code should be well-structured and contain some comments.
- Give a fourth point if the program is self-contained and highly relevant to teaching Go. It should be similar to a school exercise, a tutorial, or a Go course section.
- Grant a fifth point if the program is outstanding in its educational value and is perfectly suited for teaching Go. It should be well-written, easy to understand, and contain step-by-step explanations and comments.
The extract:
//Copyright 2017 Huawei Technologies Co., Ltd
//
//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.
package lagertest
import (
"bytes"
"encoding/json"
"io"
"github.com/onsi/ginkgo"
"github.com/onsi/gomega/gbytes"
"github.com/ServiceComb/service-center/pkg/lager"
)
type TestLogger struct {
lager.Logger
*TestSink
}
type TestSink struct {
lager.Sink
buffer *gbytes.Buffer
}
func NewTestLogger(component string) *TestLogger {
logger := lager.NewLogger(component)
testSink := NewTestSink()
logger.RegisterSink(testSink)
logger.RegisterSink(lager.NewWriterSink(ginkgo.GinkgoWriter, lager.DEBUG))
return &TestLogger{logger, testSink}
}
func NewTestSink() *TestSink {
buffer := gbytes.NewBuffer()
return &TestSink{
Sink: lager.NewWriterSink(buffer, lager.DEBUG),
buffer: buffer,
}
}
func (s *TestSink) Buffer() *gbytes.Buffer {
return s.buffer
}
func (s *TestSink) Logs() []lager.LogFormat {
logs := []lager.LogFormat{}
decoder := json.NewDecoder(bytes.NewBuffer(s.buffer.Contents()))
for {
var log lager.LogFormat
if err := decoder.Decode(&log); err == io.EOF {
return logs
} else if err != nil {
panic(err)
}
logs = append(logs, log)
}
return logs
}
func (s *TestSink) LogMessages() []string {
logs := s.Logs()
messages := make([]string, 0, len(logs))
for _, log := range logs {
messages = append(messages, log.Message)
}
return messages
}
After examining the extract:
- Briefly justify your total score, up to 100 words.
- Conclude with the score using the format: "Educational score: <total points>"
| go | 1 | //Copyright 2017 Huawei Technologies Co., Ltd
//
//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.
package lagertest
import (
"bytes"
"encoding/json"
"io"
"github.com/onsi/ginkgo"
"github.com/onsi/gomega/gbytes"
"github.com/ServiceComb/service-center/pkg/lager"
)
type TestLogger struct {
lager.Logger
*TestSink
}
type TestSink struct {
lager.Sink
buffer *gbytes.Buffer
}
func NewTestLogger(component string) *TestLogger {
logger := lager.NewLogger(component)
testSink := NewTestSink()
logger.RegisterSink(testSink)
logger.RegisterSink(lager.NewWriterSink(ginkgo.GinkgoWriter, lager.DEBUG))
return &TestLogger{logger, testSink}
}
func NewTestSink() *TestSink {
buffer := gbytes.NewBuffer()
return &TestSink{
Sink: lager.NewWriterSink(buffer, lager.DEBUG),
buffer: buffer,
}
}
func (s *TestSink) Buffer() *gbytes.Buffer {
return s.buffer
}
func (s *TestSink) Logs() []lager.LogFormat {
logs := []lager.LogFormat{}
decoder := json.NewDecoder(bytes.NewBuffer(s.buffer.Contents()))
for {
var log lager.LogFormat
if err := decoder.Decode(&log); err == io.EOF {
return logs
} else if err != nil {
panic(err)
}
logs = append(logs, log)
}
return logs
}
func (s *TestSink) LogMessages() []string {
logs := s.Logs()
messages := make([]string, 0, len(logs))
for _, log := range logs {
messages = append(messages, log.Message)
}
return messages
}
|
Below is an extract from a Go program. Evaluate whether it has a high educational value and could help teach coding. Use the additive 5-point scoring system described below. Points are accumulated based on the satisfaction of each criterion:
- Add 1 point if the program contains valid Go code, even if it's not educational, like boilerplate code, configurations, or niche concepts.
- Add another point if the program addresses practical Go concepts, even if it lacks comments.
- Award a third point if the program is suitable for educational use and introduces key concepts in programming, even if the topic is advanced (e.g., goroutines, interfaces). The code should be well-structured and contain some comments.
- Give a fourth point if the program is self-contained and highly relevant to teaching Go. It should be similar to a school exercise, a tutorial, or a Go course section.
- Grant a fifth point if the program is outstanding in its educational value and is perfectly suited for teaching Go. It should be well-written, easy to understand, and contain step-by-step explanations and comments.
The extract:
package datatype_test
import (
"testing"
"github.com/stretchr/testify/assert"
"github.com/stretchr/testify/require"
"github.com/i-sevostyanov/NanoDB/internal/sql"
"github.com/i-sevostyanov/NanoDB/internal/sql/datatype"
)
func TestNull_Raw(t *testing.T) {
t.Parallel()
null := datatype.NewNull()
switch value := null.Raw().(type) {
case nil:
default:
assert.Failf(t, "fail", "unexpected type %T", value)
}
}
func TestNull_DataType(t *testing.T) {
t.Parallel()
n := datatype.NewNull()
assert.Equal(t, sql.Null, n.DataType())
}
func TestNull_Compare(t *testing.T) {
t.Parallel()
tests := []struct {
name string
a sql.Value
b sql.Value
cmp sql.CompareType
}{
{
name: "null vs null",
a: datatype.NewNull(),
b: datatype.NewNull(),
cmp: sql.Equal,
},
{
name: "null vs integer",
a: datatype.NewNull(),
b: datatype.NewInteger(10),
cmp: sql.Less,
},
{
name: "null vs float",
a: datatype.NewNull(),
b: datatype.NewFloat(10),
cmp: sql.Less,
},
{
name: "null vs text",
a: datatype.NewNull(),
b: datatype.NewText("xyz"),
cmp: sql.Less,
},
{
name: "null vs boolean",
a: datatype.NewNull(),
b: datatype.NewBoolean(true),
cmp: sql.Less,
},
}
for _, test := range tests {
test := test
t.Run(test.name, func(t *testing.T) {
t.Parallel()
cmp, err := test.a.Compare(test.b)
require.NoError(t, err)
assert.Equal(t, test.cmp, cmp)
})
}
}
func TestNull_UnaryPlus(t *testing.T) {
t.Parallel()
a := datatype.NewNull()
v, err := a.UnaryPlus()
require.NotNil(t, err)
require.Nil(t, v)
}
func TestNull_UnaryMinus(t *testing.T) {
t.Parallel()
a := datatype.NewNull()
v, err := a.UnaryMinus()
require.NotNil(t, err)
require.Nil(t, v)
}
func TestNull_Add(t *testing.T) {
t.Parallel()
t.Run("null + null", func(t *testing.T) {
t.Parallel()
a := datatype.NewNull()
b := datatype.NewNull()
value, err := a.Add(b)
require
After examining the extract:
- Briefly justify your total score, up to 100 words.
- Conclude with the score using the format: "Educational score: <total points>"
| go | 3 | package datatype_test
import (
"testing"
"github.com/stretchr/testify/assert"
"github.com/stretchr/testify/require"
"github.com/i-sevostyanov/NanoDB/internal/sql"
"github.com/i-sevostyanov/NanoDB/internal/sql/datatype"
)
func TestNull_Raw(t *testing.T) {
t.Parallel()
null := datatype.NewNull()
switch value := null.Raw().(type) {
case nil:
default:
assert.Failf(t, "fail", "unexpected type %T", value)
}
}
func TestNull_DataType(t *testing.T) {
t.Parallel()
n := datatype.NewNull()
assert.Equal(t, sql.Null, n.DataType())
}
func TestNull_Compare(t *testing.T) {
t.Parallel()
tests := []struct {
name string
a sql.Value
b sql.Value
cmp sql.CompareType
}{
{
name: "null vs null",
a: datatype.NewNull(),
b: datatype.NewNull(),
cmp: sql.Equal,
},
{
name: "null vs integer",
a: datatype.NewNull(),
b: datatype.NewInteger(10),
cmp: sql.Less,
},
{
name: "null vs float",
a: datatype.NewNull(),
b: datatype.NewFloat(10),
cmp: sql.Less,
},
{
name: "null vs text",
a: datatype.NewNull(),
b: datatype.NewText("xyz"),
cmp: sql.Less,
},
{
name: "null vs boolean",
a: datatype.NewNull(),
b: datatype.NewBoolean(true),
cmp: sql.Less,
},
}
for _, test := range tests {
test := test
t.Run(test.name, func(t *testing.T) {
t.Parallel()
cmp, err := test.a.Compare(test.b)
require.NoError(t, err)
assert.Equal(t, test.cmp, cmp)
})
}
}
func TestNull_UnaryPlus(t *testing.T) {
t.Parallel()
a := datatype.NewNull()
v, err := a.UnaryPlus()
require.NotNil(t, err)
require.Nil(t, v)
}
func TestNull_UnaryMinus(t *testing.T) {
t.Parallel()
a := datatype.NewNull()
v, err := a.UnaryMinus()
require.NotNil(t, err)
require.Nil(t, v)
}
func TestNull_Add(t *testing.T) {
t.Parallel()
t.Run("null + null", func(t *testing.T) {
t.Parallel()
a := datatype.NewNull()
b := datatype.NewNull()
value, err := a.Add(b)
require.NotNil(t, err)
assert.Nil(t, value)
})
t.Run("null + integer", func(t *testing.T) {
t.Parallel()
a := datatype.NewNull()
b := datatype.NewInteger(10)
value, err := a.Add(b)
require.NoError(t, err)
assert.Equal(t, datatype.NewNull(), value)
})
t.Run("null + float", func(t *testing.T) {
t.Parallel()
a := datatype.NewNull()
b := datatype.NewFloat(10)
value, err := a.Add(b)
require.NoError(t, err)
assert.Equal(t, datatype.NewNull(), value)
})
t.Run("null + text", func(t *testing.T) {
t.Parallel()
a := datatype.NewNull()
b := datatype.NewText("xyz")
value, err := a.Add(b)
require.NoError(t, err)
assert.Equal(t, datatype.NewNull(), value)
})
}
func TestNull_Sub(t *testing.T) {
t.Parallel()
t.Run("null - null", func(t *testing.T) {
t.Parallel()
a := datatype.NewNull()
b := datatype.NewNull()
value, err := a.Sub(b)
require.NotNil(t, err)
assert.Nil(t, value)
})
t.Run("null - integer", func(t *testing.T) {
t.Parallel()
a := datatype.NewNull()
b := datatype.NewInteger(10)
value, err := a.Sub(b)
require.NoError(t, err)
assert.Equal(t, datatype.NewNull(), value)
})
t.Run("null - float", func(t *testing.T) {
t.Parallel()
a := datatype.NewNull()
b := datatype.NewFloat(10)
value, err := a.Sub(b)
require.NoError(t, err)
assert.Equal(t, datatype.NewNull(), value)
})
t.Run("null - text", func(t *testing.T) {
t.Parallel()
a := datatype.NewNull()
b := datatype.NewText("xyz")
value, err := a.Sub(b)
require.NoError(t, err)
assert.Equal(t, datatype.NewNull(), value)
})
}
func TestNull_Mul(t *testing.T) {
t.Parallel()
t.Run("null * null", func(t *testing.T) {
t.Parallel()
a := datatype.NewNull()
b := datatype.NewNull()
value, err := a.Mul(b)
require.NotNil(t, err)
assert.Nil(t, value)
})
t.Run("null * integer", func(t *testing.T) {
t.Parallel()
a := datatype.NewNull()
b := datatype.NewInteger(10)
value, err := a.Mul(b)
require.NoError(t, err)
assert.Equal(t, datatype.NewNull(), value)
})
t.Run("null * float", func(t *testing.T) {
t.Parallel()
a := datatype.NewNull()
b := datatype.NewFloat(10)
value, err := a.Mul(b)
require.NoError(t, err)
assert.Equal(t, datatype.NewNull(), value)
})
t.Run("null * text", func(t *testing.T) {
t.Parallel()
a := datatype.NewNull()
b := datatype.NewText("xyz")
value, err := a.Mul(b)
require.NoError(t, err)
assert.Equal(t, datatype.NewNull(), value)
})
}
func TestNull_Div(t *testing.T) {
t.Parallel()
t.Run("null / null", func(t *testing.T) {
t.Parallel()
a := datatype.NewNull()
b := datatype.NewNull()
value, err := a.Div(b)
require.NotNil(t, err)
assert.Nil(t, value)
})
t.Run("null / integer", func(t *testing.T) {
t.Parallel()
a := datatype.NewNull()
b := datatype.NewInteger(10)
value, err := a.Div(b)
require.NoError(t, err)
assert.Equal(t, datatype.NewNull(), value)
})
t.Run("null / float", func(t *testing.T) {
t.Parallel()
a := datatype.NewNull()
b := datatype.NewFloat(10)
value, err := a.Div(b)
require.NoError(t, err)
assert.Equal(t, datatype.NewNull(), value)
})
t.Run("null / text", func(t *testing.T) {
t.Parallel()
a := datatype.NewNull()
b := datatype.NewText("xyz")
value, err := a.Div(b)
require.NoError(t, err)
assert.Equal(t, datatype.NewNull(), value)
})
}
func TestNull_Pow(t *testing.T) {
t.Parallel()
t.Run("null ^ null", func(t *testing.T) {
t.Parallel()
a := datatype.NewNull()
b := datatype.NewNull()
value, err := a.Pow(b)
require.NotNil(t, err)
assert.Nil(t, value)
})
t.Run("null ^ integer", func(t *testing.T) {
t.Parallel()
a := datatype.NewNull()
b := datatype.NewInteger(10)
value, err := a.Pow(b)
require.NoError(t, err)
assert.Equal(t, datatype.NewNull(), value)
})
t.Run("null ^ float", func(t *testing.T) {
t.Parallel()
a := datatype.NewNull()
b := datatype.NewFloat(10)
value, err := a.Pow(b)
require.NoError(t, err)
assert.Equal(t, datatype.NewNull(), value)
})
t.Run("null ^ text", func(t *testing.T) {
t.Parallel()
a := datatype.NewNull()
b := datatype.NewText("xyz")
value, err := a.Pow(b)
require.NoError(t, err)
assert.Equal(t, datatype.NewNull(), value)
})
}
func TestNull_Mod(t *testing.T) {
t.Parallel()
t.Run("null % null", func(t *testing.T) {
t.Parallel()
a := datatype.NewNull()
b := datatype.NewNull()
value, err := a.Mod(b)
require.NotNil(t, err)
assert.Nil(t, value)
})
t.Run("null % integer", func(t *testing.T) {
t.Parallel()
a := datatype.NewNull()
b := datatype.NewInteger(10)
value, err := a.Mod(b)
require.NoError(t, err)
assert.Equal(t, datatype.NewNull(), value)
})
t.Run("null % float", func(t *testing.T) {
t.Parallel()
a := datatype.NewNull()
b := datatype.NewFloat(10)
value, err := a.Mod(b)
require.NoError(t, err)
assert.Equal(t, datatype.NewNull(), value)
})
t.Run("null % text", func(t *testing.T) {
t.Parallel()
a := datatype.NewNull()
b := datatype.NewText("xyz")
value, err := a.Mod(b)
require.NoError(t, err)
assert.Equal(t, datatype.NewNull(), value)
})
}
func TestNull_Equal(t *testing.T) {
t.Parallel()
t.Run("null == null", func(t *testing.T) {
t.Parallel()
a := datatype.NewNull()
b := datatype.NewNull()
value, err := a.Equal(b)
require.NotNil(t, err)
assert.Nil(t, value)
})
t.Run("null == integer", func(t *testing.T) {
t.Parallel()
a := datatype.NewNull()
b := datatype.NewInteger(10)
value, err := a.Equal(b)
require.NoError(t, err)
assert.Equal(t, datatype.NewNull(), value)
})
t.Run("null == float", func(t *testing.T) {
t.Parallel()
a := datatype.NewNull()
b := datatype.NewFloat(10)
value, err := a.Equal(b)
require.NoError(t, err)
assert.Equal(t, datatype.NewNull(), value)
})
t.Run("null == text", func(t *testing.T) {
t.Parallel()
a := datatype.NewNull()
b := datatype.NewText("xyz")
value, err := a.Equal(b)
require.NoError(t, err)
assert.Equal(t, datatype.NewNull(), value)
})
}
func TestNull_NotEqual(t *testing.T) {
t.Parallel()
t.Run("null != null", func(t *testing.T) {
t.Parallel()
a := datatype.NewNull()
b := datatype.NewNull()
value, err := a.NotEqual(b)
require.NotNil(t, err)
assert.Nil(t, value)
})
t.Run("null != integer", func(t *testing.T) {
t.Parallel()
a := datatype.NewNull()
b := datatype.NewInteger(10)
value, err := a.NotEqual(b)
require.NoError(t, err)
assert.Equal(t, datatype.NewNull(), value)
})
t.Run("null != float", func(t *testing.T) {
t.Parallel()
a := datatype.NewNull()
b := datatype.NewFloat(10)
value, err := a.NotEqual(b)
require.NoError(t, err)
assert.Equal(t, datatype.NewNull(), value)
})
t.Run("null != text", func(t *testing.T) {
t.Parallel()
a := datatype.NewNull()
b := datatype.NewText("xyz")
value, err := a.NotEqual(b)
require.NoError(t, err)
assert.Equal(t, datatype.NewNull(), value)
})
}
func TestNull_GreaterThan(t *testing.T) {
t.Parallel()
t.Run("null > null", func(t *testing.T) {
t.Parallel()
a := datatype.NewNull()
b := datatype.NewNull()
value, err := a.GreaterThan(b)
require.NotNil(t, err)
assert.Nil(t, value)
})
t.Run("null > integer", func(t *testing.T) {
t.Parallel()
a := datatype.NewNull()
b := datatype.NewInteger(10)
value, err := a.GreaterThan(b)
require.NoError(t, err)
assert.Equal(t, datatype.NewNull(), value)
})
t.Run("null > float", func(t *testing.T) {
t.Parallel()
a := datatype.NewNull()
b := datatype.NewFloat(10)
value, err := a.GreaterThan(b)
require.NoError(t, err)
assert.Equal(t, datatype.NewNull(), value)
})
t.Run("null > text", func(t *testing.T) {
t.Parallel()
a := datatype.NewNull()
b := datatype.NewText("xyz")
value, err := a.GreaterThan(b)
require.NoError(t, err)
assert.Equal(t, datatype.NewNull(), value)
})
}
func TestNull_LessThan(t *testing.T) {
t.Parallel()
t.Run("null < null", func(t *testing.T) {
t.Parallel()
a := datatype.NewNull()
b := datatype.NewNull()
value, err := a.LessThan(b)
require.NotNil(t, err)
assert.Nil(t, value)
})
t.Run("null < integer", func(t *testing.T) {
t.Parallel()
a := datatype.NewNull()
b := datatype.NewInteger(10)
value, err := a.LessThan(b)
require.NoError(t, err)
assert.Equal(t, datatype.NewNull(), value)
})
t.Run("null < float", func(t *testing.T) {
t.Parallel()
a := datatype.NewNull()
b := datatype.NewFloat(10)
value, err := a.LessThan(b)
require.NoError(t, err)
assert.Equal(t, datatype.NewNull(), value)
})
t.Run("null < text", func(t *testing.T) {
t.Parallel()
a := datatype.NewNull()
b := datatype.NewText("xyz")
value, err := a.LessThan(b)
require.NoError(t, err)
assert.Equal(t, datatype.NewNull(), value)
})
}
func TestNull_GreaterOrEqual(t *testing.T) {
t.Parallel()
t.Run("null >= null", func(t *testing.T) {
t.Parallel()
a := datatype.NewNull()
b := datatype.NewNull()
value, err := a.GreaterOrEqual(b)
require.NotNil(t, err)
assert.Nil(t, value)
})
t.Run("null >= integer", func(t *testing.T) {
t.Parallel()
a := datatype.NewNull()
b := datatype.NewInteger(10)
value, err := a.GreaterOrEqual(b)
require.NoError(t, err)
assert.Equal(t, datatype.NewNull(), value)
})
t.Run("null >= float", func(t *testing.T) {
t.Parallel()
a := datatype.NewNull()
b := datatype.NewFloat(10)
value, err := a.GreaterOrEqual(b)
require.NoError(t, err)
assert.Equal(t, datatype.NewNull(), value)
})
t.Run("null >= text", func(t *testing.T) {
t.Parallel()
a := datatype.NewNull()
b := datatype.NewText("xyz")
value, err := a.GreaterOrEqual(b)
require.NoError(t, err)
assert.Equal(t, datatype.NewNull(), value)
})
}
func TestNull_LessOrEqual(t *testing.T) {
t.Parallel()
t.Run("null <= null", func(t *testing.T) {
t.Parallel()
a := datatype.NewNull()
b := datatype.NewNull()
value, err := a.LessOrEqual(b)
require.NotNil(t, err)
assert.Nil(t, value)
})
t.Run("null <= integer", func(t *testing.T) {
t.Parallel()
a := datatype.NewNull()
b := datatype.NewInteger(10)
value, err := a.LessOrEqual(b)
require.NoError(t, err)
assert.Equal(t, datatype.NewNull(), value)
})
t.Run("null <= float", func(t *testing.T) {
t.Parallel()
a := datatype.NewNull()
b := datatype.NewFloat(10)
value, err := a.LessOrEqual(b)
require.NoError(t, err)
assert.Equal(t, datatype.NewNull(), value)
})
t.Run("null <= text", func(t *testing.T) {
t.Parallel()
a := datatype.NewNull()
b := datatype.NewText("xyz")
value, err := a.LessOrEqual(b)
require.NoError(t, err)
assert.Equal(t, datatype.NewNull(), value)
})
}
func TestNull_And(t *testing.T) {
t.Parallel()
t.Run("null AND null -> null", func(t *testing.T) {
t.Parallel()
a := datatype.NewNull()
b := datatype.NewNull()
value, err := a.And(b)
require.NoError(t, err)
assert.Equal(t, datatype.NewNull(), value)
})
t.Run("null AND true -> null", func(t *testing.T) {
t.Parallel()
a := datatype.NewNull()
b := datatype.NewBoolean(true)
value, err := a.And(b)
require.NoError(t, err)
assert.Equal(t, datatype.NewNull(), value)
})
t.Run("null AND false -> false", func(t *testing.T) {
t.Parallel()
a := datatype.NewNull()
b := datatype.NewBoolean(false)
value, err := a.And(b)
require.NoError(t, err)
assert.Equal(t, datatype.NewBoolean(false), value)
})
t.Run("null AND integer -> unsupported", func(t *testing.T) {
t.Parallel()
a := datatype.NewNull()
b := datatype.NewInteger(10)
value, err := a.And(b)
require.NotNil(t, err)
assert.Nil(t, value)
})
t.Run("null AND float -> unsupported", func(t *testing.T) {
t.Parallel()
a := datatype.NewNull()
b := datatype.NewFloat(10)
value, err := a.And(b)
require.NotNil(t, err)
assert.Nil(t, value)
})
t.Run("null AND text -> unsupported", func(t *testing.T) {
t.Parallel()
a := datatype.NewNull()
b := datatype.NewText("xyz")
value, err := a.And(b)
require.NotNil(t, err)
assert.Nil(t, value)
})
}
func TestNull_Or(t *testing.T) {
t.Parallel()
t.Run("null OR null -> null", func(t *testing.T) {
t.Parallel()
a := datatype.NewNull()
b := datatype.NewNull()
value, err := a.Or(b)
require.NoError(t, err)
assert.Equal(t, datatype.NewNull(), value)
})
t.Run("null OR true -> true", func(t *testing.T) {
t.Parallel()
a := datatype.NewNull()
b := datatype.NewBoolean(true)
value, err := a.Or(b)
require.NoError(t, err)
assert.Equal(t, datatype.NewBoolean(true), value)
})
t.Run("null OR false -> null", func(t *testing.T) {
t.Parallel()
a := datatype.NewNull()
b := datatype.NewBoolean(false)
value, err := a.Or(b)
require.NoError(t, err)
assert.Equal(t, datatype.NewNull(), value)
})
t.Run("null OR integer -> unsupported", func(t *testing.T) {
t.Parallel()
a := datatype.NewNull()
b := datatype.NewInteger(10)
value, err := a.Or(b)
require.NotNil(t, err)
assert.Nil(t, value)
})
t.Run("null OR float -> unsupported", func(t *testing.T) {
t.Parallel()
a := datatype.NewNull()
b := datatype.NewFloat(10)
value, err := a.Or(b)
require.NotNil(t, err)
assert.Nil(t, value)
})
t.Run("null OR text -> unsupported", func(t *testing.T) {
t.Parallel()
a := datatype.NewNull()
b := datatype.NewText("xyz")
value, err := a.Or(b)
require.NotNil(t, err)
assert.Nil(t, value)
})
}
|
End of preview. Expand
in Data Studio
README.md exists but content is empty.
- Downloads last month
- 46