Frequently Asked Questions
Table of contents
Device support
Which devices are supported?
GrapheneOS has official production support for the Pixel 2, Pixel 2 XL, Pixel 3, Pixel 3 XL, Pixel 3a and Pixel 3a XL. The release tags for these devices have official builds and updates available. These devices meet the stringent privacy and security standards and have substantial upstream and downstream hardening specific to the devices.
Many other devices are supported by GrapheneOS at a source level, and it can be built for them without modifications to the existing GrapheneOS source tree. Device support repositories for the Android Open Source Project can simply be dropped into the source tree, with at most minor modifications within them to support GrapheneOS. In most cases, substantial work beyond that will be needed to bring the support up to the same standards. For most devices, the hardware and firmware will prevent providing a reasonably secure device, regardless of the work put into device support.
GrapheneOS also supports generic targets, but these aren't suitable for production usage and are only intended for development and testing use. For mobile devices, the generic targets simply run on top of the underlying device support code (firmware, kernel, device trees, vendor code) rather than shipping it and keeping it updated. It would be possible to ship generic system images with separate updates for the device support code. However, it would be drastically more complicated to maintain and support due to combinations of different versions and it would cause complications for the hardening done by GrapheneOS. The motivation doesn't exist for GrapheneOS, since full updates with deltas to minimize bandwidth can be shipped for every device and GrapheneOS is the only party involved in providing the updates. For the same reason, it has little use for the ability to provide out-of-band updates to system image components including all the apps and many other components.
Some of the GrapheneOS sub-projects support other operating systems on a broader range of devices. Device support for Auditor and AttestationServer is documented in the overview of those projects. The hardened_malloc project supports nearly any Linux-based environment due to official support for musl, glibc and Bionic along with easily added support for other environments. It can easily run on non-Linux-based operating systems too, and supporting some like HardenedBSD is planned but depends on contributors from those communities.
Which devices are recommended?
The recommended devices with the best hardware, firmware and software security along with the longest future support time are the Pixel 3a, Pixel 3a XL, Pixel 3 and Pixel 3 XL. The Pixel 3a and 3a XL are budget devices meeting the same security standards as the more expensive flagship devices. Compared to the Pixel 3a and 3a XL, the flagship Pixel 3 and Pixel 3 XL have wireless charging, dual front-facing speakers, the Pixel Visual Core supporting HDR+ with compatible apps on GrapheneOS, IP68 dust and water protection, a higher-end screen, slightly more durable glass and of course a stronger CPU, GPU, cellular radio, etc. You should get one of the budget devices if these things aren't compelling to you. The Pixel 3a and 3a XL do have one extra feature: an analog headphone port as an alternative to wireless audio and digital USB-C audio.
Which devices will be supported in the future?
Devices are carefully chosen based on their merits rather than the project aiming to have broad device support. Broad device support is counter to the aims of the project, and the project will eventually be engaging in hardware and firmware level improvements rather than only offering suggestions and bug reports upstream for those areas. Much of the work on the project involves changes that are specific to different devices, and officially supported devices are the ones targeted by most of this ongoing work.
Devices need to be meeting the standards of the project in order to be considered as potential targets. In addition to support for installing other operating systems, standard hardware-based security features like the hardware-backed keystores, verified boot, attestation and various hardware-based exploit mitigations need to be available. Devices also need to have decent integration of IOMMUs for isolating components such as the GPU, radios (NFC, Wi-Fi, Bluetooth, Cellular), media decode / encode, image processor, etc., because if the hardware / firmware support is missing or broken, there's not much that the OS can do to provide an alternative. Devices with support for alternative operating systems as an afterthought will not be considered. Devices need to have proper ongoing support for their firmware and software specific to the hardware like drivers in order to provide proper full security updates too. Devices that are end-of-life and no longer receiving these updates will not be supported.
In order to support a device, the appropriate resources also need to be available and dedicated towards it. Releases for each supported device need to be robust and stable, with all standard functionality working properly and testing for each of the releases.
Hardware, firmware and software specific to devices like drivers play a huge role in the overall security of a device. The goal of the project is not to slightly improve some aspects of insecure devices and supporting a broad set of devices would be directly counter to the values of the project. A lot of the low-level work also ends up being fairly tied to the hardware.
When will more devices be supported?
Broader device support can only happen after the community (companies, organizations and individuals) steps up to make substantial, ongoing contributions to making the existing device support sustainable. Once the existing device support is more sustainable, early research and development work for other devices can begin. Once a device is deemed to be a worthwhile target, the project needs maintainers to develop and maintain support for it including addressing device-specific issues that are uncovered, which will include issues uncovered in the device support code by GrapheneOS hardening features.
It's not really a matter of time but rather a need for community support for the project increasing. As an open source project, the way to get something to happen in GrapheneOS is to contribute to it, and this is particularly true for device support since it's very self-contained and can be delegated to separate teams for each device. If you want to see more devices supported sooner, you should get to work on identifying good devices with full support for alternative operating systems with verified boot, etc. and then start working on integrating and testing support.
It should also be clear that the expectation is for people to buy a device to run GrapheneOS, rather than GrapheneOS supporting their existing devices. This will only become more true if GrapheneOS is successful enough to accomplish the goal of having devices produced based on an SoC reference design with minor improvements for privacy and security. Broad device support is the opposite of what the project wants to achieve in the long term.
Why are older devices no longer supported?
GrapheneOS aims to provide reasonably private and secure devices. It cannot do that once device support code like firmware, kernel and vendor code is no longer actively maintained. Even if the community was prepared to take over maintainance of the open source code and to replace the rest, firmware would present a major issue, and the community has never been active or interested enough in in device support to consider attempting this. Unlike many other platforms, GrapheneOS has a much higher minimum standard than simply having devices fully functional, as they also need to provide the expected level of security. It would start to become realistic to provide substantially longer device support once GrapheneOS controls the hardware and firmware via custom hardware manufactured for it. Until then, the lifetime of devices will remain based on manufacturer support. It's also important to keep in mind that phone vendors claiming to provide longer support often aren't actually doing it and some never even ship firmware updates when the hardware is still supported by the vendors...
GrapheneOS also has high standards for the privacy and security properties of the hardware and firmware, and these standards are regularly advancing. The rapid pace of improvement has been slowing down, but each hardware generation still brings major improvements. Over time, the older hardware starts to become a substantial liability and holds back the project. It becomes complex to simply make statements about the security of the project when exceptions for old devices need to be listed out. The project ends up wanting to drop devices for this reason but has always kept them going until the end-of-life date to provide more time for people to migrate.
Security and privacy
Can apps access hardware identifiers?
As of Android 10, apps cannot obtain permission to access non-resettable hardware
identifiers such as the serial number, MAC addresses, IMEIs/MEIDs, SIM card serial
numbers and subscriber IDs. Only privileged apps included in the base system with
READ_PRIVILEGED_PHONE_STATE
whitelisted can access these hardware
identifiers. Apps targeting Android 10 will receive a SecurityException
and older apps will receive an empty value for compatibility.
GrapheneOS only makes a small change to remove a legacy form of access to the serial number by legacy apps, which was still around for compatibility.
What kind of connections do the OS and bundled apps make by default?
GrapheneOS makes connections to the outside world to test connectivity, detect captive portals and download updates. No data varying per user / installation is sent in these connections. There aren't analytics / telemetry in GrapheneOS.
The expected default connections by GrapheneOS (including all base system apps) are the following:
-
The GrapheneOS Updater app fetches update metadata from https://releases.grapheneos.org/DEVICE-CHANNEL approximately once every four hours when connected to a permitted network for updates.
Once an update is available, it tries to download https://releases.grapheneos.org/DEVICE-incremental-OLD_VERSION-NEW_VERSION.zip for a delta update, and then falls back to https://releases.grapheneos.org/DEVICE-ota_update-NEW_VERSION.zip.
No query / data is sent to the server, so the only information leaked to it are the variables in these 3 URLs (device, channel, current version) which is necessary to obtain the update.
Users can control which types of connections the Updater app will use, and although it's strongly recommended to always leave it enabled it can be disabled.
-
An HTTPS connection is made to https://time.grapheneos.org/ to update the time from the date header field. This is a full replacement of Android's standard network time update implementation, which uses the cellular network when available with a fallback to SNTP when it's not available. This can be disabled with the toggle at Settings ➔ System ➔ Date & time ➔ Use network-provided time. The time zone is still obtained directly via the time zone provided by the mobile network when available.
-
On devices with a Qualcomm baseband (which provides GPS), when location functionality is being used, GPS almanacs are downloaded from https://xtrapath1.izatcloud.net/xtra3grc.bin, https://xtrapath2.izatcloud.net/xtra3grc.bin or https://xtrapath3.izatcloud.net/xtra3grc.bin. GrapheneOS has modified all references to these servers to use HTTPS rather than a mix of HTTP and HTTPS. No query / data is sent to the server.
-
Connectivity checks designed to mimic a web browser user agent are performed by using HTTP and HTTPS to fetch standard URLs generating an HTTP 204 status code. This is used to detect when internet connectivity is lost on a network, which triggers fallback to other available networks if possible. These checks are designed to detect and handle captive portals which substitute the expected empty 204 response with their own web page. These need use a very common domain and URL in order to bypass whitelisting systems only permitting access to common domains / URLs so a domain like grapheneos.org would likely be inadequate. GrapheneOS leaves these set to the standard four URLs to blend into the crowd of billions of other Android devices with and without Google Mobile Services performing the same empty GET requests. For privacy reasons, it isn't desirable to stand out from the crowd and changing these URLs or even disabling the feature will likely reduce your privacy by giving your device a more unique fingerprint. GrapheneOS aims to appear like any other common mobile device on the network.
- HTTPS: https://www.google.com/generate_204
- HTTP: http://connectivitycheck.gstatic.com/generate_204
- HTTP fallback: http://www.google.com/gen_204
- HTTP other fallback: http://play.googleapis.com/generate_204
Standard AOSP user agent for the GET request:
Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/60.0.3112.32 Safari/537.36
No query / data is sent to the servers and the response is unused beyond checking the response code.
Similar connectivity checks are also performed by Vanadium.
-
DNS connectivity and functionality tests
-
DNS resolution for other connections
What does GrapheneOS do about cellular tracking and silent SMS?
GrapheneOS always considers the network to be hostile and does not implement weak or useless mitigations. Therefore, it does not have the assorted gimmicks seen elsewhere providing privacy/security theatre to make users feel better about these issues. One of the core tenets of GrapheneOS is being honest with users and avoiding scams/frills based around marketing rather than real world privacy/security threat models.
Activating airplane mode will fully disable the cellular radio transmit and receive capabilities, which will prevent your phone from being reached from the cellular network and stop your carrier (and anyone impersonating them to you) from tracking the device via the cellular radio. The baseband implements other functionality such as Wi-Fi and GPS functionality, but each of these components is separately sandboxed on the baseband and independent of each other. Enabling airplane mode disables the cellular radio, but Wi-Fi can be re-enabled and used without activating the cellular radio again. This allows using the device as a Wi-Fi only device.
Even if interception of the connection or some other man-in-the-middle attack along the network is not currently occurring, the network is still untrustworthy and information should not be sent unencrypted. Legacy calls and texts should be avoided as they're not secure and trust the carrier / network along with having weak security against other parties. Trying to detect some forms of interception rather than dealing with the root of the problem (unencrypted communications / data transfer) would be foolish and doomed to failure.
Receiving a silent SMS is not a good indicator of being targeted by your cell carrier, police or government because anyone on the cell network can send them including yourself. Cellular triangulation will happen regardless of whether or not SMS texts are being sent or received by the phone. Even if an SMS did serve a useful purpose for tracking, a silent SMS would be little different than receiving unsolicited spam. In fact, sending spam would be stealthier since it wouldn't trigger alerts for silent SMS but rather would be ignored with the rest of the spam. Regardless, sending texts or other data is not required or particularly useful to track devices connected to a network for an adversary with the appropriate access.


As portrayed in Quills, based on the Obie Award-winning play by Doug Wright, the Marquis is an earthy, dirty, jolly old soul with the unquenchable desire to write his perverse dreams on paper.
It's not enough that the madman hole up in his room with quill and reams of parchment to indulge his fantasies, no. He has to publish it to the secret, unspoken delight of the masses. Chapters are being smuggled out of the asylum by a curious chambermaid, Madeleine (Kate Winslet from Heavenly Creatures, Titanic). The streets are buzzing with outrage and titillation.
Napoleon (Ron Cook) would love nothing more than to see the head of the Marquis twitching under the guillotine, but martyrdom would only increase the sales and spread the word. Therefore, a man is sent to the asylum with the intent to cure the Marquis of all the devils inside his head, whether it be through torture or, worse, the restriction of his writing privileges.
That upstanding citizen sent to Charenton is Dr. Royer-Collard (Michael Caine, reclaiming his title as Hardest Working Actor in the Business), a man so moral to the core that he marries a young lass whom he could have fathered twice over. This pinnacle of morality even has to force himself upon her on their wedding night.
Our friend the doctor is just the sort of closet dirty bird the Marquis delights in mocking. A play is swiftly written, performed by the inmates of the asylum (which is indeed based on fact, since de Sade's plays were quite popular in his day) about a dirty old man humping his young bride in a variety of sexual positions. Dr. Royer-Collard sits in the audience, silently biding his time. In this battle of wills between doctor and madman, this is only the beginning.
Doug Wright's story takes tremendous liberties with the Marquis' life, but the approach taken by director Philip Kaufman (Henry & June) feels appropriately mannered, clever and seedy. From the start, we accept that every character will be a bit off.
Geoffrey Rush is wonderfully carnal and hungry as the Marquis, sashaying and swaying his body as he spouts out his scathing indictments of the so-called upstanding members of society. He makes full use of his robust voice, moving from ticklish prods to hot ecstasy. Rush manages to play the role over-the-top without going into camp, since he reveals small, subtle moments of genuine feeling (such as the moment we knew was coming, when the men in power take away his precious quills).
Kate Winslet continues to impress as his loyal supporter, choosing challenging roles in independent films rather than cashing in on the success of Titanic. She could have become a major Hollywood star, but instead opted for building a quality body of work in such films as Holy Smoke and Hideous Kinky. She and Rush attack their scenes with playful relish together.
There's also fine support from Joaquin Phoenix's (Gladiator) humanitarian priest whose noble principles are rocked by the decadent charms of the Marquis. Michael Caine takes what could have been a predictable arch-fiend and turns him into a complex, firm presence -- a steady rock who makes for quite a match against Geoffrey Rush's Marquis, though they share very few scenes.
Philip Kaufman brings bravura camera placement into the film, whether it be low angles of leering faces or tracking shots following horse drawn carriages intercut with passengers rocking back and forth as vampiric music rejoices on the soundtrack. The production design is a Merchant Ivory film gone to seed, with mossy green walls and costumes which are soiled, wrinkled, and dirty. Even the wigs have flecks of sweat and grime. The actors, feeding off of these props, give performances like grinning masks, scary and hilarious.
The plot is fairly traditional melodrama, complete with secret affairs and betrayals, bodice ripping and murder. It all culminates in an inevitable, explosive riot within the madhouse where the insane run wild, rattling their chains and ripping off their clothes. The sex and violence crowd will find their fair share of it here. While the mechanics are not unfamiliar, there's so much gusto thrown into the performances and attention to period detail that Quills plays out as enjoyably lavish, but not laughable.
This film never goes as far as Pier Paolo Pasolini's interpretation of de Sade's Salo: 120 Days of Sodom, happy to be entertaining if not challenging. Altogether, it makes for a fitting beginner's introduction to the Sadean school of thought (and a much better one than De Sade, an earlier film on the man's life).
Oddly, even though Geoffrey Rush spends the final half hour of the picture wandering around completely naked, this version of Marquis de Sade's life could almost play in Peoria. Almost, I say. While the Marquis spends much of the film talking about the bizarre sexual acts he committed during his life, Quills does find time to give us a little necrophilia. Gotta love that Marquis.

The review above was posted to the
rec.arts.movies.reviews newsgroup (de.rec.film.kritiken for German reviews).
The Internet Movie Database accepts no responsibility for the contents of the
review and has no editorial control. Unless stated otherwise, the copyright
belongs to the author.
Please direct comments/criticisms of the review to relevant newsgroups.
Broken URLs inthe reviews are the responsibility of the author.
The formatting of the review is likely to differ from the original due
to ASCII to HTML conversion.
Related links: index of all rec.arts.movies.reviews reviews


WeatherStatus
public enum WeatherStatus : UInt8
Weather Status Type
-
Clear
Declaration
Swift
case clear = 0
-
Partly Cloudy
Declaration
Swift
case partlyCloudy = 1
-
Mostly Cloudy
Declaration
Swift
case mostlyCloudy = 2
-
Rain
Declaration
Swift
case rain = 3
-
Snow
Declaration
Swift
case snow = 4
-
Windy
Declaration
Swift
case windy = 5
-
Thunderstorms
Declaration
Swift
case thunderstorms = 6
-
Wintery Mix
Declaration
Swift
case winteryMix = 7
-
Fog
Declaration
Swift
case fog = 8
-
Hazy
Declaration
Swift
case hazy = 11
-
Hail
Declaration
Swift
case hail = 12
-
Scattered Showers
Declaration
Swift
case scatteredShowers = 13
-
Scattered Thunderstorms
Declaration
Swift
case scatteredThunderstorms = 14
-
Unknown Precipitation
Declaration
Swift
case unknownPrecipitation = 15
-
Light Rain
Declaration
Swift
case lightRain = 16
-
Heavy Rain
Declaration
Swift
case heavyRain = 17
-
Light Snow
Declaration
Swift
case lightSnow = 18
-
Heavy Snow
Declaration
Swift
case heavySnow = 19
-
Light Rain Snow
Declaration
Swift
case lightRainSnow = 20
-
Heavy Rain Snow
Declaration
Swift
case heavyRainSnow = 21
-
Cloudy
Declaration
Swift
case cloudy = 22
-
Invalid
Declaration
Swift
case invalid = 255


| 3736 - Consanguine Calculations World Finals - Tokyo - 2006/2007 | |||||
| Submit | Ranking |
Every person's blood has 2 markers called ABO alleles. Each of the markers is represented by one of three letters: A, B, or O. This gives six possible combinations of these alleles that a person can have, each of them resulting in a particular ABO blood type for that person.
| Combination | ABO Blood Type |
| AA | A |
| AB | AB |
| AO | A |
| BB | B |
| BO | B |
| OO | O |
Likewise, every person has two alleles for the blood Rh factor, represented by the characters + and -. Someone who is ``Rh positive" or ``Rh+" has at least one + allele, but could have two. Someone who is ``Rh negative" always has two - alleles.
The blood type of a person is a combination of ABO blood type and Rh factor. The blood type is written by suffixing the ABO blood type with the + or - representing the Rh factor. Examples include A+, AB-, and O-.
Blood types are inherited: each biological parent donates one ABO allele (randomly chosen from their two) and one Rh factor allele to their child. Therefore 2 ABO alleles and 2 Rh factor alleles of the parents determine the child's blood type. For example, if both parents of a child have blood type A-, then the child could have either type A- or type O- blood. A child of parents with blood types A+ and B+ could have any blood type.
In this problem, you will be given the blood type of either both parents or one parent and a child; you will then determine the (possibly empty) set of blood types that might characterize the child or the other parent.
Note: an uppercase letter ``Oh" is used in this problem to denote blood types, not a digit (zero).
The input consists of multiple test cases. Each test case is on a single line in the format: the blood type of one parent, the blood type of the other parent, and finally the blood type of the child, except that the blood type of one parent or the child will be replaced by a question mark. To improve readability, whitespace may be included anywhere on the line except inside a single blood type specification.
The last test case is followed by a line containing the letters E, N, and D separated by whitespace.
For each test case in the input, print the case number (beginning with 1) and the blood type of the parents and the child. If no blood type for a parent is possible, print ``IMPOSSIBLE". If multiple blood types for parents or child are possible, print all possible values in a comma-separated list enclosed in curly braces. The order of the blood types inside the curly braces does not matter.
The sample output illustrates multiple output formats. Your output format should be similar.
O+ O- ? O+ ? O- AB- AB+ ? AB+ ? O+ E N D
Case 1: O+ O- {O+, O-} Case 2: O+ {A-, A+, B-, B+, O-, O+} O- Case 3: AB- AB+ {A+, A-, B+, B-, AB+, AB-} Case 4: AB+ IMPOSSIBLE O+
Tests-Setter: Derek Kisman


Websocket Audio Echo Client
This is Websocket Audio Echo Example Client Page.
Host
Port
Streamer
Start
Stop
Player
Start
Stop


Required fields are folllowed by *
Name *
Phone *
Email *
College *
Address
City *
Pincode *
State/Union Territory *
State/Union Territory
Andhra Pradesh
Arunachal Pradesh
Assam
Andaman and Nicobar
Bihar
Chandigarh
Chhattisgarh
Dadra and Nagar Haveli
Daman and Diu
Delhi
Goa
Ladakh
Lakshadweep
Gujarat
Haryana
Himachal Pradesh
Jammu and Kashmir
Jharkhand
Karnataka
Kerala
Madhya Pradesh
Maharashtra
Manipur
Meghalaya
Mizoram
Nagaland
Orissa
Punjab
Pondicherry
Rajasthan
Sikkim
Tamil Nadu
Telangana
Tripura
Uttarakhand
Uttar Pradesh
West Bengal


Active
Much longer nav link
Link
Disabled
One of three columns
Previous
Next
Featured
Special Title treatment
With supporting text.
Go somewhere


This class can be used to transform objects in 3D space by adapting a similar interaction model of DCC tools like Blender.
Unlike other controls, it is not intended to transform the scene's camera.
[name] expects that its attached 3D object is part of the scene graph.
[name] is an add-on, and must be imported explicitly. See [link:#manual/introduction/Installation Installation / Addons].
import { TransformControls } from 'three/addons/controls/TransformControls.js';
[example:misc_controls_transform misc / controls / transform ]
[page:Camera camera]: The camera of the rendered scene.
[page:HTMLDOMElement domElement]: The HTML element used for event listeners.
Creates a new instance of [name].
Fires if any type of change (object or property change) is performed. Property changes are separate events you can add event listeners to. The event type is "propertyname-changed".
Fires if a pointer (mouse/touch) becomes active.
Fires if a pointer (mouse/touch) is no longer active.
Fires if the controlled 3D object is changed.
See the base [page:Object3D] class for common properties.
The current transformation axis.
The camera of the rendered scene.
The HTMLDOMElement used to listen for mouse / touch events. This must be passed in the constructor; changing it here will not set up new event listeners.
Whether or not dragging is currently performed. Read-only property.
Whether or not the controls are enabled.
The current transformation mode. Possible values are "translate", "rotate" and "scale". Default is `translate`.
The 3D object being controlled.
By default, 3D objects are continuously rotated. If you set this property to a numeric value (radians), you can define in which steps the 3D object should be rotated. Default is `null`.
Whether or not the x-axis helper should be visible. Default is `true`.
Whether or not the y-axis helper should be visible. Default is `true`.
Whether or not the z-axis helper should be visible. Default is `true`.
The size of the helper UI (axes/planes). Default is *1*.
Defines in which coordinate space transformations should be performed. Possible values are "world" and "local". Default is `world`.
By default, 3D objects are continuously translated. If you set this property to a numeric value (world units), you can define in which steps the 3D object should be translated. Default is `null`.
See the base [page:Object3D] class for common methods.
[page:Object3D object]: The 3D object that should be transformed.
Sets the 3D object that should be transformed and ensures the controls UI is visible.
Removes the current 3D object from the controls and makes the helper UI invisible.
Should be called if the controls is no longer required.
Returns the [page:Raycaster] object that is used for user interaction. This object is shared between all instances of TransformControls. If you set the [page:Object3D.layers .layers] property of the [name], you will also want to set the [page:Raycaster.layers .layers] property on the [page:Raycaster] with a matching value, or else the [name] won't work as expected.
Returns the transformation mode.
Resets the object's position, rotation and scale to when the current transform began.
[page:String mode]: The transformation mode.
Sets the transformation mode.
[page:Number rotationSnap]: The rotation snap.
Sets the rotation snap.
[page:Number scaleSnap]: The scale snap.
Sets the scale snap.
[page:Number size]: The size of the helper UI.
Sets the size of the helper UI.
[page:String space]: The coordinate space in which transformations are applied.
Sets the coordinate space in which transformations are applied.
[page:Number translationSnap]: The translation snap.
Sets the translation snap.
[link:https://github.com/mrdoob/three.js/blob/master/examples/jsm/controls/TransformControls.js examples/jsm/controls/TransformControls.js]


DTHTMLParser Class Reference
| Inherits from | NSObject |
| Declared in | DTHTMLParser.h |
Overview
Instances of this class parse HTML documents (including DTD declarations) in an event-driven manner. A DTHTMLParser notifies its delegate about the items (elements, attributes, CDATA blocks, comments, and so on) that it encounters as it processes an HTML document. It does not itself do anything with those parsed items except report them. It also reports parsing errors. For convenience, an DTHTMLParser object in the following descriptions is sometimes referred to as a parser object.
Tasks
Initializing a Parser Object
-
– initWithData:encoding:
Initializes the receiver with the HTML contents encapsulated in a given data object.
Parsing
-
– parse
Starts the event-driven parsing operation.
-
– abortParsing
Stops the parser object.
-
– setDelegate:
Sets the receiver’s delegate.
-
– delegate
Returns the receiver’s delegate.
-
columnNumber
Returns the column number of the XML document being processed by the receiver.
property -
lineNumber
Returns the line number of the HTML document being processed by the receiver.
property -
parserError
Returns an
propertyNSError
object from which you can obtain information about a parsing error. -
publicID
Returns the public identifier of the external entity referenced in the HTML document.
property -
systemID
Returns the system identifier of the external entity referenced in the HTML document.
property
Properties
columnNumber
Returns the column number of the XML document being processed by the receiver.
@property (nonatomic, readonly) NSInteger columnNumber
Discussion
The column refers to the nesting level of the HTML elements in the document. You may invoke this method once a parsing operation has begun or after an error occurs.
Declared In
DTHTMLParser.h
lineNumber
Returns the line number of the HTML document being processed by the receiver.
@property (nonatomic, readonly) NSInteger lineNumber
Discussion
You may invoke this method once a parsing operation has begun or after an error occurs.
Declared In
DTHTMLParser.h
parserError
Returns an NSError
object from which you can obtain information about a parsing error.
@property (nonatomic, readonly, strong) NSError *parserError
Discussion
You may invoke this method after a parsing operation abnormally terminates to determine the cause of error.
Declared In
DTHTMLParser.h
Instance Methods
delegate
Returns the receiver’s delegate.
- (id<DTHTMLParserDelegate>)delegate
See Also
Declared In
DTHTMLParser.h
initWithData:encoding:
Initializes the receiver with the HTML contents encapsulated in a given data object.
- (id)initWithData:(NSData *)data encoding:(NSStringEncoding)encoding
Parameters
- data
An
NSData
object containing XML markup.
- encoding
The encoding used for encoding the HTML data
Return Value
An initialized DTHTMLParser
object or nil if an error occurs.
Declared In
DTHTMLParser.h
parse
Starts the event-driven parsing operation.
- (BOOL)parse
Return Value
YES
if parsing is successful and NO
in there is an error or if the parsing operation is aborted.
Discussion
If you invoke this method, the delegate, if it implements parser:parseErrorOccurred:, is informed of the cancelled parsing operation.
Declared In
DTHTMLParser.h


Represents an immutable block of data that is uniquely referenced with a cid.
const block = new Block(Uint8Array.from([0, 1, 2, 3]), new CID('...'))
The data to be stored in the block as a Uint8Array.
The cid of the data
The cid of the data this block represents.
The data of this block.
Check if the given value is a Block.
Represents an immutable block of data that is uniquely referenced with a cid.
const block = new Block(Uint8Array.from([0, 1, 2, 3]), new CID('...'))


|
|
|
Profit and Loss - Quant/Math - CAT
2003
Question 4 the day: July 3,
2003
The question for the day is from
the topic of Profit and Loss.
- Two merchants sell, each an article for Rs.1000.
If Merchant A computes his profit on cost price, while
Merchant B computes his profit on selling price, they
end up making profits of 25% respectively. By how much
is the profit made by Merchant B greater than that of
Merchant A?
| (1) |
Rs.66.67 |
|
|
(2) |
Rs. 50 |
| (3) |
Rs.125 |
|
|
(4) |
Rs.200 | Correct
Answer - (2)
Solution:
Merchant B computes his
profit as a percentage of selling price. He makes a
profit of 25% on selling price of Rs.1000. i.e. his
profit = 25% of 1000 = Rs.250
Merchant A computes
his profit as a percentage of cost price.
If he
makes a profit of 25% or 1/4th of his cost
price, then his profit expressed as a percentage of
selling price = 1/(1+4) = 1/5th or 20% of
selling price.
So, Merchant A makes a profit of
20% of Rs.1000 = Rs.200.
Hence, Merchant B makes
Rs.50 more profit than Merchant A.
| | | |


--- date: 2023-07-31 lastmod: 2023-08-01 title: "How to test your Lua" description: "Having a look at testing Lua code, from small manual tests, to automated tests with LuaUnit. Also having a look at how to mock code and continuous integration with GitHub Actions." image: "/assets/blog/lua-series-part-3/title-card.png" imageAlt: "Showing a VSCode window in dark mode, a Lua file open with showing test code written with LuaUnit. A sidebar on the left, showing the project files that get built in this part of the series." linkTitle: "Different aspects of testing your Lua code." banner: "/assets/blog/lua-series-part-3/banner" bannerAlt: "Showing a VSCode window in dark mode, a Lua file open with showing test code written with LuaUnit. A sidebar on the left, showing the project files that get built in this part of the series." summary: "
Besides quick iterations on the command-line, having a test suite for Lua will be crucial for any serious project. This article will also cover mocking and a continuous integration setup.
" hasCode: true tags: ["post", "lua"] series: { name: lua, part: 3 } ---After the first article of this series, setting up a project with Lua and LuaRocks, and a deep dive into managing Lua modules, it is time to look at how to test Lua code in this part of the series.
The article will start by showing how to quickly iterate over code and run small snippets — manually, without external dependencies. After that; unit testing, first without and then with an external module, LuaUnit; how to create mocks for tests; and finally using continuous integration.
All the code shown in this article is also available in the companion repository on GitHub, branch part-3.
The latest Lua version as of writing is 5.4 (released ), though everything in this article series will work with Lua 5.1 (released ) and up. If this deviates, a callout like the following will signal the required version.
An overview of all versions and main their features can be found on the official Lua version history page.
Besides Lua, LuaRocks will be used for the base test setup. I covered setting up both in the first article of this series, showing how to install and run Lua and LuaRocks for macOS, Linux, and Windows.
With both installed, running the following command inside a project folder will create a new LuaRocks projects.
This will set up the package "my-project" with LuaRocks. More about managing projects with LuaRocks in the second article of this series.
With the project setup done, it is now possible to run
./luarocks test
. Without further parameters, this will run a
test.lua
file from the project root if found.
Alternatively, the test
property of the project
.rockspec
file can be used to define a different location or file
for the test entry.
Besides using a Lua file as the test entry, a
shell command can be used by changing script
to
command
.
For now, the test entry file will only print that no tests are defined.
All options for setting up the test command can be found in the test command specification on the LuaRocks GitHub wiki.
Even with a way to run the test entry point via LuaRocks, there is also a simpler way to test code without LuaRocks or even tests — running and verifying the code manually.
I'm absolutely in favor of test automation, but for small scripts and snippets, manually testing, as with Lua's interactive mode, can be a viable way for quick iterations.
Running the lua
CLI without any arguments will enter interactive
mode.
To test how to iterate on code, the following small piece of code, called
chunk
in Lua, will be defined inside a new file factorial.lua
.
The idea is to use the dofile
function for quick tests.
After making changes to the code, dofile
can be executed again
from the console to re-run the code. Using this approach will enable quick
iterations on small chunks via the command-line.
assert
Before diving into LuaUnit, for small tests, Lua's
assert
function can be used in combination with
pcall. To keep the setup minimal, all that is needed is a test
helper
function.
The function will take an anonymous function as an argument, call it via
pcall
, and in the case of an error, print the result.
Using this approach, tests for the factorial
function could look
like the following.
A slightly more complex example would be to create a test runner table to handle how to exit the test on failure.
This will use the same test
function but set a property
hasErrors
when a test fails. Via the
evaluate
function, called after all tests, a proper exit code and
status message can be emitted.
The same test suite for the factorial
function with this small
runner could look like the following.
Used as a base, one can already get quite far with this simple test runner, which can even be further extended.
For example, instead of directly calling defined test functions, gather them
all and run them when calling evaluate
. This would then enable
one to pretty print the test output or even
shuffle tests to ensure test isolation.
The LuaUnit module installed via LuaRocks is a very popular unit testing framework for Lua that comes packed with features.
LuaUnit needs to be added to the test
dependencies of the project. Dependencies defined under the test_dependencies
property in
the projects .rockspec
file will be
automatically installed when running
./luarocks test
.
The .rockspec
test definition also needs some adjustments, namely
running the entry test file with Lua directly to be able to pass command-line
options. As
I really like TAP
I will use it as the output format for all tests.
For LuaUnit tests are functions or tables of functions that
all start with the word test
or Test
and get
executed through the root test file.
Taking the example function from earlier, a
single test case can be created by defining a function starting with
Test
.
Multiple test cases can be organized or grouped in a table. This will increase readability when running the tests.
A growing test suite needs to be organized for better maintainability — splitting tests in multiple files can be one way. To enable this pattern, a test module needs to return the defined test table; the entry test file will then require all defined tests and execute them.
To showcase this, a new example function will be created.
The tests for this new example will be in a separate file, returning the local table with the test cases.
Same for the
factorial
tests, moving them into a
separate file and exporting the test table.
I like keeping tests close to the implementation, which is
why tests are in a file with the same name and the postfix
-test
in the same folder — having a
factorial-test.lua
test file for the
factorial.lua
implementation. Mind you, this is my personal
preference. Another typical pattern is having a single test folder containing
all test files.
Now with dedicated test files, the entry file will require all tests and run LuaUnit.
Running ./luarocks test
will execute the test suite.
LuaUnit provides
a way to call code before and after a set of grouped tests
— often called "setup" and "teardown" or
"beforeAll" and "afterAll" — via the special functions
setUp
and tearDown
.
Arguments passed to LuaUnit through ./luarocks test
should be
separated by --
. For example, using
LuaUnit's pattern option to select a subset of tests to run.
This will only execute tests matching the pattern TestFactorial
.
There are many ways to isolate code and replace external dependencies for testing, called mocking. In my time using Lua, I found no test-mock library that won my heart; instead, I use a combination of different techniques to mock code for testing.
Increasing testability should always be the first step, avoiding any workarounds to mock code altogether. Instead of accessing a dependency inside a function, pass it as an argument; initialize an object with needed dependencies; or make default values accessible to override via a function or property.
Here is an example of moving dependencies outside a function.
Another example is having a default dependency with the option to override it on object creation.
A basic mock can be anything that replaces a dependency in a chunk of code. What this value does or how it is shaped depends on the goal of the test; e.g., an empty function can be passed to skip or remove a call, check if a method actually got called, or simulate values on a table to fully isolate a test.
To showcase this, the following createUser
function will be
tested; the callback will be mocked.
The goal is to test if the user gets created successfully; therefore, an empty callback function is of no use. Only if the callback is called does the user get created.
One way to test this is to create a mock function that toggles a boolean when called and asserts the value.
Mocking a function or value exported by a module is best done inside LuaUnit's
setUp
and tearDown
functions. The exported function or value gets replaced with a mock in
setUp
, keeping a reference, and restoring the original value in
tearDown
.
As Lua keeps all
global variables in a table called _G
, the environment, global functions and values can be mocked for tests in the same way as
exported values.
To demonstrate this, the goal for the next example is to mock the
print
function and test if it has been called at least once.
Inside LuaUnit's setUp
a reference to the global print function
will be kept and restored inside tearDown
.
The actual test unit will define the mock function with a boolean to check if it has been called.
This is how the whole example looks.
Let's take the following scenario: a function to be tested has a dependency to a module added via LuaRocks. To properly test the function, the required module needs to be mocked.
To better visualize this, a function to retrieve an asset path from the user's system depends on the module lua-path.
The function getPath
needs to be tested, and the values
path.user_home
and path.DIR_SEP
mocked, to isolate
the test from the user environment.
As require
is a global function, it can be
mocked the same way as other global functions: by
storing a reference inside LuaUnit's setUp
and restoring it in
tearDown
.
Inside setUp
the global require
can be overridden,
listening for the dependency to be mocked, and
returning a mocked value in place. The
actualRequire
is used to get any non-mocked module.
The to-be-tested module will be required inside the test unit.
Requiring the code for testing inside the actual test needs to be done to
ensure the require
function is mocked first in
setUp
.
Here is the full example how to mock require
.
Tests should be run often, and adding continuous integration will help spot issues early. With a repository on GitHub, GitHub Actions is a convenient way to enable this.
I will use two amazing actions created by Leafo, leafo/gh-actions-lua and leafo/gh-actions-luarocks.
Creating a new workflow called test
, running on every push.
Defining the test job using the GitHub actions.
Finally, installing all dependencies with LuaRocks and
running the test suite. To run all tests, the environment
variable LUA_INIT
needs to be set with the path to the setup
file, letting Lua know where to find modules installed with LuaRocks.
The whole workflow file, enabling continuous execution of the test suite, looks as follows.
As said in the beginning, all the code shown in this article is also available in the companion repository on GitHub, branch part-3.
The next article will focus on debugging and profiling Lua code — really digging into fixing bugs, detecting performance bottlenecks, and even writing a small profiling tool.
Until then 👋🏻


Is there are any solution for such a constraint: for 2 integer Arrays of the same size x_i = x_j => y_i = y_j in other words, there is an integer function such x = f(y) -------------- next part -------------- An HTML attachment was scrubbed... URL: <http://www.gecode.org/pipermail/users/attachments/20170417/e9069afb/attachment.html>


Before Change
await self.set_backend_config(backend, backend_config)
// -- Metric Registration -- //
[metric_exporter] = retry_actor_failures(
master_actor.get_metric_exporter)
self.metric_client = MetricClient(metric_exporter)
self.num_router_requests = self.metric_client.new_counter(
"num_router_requests",
description="Number of requests processed by the router.",
After Change
serve.init(name=instance_name)
master_actor = serve.api._get_master_actor()
traffic_policies = ray.get(master_actor.get_traffic_policies.remote())
for endpoint, traffic_policy in traffic_policies.items():
await self.set_traffic(endpoint, traffic_policy)
backend_dict = ray.get(master_actor.get_all_worker_handles.remote())
for backend_tag, replica_dict in backend_dict.items():
for replica_tag, worker in replica_dict.items():
await self.add_new_worker(backend_tag, replica_tag, worker)
backend_configs = ray.get(master_actor.get_backend_configs.remote())
for backend, backend_config in backend_configs.items():
await self.set_backend_config(backend, backend_config)
// -- Metric Registration -- //
[metric_exporter] = ray.get(master_actor.get_metric_exporter.remote())
self.metric_client = MetricClient(metric_exporter)
self.num_router_requests = self.metric_client.new_counter(
"num_router_requests",
description="Number of requests processed by the router.",


VoiceBase's PCI and SSN detectors are based on machine learned models of real calls where both a caller and an agent are audible. This gives higher reliability and adaptability to real world situations than deterministic models, but also means that for accurate results the audio being processed for PCI, SSN, or PII detection must be real, not a test audio.
An actual phone order may reflect some amount of conversation, followed by a discussion of product and quantity, the agent giving a total, and finally a request for the card type and number, expiration date and possibly CVV code. This pattern of dialogue is the type of data the PCI and related detectors have been trained on.
If a customer creates a test audio that may only include numbers being read without the context that would typically trigger the model, the PCI will probably not be successfully detected.
The JSON transcript would be like the example below, where 'w' is the word or speaker, 'e' and 's' are timestamps, 'c' is confidence, 'p' is position in the transcript, and 'm' is metadata information ("turn" reserved for speaker switches). This is a simple transcript where the caller says hi, then the agent says hi.
{
"w": "caller",
"e": 5560,
"s": 5160,
"c": 1,
"p": 1,
"m": "turn"
},
{
"w": "Hi",
"e": 5560,
"s": 5160,
"c": 0.012,
"p": 2
},
{
"w": "agent",
"e": 5670,
"s": 5560,
"c": 0.828,
"p": 3
"m": "turn"
},
{
"w": "Hi",
"e": 5670,
"s": 5560,
"c": 0.012,
"p": 4
}
See more examples here.
Request an API key by signing up for access.
The API can accept urls to the media or the actual media as
form data attachments.
Our total list of accepted formats includes: *.mp3, *.mp4, *.flv, *.wmv, *.avi, *.mpeg, *.aac, *.aiff, *.au, *.ogg, *.3gp, *.flac, *.ra, *.m4a, *.wma, *.m4v, *.caf, *.cf, *.mov, *.mpg, *.webm, *.wav, *.asf, *.amr
Accepted - The file is successfully uploaded
Scheduled - The file is uploaded and is now in transcription queue
Running - The job is currently transcribing the audio file
Finished - The job is complete
Failed - The job has failed running
Callbacks are sent when a job's status reaches either 'Finished' or 'Failed'.


I write software for web and mobile. I founded a web design company, am the creator of Write.app and released MoonWeather for iOS & Android.


Beta This is a test version of the layout of this page. Take the survey to help us improve it
Guidance
This page contains information related to the 2015 to 2016 academic year. Please visit our student support page for the most up to date guidance.
Guidance to help provide free meals to disadvantaged 16 to 18 year old students in further education (FE) funded institutions.
This is departmental advice from the Education Funding Agency ( EFA ). This advice is non-statutory, and has been produced to help recipients understand their obligation to provide free meals to disadvantaged 16 to 18 year old students in further education (FE) funded institutions.
This advice relates to the 2015 to 2016 academic year.
Maintained school and academy sixth forms are already required by the Education Act 1996 to provide free meals to disadvantaged students who are aged over 16.
From September 2014, this requirement was extended to disadvantaged students following FE courses at the range of FE funded institutions. Funding agreements have been amended to place a legal duty on institutions to comply with this requirement. This guide is intended to support those institutions in providing, and administering, free meals in line with the requirement.
Allocations will be based on a lagged student number basis from the previous academic year
To be eligible for a free meal, students must be enrolled in further education provision funded via the Education Funding Agency at:
Students must be aged between 16 and 18 on 31 August 2015 to be eligible for a free meal in the 2015 to 2016 academic year. Students who turn 19 during their study programme will remain eligible for a free meal until the end of the academic year in which they turn 19 or to the end of their study programme, whichever is sooner.
Students aged 19 to 24 who are subject to a learning difficulty assessment (LDA) or education health and care plan (EHC plan) and ESF students aged between 16 and 18 on 31 August 2015 are also entitled to a free meal while attending their provision if they meet the eligibility criteria.
The following groups of student are not eligible for a free meal:
Free meals are targeted at disadvantaged students. For the purposes of eligibility for free meals, disadvantage is defined by the students being in receipt of, or having parents who are in receipt of, one or more of the following benefits:
A student is only eligible to receive a free meal when they, or a parent/guardian on their behalf, have made a successful application to the institution where they are enrolled see verification of student eligibility .
Feedback from institutions has indicated that there is some confusion about Working Tax Credit and whether children from families in receipt of it are eligible for free meals.
Working Tax Credit is not a qualifying benefit for free meals, and a parent or student in receipt of Working Tax Credits only (or contribution-based Job Seekers Allowance or Employment and Support Allowance) is not entitled to a free meal.
However, if a parent or student is in receipt of Working Tax Credit but is additionally in receipt of one of the entitling benefits listed in the student eligibility section, for example income support, they would then be entitled to a free meal. In other words, receipt of one of the qualifying benefits listed in the eligibility section essentially over-rides any additional benefits they may be in receipt of.
Students must also satisfy the residency criteria set out in the EFA Funding regulation guidance for the 2015 to 2016 academic year .
The student, or their parent/guardian, must submit an application to the institution where they are enrolled. Institutions should develop their own process for dealing with free meals applications. Some may wish to use a paper application form, whilst others may wish to provide an on-line application option.
As part of the application, institutions must ask the student (or their parent/guardian) to provide evidence of the award of the qualifying benefits set out in section student eligibility, for example an award notice or letter from the Department of Work and Pensions (DWP) or HMRC. Institutions may want to consider using a combined application form and process for free meals and the 16 to 19 Bursary.
In the 2014 to 2015 academic year, free meals funding was based on students being matched as previous recipients of free school meals at the age of 15 using the young people’s matched administrative dataset (YPMAD). In the 2015 to 2016 academic year, institutions will receive free meals funding based on lagged institution data.
A flag has been added to the individualised learner record ( ILR ) to record those students who are eligible for and in receipt of free meals funding. We will use this flag to determine the number of eligible students who claimed a free meal in the 2014 to 2015 academic year. This will provide a basis for the free meals allocations in the 2015 to 2016 academic year.
We have taken the proportion of free meals students in the R06 as at 1 November and applied this to the lagged student number to identify the number of fundable free meals students. For new institutions, we have used a local authority average to determine the potential number of students eligible for free meals.
We used the mode of attendance profile of each institution to determine how many of the potentially eligible students attend on either a full-time or part-time basis. Two rates have been applied, one for each of these categories, equivalent to £2.41 per student per meal.
Where institutions have not spent their 2014 to 2015 allocation, ie they reported zero eligible students, they will not receive an allocation for the 2015 to 2016 academic year. Institutions will be expected to use the unspent 2014 to 2015 funding to support eligible students in the new academic year.
If institutions do not have eligible students, they should contact the EFA to return their free meals allocation.
Free meals funding for the 2015 to 2016 academic year will be paid to institutions in two parts: approximately two thirds in September 2015 and up to one third in April 2016.
As institutions are already permitted to use up to 5% of their 16 to 19 Bursary Fund allocation for the administrative costs associated with verifying student eligibility (receipt of qualifying benefits, household income assess, etc); no further administrative contribution may be taken from the free meals funding allocation.
There will be no end of year reconciliation of free meals funding.
Institutions are required to make provision for free meals to eligible students (ie those who are in receipt of the qualifying benefits and who make a successful application for free meals) for each day that the student attends their study programme, where this is appropriate. To further illustrate this, for example, if a part time student attends for five days a week, 9am to 3pm, for part of their course, then the institution should provide five free meals. Similarly, if a full time student has two days a week when they only attend from 9am to 10am, then the institution does not have to provide meals on those days.
Institutions should encourage and support students in making healthy food choices and should also, where practical, seek to offer hot food options. Many caterers will be able to advise on suitable healthy options to offer students; further sources of information are provided in further information .
Institutions are expected to provide a meal free of charge to eligible students, or to fund the free meal via an electronic credit or voucher which can be redeemed on-site or off-site where institutions have made arrangements with nearby food outlets. Electronic credits and vouchers must be worth a minimum value of £2.41.
If an institution determines that it is necessary to enhance the £2.41 free meals funding rate, ie to provide a meal with a greater value, from the 16 to 19 Bursary Fund or other sources, they have the discretion to do so.
However, institutions must consider the value for money and reasonableness of such an enhancement to the £2.41 rate and must be able to justify this, particularly if they choose to make a significant variation from this amount.
Due to the specialist nature of provision within post-16 institutions, the cost of meals is sometimes included as part of the package of support that is agreed with local authorities. In these instances, institutions should deduct the appropriate amount of funding from the total costs of the package for those students who will be eligible for a free meal. This removes the issue of double funding and allows local authorities to utilise funds elsewhere.
The overwhelming majority of students will require a free meal at lunch time to fit in with usual study/attendance patterns. However, institutions may exceptionally choose to make provision for a free meal at an alternative time, for example, as a breakfast, depending on the study pattern of individual students.
Institutions must ensure that they also make free meals provision for students on days when they are off-site as part of their study programme, for instance attending a work placement or work experience. Wherever possible, institutions should provide a voucher that can be used at a nearby food outlet or make arrangements with the work placement or work experience provider to provide a meal.
The expectation is that a meal, voucher or credit will be provided to eligible students. However, this may not be practical in some situations. Institutions will therefore be permitted to offer cash in the following exceptional circumstances.
Where institutions assess there are particular and exceptional circumstances that fall outside these parameters, they have discretion to make cash payments where they assess that failing to do so will prevent an eligible student from being provided with a meal. Institutions must ensure they record any such decisions as part of their auditable records.
Institutions are best placed to make decisions in the case of students who have special dietary requirements, taking into account local circumstances. Institutions are expected to make reasonable adjustments for students with these requirements.
The school food plan’s UIFSM toolkit was developed to help schools implement universal free school meals for infant pupils, but it contains advice on how to cater for pupils with special dietary requirements, which may be helpful to institutions.
Institutions are only permitted to use the free meals funding allocated to them by the EFA to support students who meet the free meals criteria as set out in student eligibility .
As set out in the provision of free meals to students , if an institution determines that it is necessary to enhance the £2.41 free meals funding rate, ie to provide a meal with a greater value, from the 16 to 19 Bursary Fund or other sources, they have the discretion to do so.
However, if institutions choose to enhance free meals funding from the 16 to 19 Bursary Fund, they must ensure that they continue to provide sufficient support from that scheme to support students facing the range of barriers to participation (the cost of transport, books, equipment, etc). Free meals funding should not be enhanced to the detriment of these other needs.
Students who are eligible for a free meal may also receive additional support from the 16 to 19 Bursary Fund, if the institution assesses that they meet the criteria for a defined vulnerable group bursary or that they are facing significant financial barriers to participation and require additional support from their discretionary bursary allocation.
Institutions should, however, ensure that the provision of a free meal or the funding provided to the student for the free meal is considered when assessing their need for support – this point applies both to the vulnerable group bursary and discretionary bursary.
Equally, institutions may use discretionary bursary funds, as they can now, to provide meals to students who are not eligible for free meals as described in section student eligibility but for whom the absence of regular meals is providing a barrier to their participation and achievement.
Institutions are responsible for ensuring that their students are aware of the eligibility criteria for free meals and should encourage students who think they meet the criteria to make an application for a free meal.
Institutions should ensure that their free meal provision is clearly set out for students and parents, for example by publishing a statement on their website, providing information at enrolment days, sending letters home to parents, etc.
Students do better in their studies when they have access to proper, regular meals. Institutions are therefore encouraged to support students in the making of healthy food choices by making them aware of relevant information and guidance see further information .
Institutions must complete the free meal field in the ILR to provide information on the take up amongst the number of young people eligible for free meals. This data will be used to inform future allocations.
When completing the field, institutions must ensure that they only record students who are eligible and have taken up the free meal. Students who may have received funding for meals by means of a discretionary 16 to 19 Bursary Fund award should not be recorded in the free meals field. Students who receive Free School Meals (FSM) ie 14 to 15 year-olds, should continue to be reported in the existing field.
The ILR states that code FME2 should be recorded if the student is eligible for, and has taken up, free meals at any point during the academic year. If the student becomes ineligible during the year or is no longer receiving free meals, then this indicator should not be removed until the start of the following academic year.
This code should be recorded, where applicable, for EFA funded students aged 16 to 19, 19 to 24 year-old students who are subject to a LDA or EHC and ESF funded students aged between 16 and 18.
The EFA will analyse data returned by institutions via the ILR and generate future allocations on a lagged student number basis.
Institutions that do not complete the ILR but instead complete the School Census should complete the two free school meals fields.
Institutions should maintain accurate and up to date records that:
It is the responsibility of individual institutions to decide what evidence they accept and how recent it is. However, they must ensure they can evidence that only students who meet the eligibility criteria for free meals each year receive them. In any instances where institutions have used their discretion to make cash payments which are outside the specified criteria set out in this document, they must ensure these are recorded.
Administration and allocation of free meal funding will be subject to the institution’s normal governance and audit regimes. Free meals funding is also subject to assurance as part of the normal assurance arrangements for 16 to 19 education and training. Institutions should note that, following an audit, funding may be recovered where free meals payments are found to have been made where the student was ineligible for a free meal.
Further information about healthy eating to help with further education free meal provision is available from the following websites.
the Children’s Food Trust (formerly known as the School Food Trust) has produced guidance for schools, which institutions will also be able to use to help them set up a process for dealing with FE free meal applications. The ‘Free School Meals Matter Toolkit’, and a quick guide to free school meals are available at Children’s Food Trust
information about healthy eating, including recipes, is available at Change4Life and NHS


Issues
Black Lives Matter
Consent
Substance Abuse
About Us
❮
❯
Learn More
Perspectives
The amount of crime city has no correlation to the rate police officers kill people of any rate.
This article goes in-depth on the results of a GenForward poll about people's experience with police violence, in which most blacks reported they had been personally experienced harassment or violence by the police.
Although people have been protesting because of Michael Brown's death, police killings have not stopped since then. This article shows where other deaths have happened at the hands of the police.
Paris is the capital of France.


Little Hardwell (Credits: DBR.FM)
Hardwell was born in 1988 in Breda and began to orient himself on music in early years. At the age of 4 he took piano lessons for the first time and received a training at a music school. Already at the age of twelve, he produced his first own songs in the field of electro while he originally was active as a hip-hop-DJ. Through his participation in various competitions, he became a big name in Breda’s DJ-scene and had the chance to prove his abilities. One of his idols was the DJ and producer Tiësto, who also came from Breda, and made the jump into the upper EDM-scene in a similar way.
Through the change of hip-hop to an underground scene, Hardwell decided to change his genres to commercial electronic dance music. He started producing remixes and uploaded them on several platforms on the Internet. At the age of 14 Dutch producer duo Klubbheads listened to him and offered him a record deal with "Digidance". Three weeks later he made a first official release with the 2-disc-record "Bubbling Beats 1", whereupon he toured through the Netherlands and increased his performances to appearances in well-known clubs. His first official single "Play It Around" came out in 2006, and became a big hit in German clubs. The single featured a combination of different musical genres, which were popular at that point of time as well as his own style.
One of Hardwell's latest Concerts (Credits: edmchicago.com)
Hardwell is part of every big and small EDM and Electro festivals many times throughout the year in many and many countries, some of them are UMF, Tomorrowland and many more...
2016
2017
2017
Hardwell On Air Show (Credits: global-sets.com)
In March 2011 Hardwell started to present his own podcast "Hardwell On Air". This is a one-hour selection of songs by different artists. The podcast has developed into an internet success and the show now is broadcasting from Netherlands every Friday and is aired in over 50 radio stations worldwide such as Sirius XM's Electric Area in the United States and Grupo Radio Centro's XHFAJ-FM in México and has hundreds of thousands of listeners worldwide.
Musics played on HOA show are EDM, House, Progressive, Electro and even some Hardstyle. Be sure to check it out!
Revealed Logo
The label was established on 11 April 2010 by electronic music producer and DJ Hardwell. Revealed mainly focuses on big room house, dance, progressive house and electro house.
The label has had some success, including "Apollo" by Hardwell featuring Amba Shepherd, which peaked on No. 26 of the Dutch Top 40. Hardwell's 2014 single "Dare You" was also successful, entering the UK Singles Chart at No. 18. "Dare You" has also been used on adverts for television programs such as Strictly Come Dancing.
In 2015 Revealed launched a radio show called "Revealed Radio" with a different artist from the label as host each week, starting with Hardwell.[8] The label has over 200 track releases.
In 2016, Revealed released an acapella pack to celebrate six years of their establishment.
Some DJ artists that have released one or more songs with Revealed Recordings are: Hardwell, Afrojack, Blasterjaxx, Dannic, FireBeatz and much more...
Hardwell
Hardwell at Ultra
Hardwell at a Festival
Hardwell Style
Hardwell wins 6 IDMA awards on 2016 (Credits: EDM Sauce)
| Year | Awards | Category |
|---|---|---|
| 2012 | IDMA | Best Break-Trough DJ |
| 2013 | IDMA | Best Global DJ |
| IDMA | Best Remixer | |
| DJ Awards | Best Electro-House | |
| 2014 | DJ Awards | Best Electro House |
| MTV European Music Awards | Best Dutch Act | |
| IDMA | Best Global DJ | |
| IDMA | Best Progressive House/Electro DJ | |
| IDMA | Best Featured Vocalist Performance - Hardwell ft. Amba Shepherd-Apollo | |
| 2015 | IDMA | Best Global DJ |
| IDMA | Best Progressive House/Electro DJ | |
| IDMA | Best Electro/Progressive House Track - Hardwell & Joey Dale ft. Luciana-Arcadia | |
| IDMA | Best Compilation or Full Length DJ Mix - Hardwell Presents Revealed Volume 5 | |
| IDMA | Best Podcast or Radio Mixshow DJ - Hardwell - Hardwell On Air | |
| DJ Awards | Best International DJ | |
| DJ Awards | Best Electro/Progressive House | |
| 2016 | IDMA | Best Global DJ |
| IDMA | Best Progressive House/Electro DJ | |
| IDMA | Best Artist | |
| IDMA | Best Compilation or Full Length DJ Mix - Hardwell Presents Revealed Volume 6 | |
| IDMA | Best Podcast or Radio Mixshow DJ - Hardwell - Hardwell On Air | |
| IDMA | Best Featured Vocalist Performance - Hardwell feat. Jake Reese - Mad World | |
| DJ Awards | Best Big Room House DJ |
Want to Know More about this Awesome DJ? Want to Check his Biography? Maybe See his performed Sets in various Parties and Festivals?
Here are some Sources and References, where you can know more about Hardwell and his Music:


Focusing on women from mythology
Sudha Murthy’s new book for children contains 24 lesser-known stories
by Krupa JosephSudha Murthy launched a children’s book, ‘The Daughter from a Wishing Tree: Unusual Tales about Women in Mythology’, on November 14, marking the occasion of Children’s Day, at an event held at Crosswords, Malleshwaram.
This is the fourth installment to her mythology series, preceded by ‘The Serpent’s Revenge: Unusual Tales from the Mahabharata’, ‘The Man from the Egg: Unusual Tales about the Trinity’, and ‘The Upside-Down King: Unusual Tales about Rama and Krishna’.
The book contains 24 stories that focuses on the women in mythology.
Metrolife spoke to the author and entreprenuer, about her latest work.
What inspired you to write this book?
I felt that women are not represented properly. The sacrifices women make often go unnoticed. Mythology places the spotlight on men. Very few women, such as Sita and Draupadi, get attention. I thought that it was time to tell the stories of other women. These women have played a vital role in deciding the future of their families and lineage, and I wanted them to be recognised.
Why did you write this book for children?
This book is part of a series that I began writing because I thought it would be a great way for parents to initiate their children to the epics. The fifth and the last book will come out next year.
Do you prefer writing for adults or children?
I don’t know. I write whenever a story starts to brew in my mind. I don’t really think about who I am writing it for. I want to be able to share my knowledge, and that’s what I try to do with my books.
 Who is your favourite author?
It keeps changing depending on the stage of life I am at.
You left Telco in 1982 to help your husband start Infosys. You have since gone on to do different things, but do you miss engineering?
Not really. I am very invested in and very happy with the work I am doing now.
Does it bother you that despite all your work, many still refer to you as Narayana Murthy’s wife?
Along with every successful woman, there has to be an understanding husband. He has been that for me. I am not bothered by what others have to say. Is it not true that I am Narayana Murthy’s wife? My work is important, and I focus on that. I know what I am, the rest is unimportant.


| < Day Day Up > |
Hack 51 Get the Most Out of FTP
Get the most out of stock ftp with macros and scripts. In this age of GUIs and feature-rich browsers, it's easy to forget how quick and efficient command-line ftp can be. That is, until you're logged into a system that doesn't have X installed, nor a browser, nor any fancy FTP programs.  And, of course, you'll need to download something. Perhaps you find yourself using ftp all the time, always going to the same FTP servers and downloading from or uploading to the same directories. Clearly, it's time for some FTP automation. 5.11.1 Automating LoginsHave you ever noticed how easy it is to use FTP from a modern browser? Simply click on a hyperlink to start a download. At the command line, though, you can't even browse the FTP directory structure until you successfully log into the FTP server. Well, guess what: you always have to log into an FTP server. It's just that your web browser hides this little detail by doing it for you in the background. You can achieve the same transparency for command-line ftp by creating a file called .netrc in your home directory and placing the following line in that file: % more ~/.netrc default login anonymous password<EMAIL_ADDRESS>This line will work for any FTP server on the Internet that accepts anonymous logins. (Most do, unless it's a private server.) When creating your own file, use your own email address as the password. Test your change with this command: % ftp ftp.freebsd.org Compare your results to the FTP output in [Hack #71] . You should receive the same banner shown there without having to first type in a username and password. If you're a webmaster who uses FTP to upload your new files, you do have to log in first. After all, you don't want just anyone uploading files, so you require a username and password. To automate that process, add a section to your ~.netrc that reflects the name of your server and your username and password: machine ftp.myserver.com login myusername password mypassword Since you've just inserted your password into a plain text file, it's important to change the permissions on this file so that only you can read it: % chmod 600 ~/.netrc If you forget to change the permissions and try to access an FTP server that requires a username and password, your login attempt should fail and result in this error message: ftp: Error: .netrc file is readable by others. ftp: Remove password or make file unreadable by others. To be extra safe, exclude the password line completely. When you connect to the FTP server, your username will be provided for you, but you will still be prompted for the password. 5.11.2 Automating TransfersNow, let's say that you visit ftp.freebsd.org on a regular basis and always access its pub/FreeBSD/releases/i386 directory. Rather than cding every time, you can automate that process by creating an FTP macro. Add these lines to ~/.netrc: macdef fbsd bin cd /pub/FreeBSD/releases/i386 Macros are defined by macdef, and the name of the macro follows. Keep the name short but useful, as a macro is supposed to be a timesaver. Once you've declared the macro, add the FTP commands you want to execute, one line at a time. This particular macro contains the bin (or binary) command. That command is useful when downloading because it ensures all files, including non-ASCII files such as applications, will download correctly. I also included a cd command to automatically take me to my usual working directory.
There are two ways to use your macro. If you're already connected to the FTP server, type $ macroname at the ftp prompt: ftp> $ fbsd bin 200 Type set to I. cd /pub/FreeBSD/releases/i386 250 "/pub/FreeBSD/releases/i386" is new cwd. Note that each command in the macro will be executed, followed by its results. The second way to run the macro is when you first invoke the ftp command: % echo "$ fbsd" | ftp ftp.freebsd.org Now, if you try that one, you'll notice that all of your commands will succeed. Then, your FTP session will abruptly end, and you'll receive your regular prompt back! Rather disappointing if you were planning on typing some more commands at the ftp prompt, but absolutely perfect if your intention is to script an entire FTP session. 5.11.3 Scripting an Entire SessionIf you already know what you want to do, and especially if you need to do it more than once, why type in everything at the ftp prompt? Suppose you want to download the latest XFree86 distribution directly from ftp://ftp.xfree86.org/. Consider placing this macro in ~/.netrc: macdef X bin bell prompt cd /pub/XFree86/4.3.0/source mget * bye This macro assumes that this ~/.netrc file already contains the line that allows anonymous logins. The bell command, which is optional, should produce a sound after each successful file transfer. The prompt command is very important, though. By default, the FTP server expects interaction from the user. That is, when you ask to download multiple files with mget, the FTP server will wait for you to confirm every transfer by typing y. Obviously, we want to disable that behavior when we're scripting a download. To run this macro: % echo "$ X" | ftp ftp.xfree86.org By default, ftp will save the downloaded files in your current working directory. If you prefer, you can specify an alternate location in your macro with the lcd (local change directory) command. For example: lcd /usr/local/Xsource will save the downloaded files to the /usr/local/Xsource directory. Make sure your directory exists and put the lcd line before your mget line. 5.11.4 A Better FTP?No matter how hard you try to make the default FTP client user-friendly, it is still a very basic command, and you may find a little too primitive, especially if you use ftp often. If you would like to try a more convenient and user-friendly command-line tool, try ncftp, which is available as a port or package for FreeBSD, NetBSD, and OpenBSD. 5.11.5 See Also
|
| < Day Day Up > |


Real Time Communication with WebRTC and file transfer
Online Users
Enter Message to send to a user using Webrtc protocol
Enter User:
Enter Message:


Steven Dow, Blair MacIntyre, Jaemin Lee, Christopher Oezbek, Jay David Bolter, and Maribeth Gandy
A system also covered by the paper 7cad57c4be38dd89109c2544fee04b10 by the same authors.


About Login Filters
How to configure the Host Settings for Login Filters. Using login filters you can control which IP Addresses are allowed to login to your website. You can either Allow or Deny a single IP address or a range of addresses. You need to have selected the Enable IP address checking check box to be able to add new filters, See "Membership Management"
Adding a Login Filter
- Navigate to Host > Host Settings.
- Select the Advanced Settings tab.
- Expand the Login IP Filters section.
- Click the Add New Filter button.
- At Rule Specificity, select from these options:
- Single IP, this is the default option.
- In the First IP text box, enter the single IP to filter.
- IP Range
- In the First IP text box, enter the first IP to be used with the subnet mask to calculate a range of IP addresses.
- In the Mask text box, enter the subnet mask that will be combined with the first IP address to calculate a range of IP addresses for filtering.
- At Rule Type, choose whether to Allow users within that IP range to login or Deny login. Using Deny is a good way to restrict access to hackers.
- Click the Save button.
Editing or Deleting a Login Filter
How to edit or delete an existing login filter. Note:A rule that bans your current IP cannot be deleted.
- Navigate to Host > Host Settings.
- Select the Advanced Settings tab.
- Expand the Login IP Filters section.
- Click the Edit or the Delete button beside the login filter to be edited or deleted.


{% extends "layout.html" %} {% block content %}
| Device | Released | Initial | Latest | Supported | Siri Suggestions | ARKit 2 | Camera Effects | Memoji | Apple Pay Cash | Person to Person | Appointment Confirmation | ARKit | Hardware Decode H.265 | Encode in H.265 | Animoji | Rich Notifications | Ride-booking | Raise to Wake | Transit | PIP | Slide Over | Split View | Facedown | Apple Pay | Handoff | Instant Hotspot | Health | Phone Calls | SMS | AirDrop | Panorama | Camera Filters | Photos Filters | Camera Swipe | Flyover | Siri | Turn-by-Turn | Cellular FaceTime | Offline Reading List | Panorama |
|---|
Data provided by the Jailbreak Telegram community.
{% endblock content %} {% block ext %} {% endblock ext %}


logout
Create a new account
Username:
Password:
Container:
Accounts:
Username
Password
Container
Actions


A configurable component, such that its configuration can be saved when it is serialized and restored when deserialized.
SearchableRDD implementation using Lucene.
Lucene-based implementation of it.agilelab.bigdata.spark.search.Index
with global IDF support.
Lucene-based implementation of it.agilelab.bigdata.spark.search.Index
.
Created by m1lt0n on 29/02/16.
Implements SearchableRDD as an RDD of LuceneIndexedPartition