text:
Life & StyleLife
life-style, life, feedback organic recovery, hunter valley research foundation, david sivyer
Four years ago, David Sivyer found life was drawing him back to his parents' farm at the foot of the Barrington Tops. Like many farming businesses, the family was looking for opportunities to diversify. Working in hospitality management, Sivyer had witnessed huge amounts of organic material from restaurants and cafes being thrown away, literally going to waste. "It wasn't until I moved back to the farm that I put two and two together," he says. "Instead of using synthetic fertilisers we thought that, with a huge organic waste collection, we could potentially improve our soil by converting the organic waste [into compost]." Feedback Organic Recovery germinated from this simple idea. Sivyer began by collecting waste from cafes around Maitland and later, Newcastle, taking food waste and organic materials such as chefs' food prep waste, leafy greens, egg shells, paper and coffee grounds and manually turning them into compost at the family farm. But it wasn't long before he had almost more compost than he needed, so he began looking for other waste materials to work with, and new outlets for the compost.       Sivyer's business, Feedback Organic Recovery, has since evolved from organic waste collection and composting to include designing and installing urban gardens built from waste materials such as pallets and hessian, and leading workshops to teach these skills to adults and children. "It's totally focused on waste and the positive impact of being resource efficient," Sivyer says. "Now we're moving on to urban farming as well. "It just makes so much sense, using vacant urban land. We can completely close that food loop of collecting organic waste, converting it into compost, remediating the soil with the compost and growing local and seasonal produce that can go back to those cafes." Feedback Organic Recovery has been given temporary use of land in the grounds of the Hunter Valley Research Foundation in Maryville, where the pilot project urban farm crop is being planted.  A healthy mesclun mix of leafy greens, kale and cherry tomatoes will be the first crop.  A bee hive from Urban Hum will also be installed. For Sivyer, the next logical step is converting the business into a social enterprise and he's encouraging the community to get involved. To become part of the growing change he's inviting people to enlist Feedback to either set up urban farms in their backyards to become part of the urban farm plot, or pick up some skills by joining him and others at the urban farm in Maryville. Participants will help with seeding, transplanting, growing and harvesting. Head to feedbackorganic.com.au for more information. "The mission of Feedback is to repurpose waste in an environmentally sustainable, innovative and enjoyable fashion," Sivyer says. "The model I'm using is that any profit Feedback makes is reinvested into engaging the community with our human and environmental well-being in mind. "Some other ways for people to get involved include pallet workshops and kids creative workshops. "I think it's a no-brainer that others should be included in this. It's way too good of a life and I think that this should be replicated for others. If we can get more people involved it's only encouraging a great future in some way."
/images/transform/v1/crop/frm/37hLjTSaqSzzPeeWNnNkKKB/25bfc457-226c-47c7-ba71-3d4909080649.jpg/r125_0_1863_982_w1200_h678_fmax.jpg
October 6 2016 - 1:21PM
Feedback Organic Recovery: Urban farmer David Sivyer is leading by example
LOUISE FRASER
FORWARD THINKING: David Sivyer at the Hunter Valley Research Foundation in Maryville, where the pilot project urban farm crop is being planted. Picture: Chris Brown
Four years ago, David Sivyer found life was drawing him back to his parents' farm at the foot of the Barrington Tops.
Like many farming businesses, the family was looking for opportunities to diversify.
Working in hospitality management, Sivyer had witnessed huge amounts of organic material from restaurants and cafes being thrown away, literally going to waste.
"It wasn't until I moved back to the farm that I put two and two together," he says.
"Instead of using synthetic fertilisers we thought that, with a huge organic waste collection, we could potentially improve our soil by converting the organic waste [into compost]."
Feedback Organic Recovery germinated from this simple idea. Sivyer began by collecting waste from cafes around Maitland and later, Newcastle, taking food waste and organic materials such as chefs' food prep waste, leafy greens, egg shells, paper and coffee grounds and manually turning them into compost at the family farm.
But it wasn't long before he had almost more compost than he needed, so he began looking for other waste materials to work with, and new outlets for the compost.
Sivyer's business, Feedback Organic Recovery, has since evolved from organic waste collection and composting to include designing and installing urban gardens built from waste materials such as pallets and hessian, and leading workshops to teach these skills to adults and children.
"It's totally focused on waste and the positive impact of being resource efficient," Sivyer says.
"Now we're moving on to urban farming as well.
"It just makes so much sense, using vacant urban land. We can completely close that food loop of collecting organic waste, converting it into compost, remediating the soil with the compost and growing local and seasonal produce that can go back to those cafes."
Feedback Organic Recovery has been given temporary use of land in the grounds of the Hunter Valley Research Foundation in Maryville, where the pilot project urban farm crop is being planted. A healthy mesclun mix of leafy greens, kale and cherry tomatoes will be the first crop. A bee hive from Urban Hum will also be installed.
For Sivyer, the next logical step is converting the business into a social enterprise and he's encouraging the community to get involved.
To become part of the growing change he's inviting people to enlist Feedback to either set up urban farms in their backyards to become part of the urban farm plot, or pick up some skills by joining him and others at the urban farm in Maryville. Participants will help with seeding, transplanting, growing and harvesting. Head to feedbackorganic.com.au for more information.
"The mission of Feedback is to repurpose waste in an environmentally sustainable, innovative and enjoyable fashion," Sivyer says.
"The model I'm using is that any profit Feedback makes is reinvested into engaging the community with our human and environmental well-being in mind.
"Some other ways for people to get involved include pallet workshops and kids creative workshops.
"I think it's a no-brainer that others should be included in this. It's way too good of a life and I think that this should be replicated for others. If we can get more people involved it's only encouraging a great future in some way."
Feedback Organic Recovery will be presenting workshops for adults and children at Transition Newcastle's Fair Share Festival at Hamilton Public School on November 12 and 13. For more information visit feedbackorganic.com.au or transitionnewcastle.org.au/fair-share-festival-2016/
Discuss "Urban farmer is leading by example"
Shopkeeper assaulted during hold-up at Morpeth


Our Junior Suite is a very spacious room of 58 m2, decorated in a modern style, natural tones to guarantee the well-being and tranquility, with beautiful views of the Mediterranean Sea, as well as the Salins canal. The room is designed to offer all comforts and comfort, has a separate dressing room, a small living room, king size double bed (2m x 2.10m) ideal for a romantic stay.
Fully furnished terrace with a sofa, table and chairs to enjoy the views while having breakfast.
The bathroom equipped with a large rain shower and a whirlpool bath, separate toilet, professional hairdryer, bathrobe and slippers, bathroom accessory.


£ – Ladder Falls? - Compensation Claim Solicitor?
Can I Make a Compensation Claim for a Ladder Fall?
What are the Symptoms of a Ladder Fall Injury?
Is Tylers a No-Win, No-Fee Ladder Fall Compensation Claims Solicitor?
Where Can I Find Out More Information About a Ladder Fall Injury?
How Can I Make a Ladder Fall Compensation Claim?
How Long Do I Have to Claim Compensation for a Ladder Fall Injury?
Will Tylers Represent Me Following a Ladder Fall Injury?
Some jobs are more dangerous than others, that is a fact. For instance, construction jobs that require handling of heavy objects and have much risk of injuries due to dealing with dangerous tools, it can be potentially dangerous to the health of the worker.
In a case that you are the victim of an injury due to a ladder accident, you may have questions regarding your rights and on how to go about the process of securing your compensation for medical and other financial losses. Below are some of the questions answered to give you an overview of how a ladder fall compensation claim works.
Yes! If you have been the victim of an accident in the work place and the accident is a result of employer negligence, you can claim compensation for a ladder fall. It is recommended that the individual who is the victim files a claim for compensation immediately following the incident in order to make the process more efficient. Keep in mind that there are quite a few different possibilities in the cause of your ladder fall injury. These reasons include: ladder being held up at the wrong angle, ladder being too small, ladder having insufficient support, and the wrong type of ladder being used for a purpose. Because it is the responsibility of your employer to ensure your safety, it is your right to claim compensation for financial losses you have gone through after your fall.
Symptoms and other indicators that you may need medical attention after your fall are many. However, it is highly recommended that you get a medical check-up even without apparent medical abnormalities. This is because sometimes injuries incurred from a fall may be extremely dangerous, but with no noticeable symptoms. Also, how you fell from the ladder determines the types of symptoms and pains you will experience.
Some common symptoms include severe pain when moving certain body parts. The pain is especially heightened in the body part that landed first during the fall. If landed on the head, there is a good chance you have sustained a sort of head injury. You may experience persistent headaches and difficulty focusing.
Yes, yes, we are! We have great belief that our services and our lawyers are experienced enough with the legal process to get you the compensation that you deserve. And if we are not able to do so, we are glad to say that you will pay no fee.
Naturally, you will have many question regarding your fall and other legal processes require of you as you attempt to file and follow through with your ladder fall compensation claim. You can call Tylers Solicitors for more information regarding injury claims in general in the United Kingdom, ladder fall injury claims included. On our website you may find information about how to go about the process which includes the initial filing of the claim all the way to the final process of a court hearing and the compensation process. Other additional good and useful information that can be found on the site include how the compensation sum is calculated. From this information, you can know the precise amount to expect as compensation.
Immediately following your fall and your diagnosis, it is recommended you get in touch with a ladder fall injury compensation lawyer or solicitor who will take you through the process of making a legal claim. This process involves gathering important details about your fall that will point to the negligence of the responsible party. Through completing the Particulars of the Claim form, you gather and inform the solicitor of all the details surrounding your fall. The court will review your documents and inform the responsible party of your claim.
Because most types of compensation claims take quite a bit of time to be processed, it is recommended that you file and begin the process as soon as you can. This is because you want to avoid waiting too long after the accident. This usually result in loss of evidence, especially bodily harm and other financial losses incurred.
If you would like to make a compensation claim for a ladder falls case then call Tylers Solicitors today for a no-obligation chat on (freephone) 0800 699 0079 today!


Women of the Motor Corps didn't take narrow confines for an answer as they persevered into the broad expanse of roadways, delivering care and comfort during the chaos of World War I.
On June 21st, 1997, Lisa Leslie, center for the Los Angeles Sparks, and Kym Hampton, center for the New York Liberty, took the ceremonial "jump ball" marking the official start of the Women's National Basketball Association (WNBA).
A sector of women from the Puerto Rican elite arose to organize the Women Temperance Societies, despite women being silenced for centuries in their attempts for political participation.
Un sector de mujeres protestantes estableció en 1916 una serie de Ligas de Temperancia bajo el auspicio de la "Women Christian Temperance Union" y el liderazgo de Annie Robbins.
Monopoly's roots begin with a woman— a progressive named Elizabeth Magie.
The opportunity for a greater political voice drew African American women to the suffrage movement.
Colleges for women in the United States, founded in the second half of the 19th century, began as dangerous experiments.
Dr. Ellen Ochoa was the first female Hispanic astronaut. Recently, we sat down with her for a discussion about her career, the future of women in aeronautics, and inspiring future generations of women.
Women have long been part of a powerful history of military service, risking their lives for cause and country. Explore women's military history with these artifacts held by the Museum.
African American women were critically important in the creation and operation of contraband relief societies.
In the early 2000s, roller derby witnessed a revival, quickly becoming a popular sporting event and past time. Yet roller derby's history stretches back to over a century ago.
Explore some of the artifacts related to bridge the museum has in the collections.
The women of the Penn graduating class of 1964 were smart, talented, and self-confident women who came from the tops of their high school classes.
To find out how nursing today is different from nursing in the past, the Museum reached out to four nurses currently practicing in the field to hear about their experiences.
On April 14, 1861, Fort Sumter fell—the beginning of four years of brutal war. Thousands of women volunteered as nurses. By one estimate, more than twenty thousand women serves as nurses on the Union side during the war.
Asian American women have made a significant impact on the United States in a wide variety of fields. Despite facing both racial discrimination and sexism, these women stood strong, challenged stereotypes, and paved the way for future generations.


text:
Q: Tracking errors from z/os's syslog I need to reference the errors related to jobs present in the syslog.
Is it preferable to use messages from the ordonnancer e.g EQQE036I (TWS) or those from MVS e.g IEF451I, IEF452I etc ...

A: It depends: If there are TWS-specific errors you have to track them using the EQQ messages. Otherwise I'd go for the scheduler-independent and probably more detailed MVS messages.
And most of these messages haven't changed much in decades.

redpajama_set_name: RedPajamaStackExchange


text:
Upcoming on MBE and KCRW Presents
Written by Rachel Reynolds May. 14, 2010 Live Performances
Upcoming Live Performances on MORNING BECOMES ECLECTIC with host JASON BENTLEY
Friday, May 14, Flying Lotus is a renowned producer who launched a musical movement here in LA by expertly merging hip hop, psychedelic and dubstep sounds. He counts Thom Yorke among his many fans. Armed with his laptop, we'll feature a live performance and interview on Morning Becomes Eclectic at 11:15AM.
Wednesday, May 19, Shout Out Louds offer their peppy Swedish pop when they join Morning Becomes Eclectic fora live session and interview at 11:15am.
Thursday, May 20, Seattle's Minus The Bear have been making their way through the U.S. touring their polished, catchy songs. They'll stop by KCRW studios to perform songs from their newly minted release "Omni" on Morning Becomes Eclectic at 11:15am.
Friday, May 21, USA Today calls Scotland's Frightened Rabbit a "must-see act" and we'll get a chance to experience their anthemic, stadium-sized rock when they join Morning Becomes Eclectic for a live set at 11:15am.
Wednesday, May 26, Indie trio Nada Surf took on their favorite songs by other artists for their new album, dedicated entirely to covers. We'll hear what makes these songs special when they join us for a live session on Morning Becomes Eclectic at 11:15am.
Thursday, May 27, Fyfe Dangerfield first came to KCRW as a founding member of the avant-pop group the Guillemots and we've invited him back to share his extraordinary solo work. Hear his exuberant, love-drenched pop songs on Morning Becomes Eclectic at 11:15am.
Tuesday, June 1, KCRW DJs were early champions of garage rockers Black Rebel Motorcycle Club and our love affair with their music has never faltered. We welcome the band back to our studios to play songs from their new album — one of their best yet — on Morning Becomes Eclectic at 11:15am.
Wednesday, June 2, Three of LA's best singer-songwriters have teamed up to form the Living Sisters. Inara George of The Bird & The Bee, Becky Stark of Lavender Diamond and singer Eleni Mandell will harmonize on a beautiful set of songs on Morning Becomes Eclectic at 11:15am.
KCRW PRESENTS IN SOUTHERN CALIFORNIA
Sat, May 15, MEXICAN INSTITUTE OF SOUND at SOHO IN SANTA BARBARA.
Sun, May 16, SEA WOLF AT THE AUTRY MUSEUM.
Tues, May 18, The Moth Story Slam at the El Cid.
Tues, May 18, MASSIVE ATTACK AT THE WILTERN.
Wed, May 19, MASSIVE ATTACK AT THE WILTERN.
Wed, May 19, Caribou and special guest Toro Y Moi play the El Rey Theatre.
Wed, May 19, Julieta Venegas at Club Nokia.
Thurs, May 20, SHOUT OUT LOUDS AT THE EL REY THEATRE.
Thurs, May 20, MASSIVE ATTACK AT THE WILTERN THEATRE.
Thurs, May 20, EDWARD SHARPE AND THE MAGNETIC ZEROS AT UCLA'S ROYCE HALL.
Thurs, May 20, MINUS THE BEAR AT THE MAYAN.
Sun, May 23, FRIGHTENED RABBIT AT THE MUSIC BOX.
Tues, May 25, NADA SURF AT THE TROUBADOUR.
Wed, May 26, NADA SURF AT THE TROUBADOUR.
Tues, May 25, ANGUS AND JULIA STONE AT THE MASONIC LODGE AT THE HOLLYWOOD FOREVER CEMETERY.
Wed, May 26, ANGUS AND JULIA STONE AT THE MASONIC LODGE AT THE HOLLYWOOD FOREVER CEMETERY.
Fri, May 28, SIMIAN MOBILE DISCO (DJ SET) AT CONTROL AT THE AVALON.
Mon, May 31, The Moth Story Slam at Air Conditioned Lounge.
Wed, June 2, The Moth Grand Slam at the Echoplex.
Wed, June 2, The Living Sisters at The Hotel Café.
Wed, June 2, SCHOOL OF SEVEN BELLS AT THE ECHO.
Fri, June 4, FIRST FRIDAYS FEATURING PEANUT BUTTER WOLF AND NEON INDIAN AT THE NATURAL HISTORY MUSEUM.
Fri, June 4, LOCAL NATIVES AT THE TROUBADOUR.
Sun, June 6, THE XX AT THE WILTERN.
Wed, June 9, Hot Hot Heat at the Bootleg Theatre.
Fri, June 11, HENRY ROLLINS: FREQUENT FLYER TOUR AT LARGO AT THE CORONET.
Sat, June 12, HENRY ROLLINS: FREQUENT FLYER TOUR AT LARGO AT THE CORONET.
Sat, June 19, IMOGEN HEAP AT THE GREEK THEATRE.
Sun, June 20, KCRW's WORLD FESTIVAL FEATURES BAABA MAAL, YEASAYER, TINARIWEN, FOOL'S GOLD and PLAYING FOR CHANGE AT THE HOLLYWOOD BOWL.
Tues, June 22, Jo Hamilton at Hotel Café.
Tues, June 22, STARS AT THE TROUBADOUR.
Thurs, June 24, FAT FREDDY'S DROP AT THE MUSIC BOX AT THE HENRY FONDA.
Sat, June 26, SHARON JONES AND THE DAP KINGS AT THE WILTERN.
Sun, June 27, KCRW's WORLD FESTIVAL FEATURES GOLDFRAPP, ORQUESTA BUENA VISTA SOCIAL CLUB featuring OMARA PORTUONDO and TUNEYARDS AT THE HOLLYWOOD BOWL. Tom Schnabel hosts.
Sun, July 18, KCRW's WORLD FESTIVAL FEATURES THE SWELL SEASON, SHE & HIM AND THE BIRD AND THE BEE AT THE HOLLYWOOD BOWL. Liza Richardson and Chris Douridas host an evening of duets.
Mon, July 19, THE NEW PORNOGRAPHERS AT THE MUSIC BOX.
Sun, July 25, KCRW's WORLD FESTIVAL BRINGS REGGAE NIGHT IX FEATURING JIMMY CLIFF, SLY & ROBBIE, AND TARRIS RILEY AT THE HOLLYWOOD BOWL. Jeremy Sole hosts.
Thurs, August 12, My Morning Jacket at the Greek.
Sat, August 14, SEU JORGE AT CLUB NOKIA.
Wed, August 18, Rodrigo y Gabriela at The Greek.
Sun, August 29, KCRW's WORLD FESTIVAL FEATURES THE CHEMICAL BROTHERS, CHROMEO AND YACHT AT THE HOLLYWOOD BOWL. Jason Bentley hosts.
Sept 10, 11, and 12, KCRW is Media Sponsor for the FIREWORKS FINALE AT THE HOLLYWOOD BOWL featuring PINK MARTINI.
Sun, September 19, KCRW's WORLD FESTIVAL BRINGS VIVA MEXICO! FEATURING CALEXICO, OZOMATLI, LOS SUPER SEVEN, MEXICAN INSTITUTE OF SOUND, MARIACHI REYNA LOS ANGELES AND GRANDEZA MEXICANA FOLK BALLET COMPANY AT THE HOLLYWOOD BOWL. Raul Campos hosts.
Mon, September 27, The Black Keys at the Hollywood Palladium.

redpajama_set_name: RedPajamaCommonCrawl


Achieving the ideal assessment flow depends on a holistic solution that connects your data. A fully integrated platform, for instance, can allow for assessment and grading to occur simultaneously. Rubric assessment data can then be shared across multiple faculty and aggregated to demonstrate student performance outcomes across multiple courses throughout a program. To learn more, fill out the form to the right and download the informational PDF.


'' 978-0-13-327423-3 Connected Mathematics 3. Teacher Resources Grade 7. 9780133274233, 0133274233.
'' 978-0-13-327426-4 Phillips, Fey, Friel Lappan Connected Mathematics 3. Teacher Resources Grade 7, for 8 Units. 9780133274264, 0133274268.
1995 978-0-13-327545-2 Food Container Corrosion $$$ Wiese et al.
2014 978-0-13-327813-2 Connected Mathematics 3. CMP3, Grade 7. 9780133278132, 0133278131.
2014 978-0-13-327871-2 Connected Mathematics 3. ExamView Test Bank CD-ROM. Grades 6-8 & Algebra 1. 9780133278712, 0133278719.
2013 978-0-13-327872-9 Connected Mathematics 3. Teacher Lesson Support CD-ROM. Grade 6. 9780133278729, 0133278727.
2013 978-0-13-327873-6 Connected Mathematics 3. Teacher Lesson Support CD-ROM. Grade 7. 9780133278736, 0133278735.
'' 978-0-13-327874-3 Connected Mathematics 3. Teacher Lesson Support CD-ROM. Grade 8 & Algebra 1. 9780133278743, 0133278743.
2014 978-0-13-327876-7 Connected Mathematics 3. Teacher Lesson Support DVD. Grade 6. 9780133278767, 013327876x.
'' 978-0-13-327877-4 Connected Mathematics 3. Teacher Lesson Support DVD. Grade 7. 9780133278774, 0133278778.
'' 978-0-13-327878-1 Connected Mathematics 3. Teacher Lesson Support DVD. Grade 8 & Algebra 1. 9780133278781, 0133278786.


text:
A Baptism of Fire
'As it gets harder to sell pictures, we take greater and greater risks,' explains Corentin Fohlen. A war correspondent still in his twenties, Fohlen is part of a new generation of freelance journalists who fly to war zones from Libya to Afghanistan on their own dime in the hope of selling images to news media outlets.
But the carefree attitude of youth can change when confronted with the harsh reality of life in wartime. When a colleague is killed in Syria, Fohlen's thirst for adventure turns into a deeper reflection on the meaning of work and life. Director Clement-Wilz followed Fohlen through shells and bullets for four years in order to create this riveting portrait of the life of a contemporary war correspondent.
'Risk your life to show the conflict and suffering of the world? This original documentary testifies to the passion of a photojournalism: Corentin, not yet 30-years-old, has already spent six years in the business. From the chaos of Cairo to Homs, from Haiti to Libya, we see him at work, equipped with a helmet, gas mask and bulletproof vest.' - Le Monde
'A young photographer's first wartime experiences are documented in A Baptism of Fire. Shot on the ground, in the heart of danger, the film exposes raw emotion, pain, reflection and laughter.' - Les Inrocks
'One of the best documentaries of all time. [Director Jerome Clement-Wilz] follows his friend through shells of bullets to bring to light the daily lives of these news junkies.' - Vanity Fair, France
Clément-Wilz, Jérôme (film director)
Fohlen, Corentin (performer)
Caza, Jérôme (film producer)
Epale, Charlotte (film producer)
Jérôme Caza, Charlotte Epale, producers.
Journalism and the Press
Politics and Political Science
photography; war photographer; photo-journalist; middle east; arab spring; "A Baptism of Fire"; Icarus Films; Corentin Fohlen; Syria;
Distributor: Icarus Films
Language: French / English subtitles
Included in Collections: The Icarus Films Collection, The Docuseek2 Essential Collection, The Docuseek2 Complete Collection 2nd Edition


I specialize in Making Technology Work For People, so it's logical that I write about technology. I also write about marketing and customer service, because I've seen both done so well and so poorly.
See what the site is About, use the Contact form to share suggestions or comments, or head straight to the Blog posts.


text:
Home Innovation Services & Software Operating Systems Windows
You are the computer
Way back when, computers were people. Problems were broken up into lots of little pieces, and shared across a room full of mathematicians armed with logarithmic tables, Napier's Bones, slide rules and the like.
Written by Simon Bisson, Contributor and Mary Branscombe, Contributor on May 8, 2012
Way back when, computers were people. Problems were broken up into lots of little pieces, and shared across a room full of mathematicians armed with logarithmic tables, Napier's Bones, slide rules and the like. That way codes were analysed, paths plotted, and ballistic tables computed, ready to simplify the art of war. No one person knew the answer to the problem, they just had their little part of it, ready to deliver and add to the corpus that would become the final answer.
People still are computers, and the underlying concept carries across to ideas like Amazon's Mechanical Turk, where problems can be spread across many thousands of users, parallelising complex tasks. It's an approach that can help analyse air sea rescue photographs, or run art projects that simulate artificial intelligence. There's also something similar that happens when a problem goes viral across a social network. Names and addresses can be found as minor connections expand across the world, people identified, property returned.
This new networked society we're building is a strange creature, full of emergent properties that come from millions of eyes and millions of typing, touching and clicking fingers. We're still finding it hard to understand, believing that a literal camera that describes what it photographs to be the product of advanced artificial intelligence rather than the result of a person somewhere looking at a screen, typing a description and earning a handful of pennies. Sometimes the most advanced technology really is indistinguishable from the kind of magic we used to see on Saturday night variety shows that were broadcast from big tops on West Country beaches.
Perhaps we need to remain wary, ready to ask just why we're being asked the questions where being asked, why we're playing the games we're playing. Is that alternate reality game really marketing the latest Bond movie, or are you acting as the eyes and ears of an anonymous intelligence agency a thousand miles away or more? After all, there's no one less suspicious than someone who believes truly they're only playing a game…
Sure, you might say, that would never happen to me.
But it already is, in a way. Each time you fill in a reCAPTCHA form to access a website or post a blog comment you're helping train the OCR engines at Google as they digitise books. The pair of words is there for a reason, one is a known, already recognised, piece of text that helps calibrate your response on the unknown text. But it's not just books you're helping digitise – you're also helping Google match the houses its streetside photography system has captured with the addresses in its mapping database.
Sometimes you'll get a reCAPTCHA form that looks like this:
Instead of text from a book, you're getting a section of a photograph with a number. Identify the number, and you're just part of the computer, helping match house and address, making it easier for Google to display the right picture when someone looks for a particular address. It's a problems that computationally very hard, but now all Google needs to do is identify something that might be a number, deliver to one of the many millions using reCAPTCHA, and if identified, use the result. If its unidentifiable, the user will just refresh the form and a new image will be delivered, ready for identification.
You didn't notice, and you weren't paid, but you were part of an algorithm, part of the machine. For the moment between looking at the image, filling in the form, and clicking submit, you were the computer.
Welcome to the machine. We're so glad you're here.
Simon Bisson
This 1980s computer was a huge leap forward. Now you can download its source code
Ransomware has now become a problem for everyone, and not just tech
The best AI writers: ChatGPT and other interesting alternatives to try


With four controlled burns the week before the seminar and a flashover burn demonstration the day before, we are literally burning down the house to make this an exciting and relevant seminar. It will take fire science and litigation techniques into the real world, using photographs, video, and data from controlled burns, incorporating them into presentations about fire behavior, fires involving products found in home and office environments, and trial tactics to manage technical and graphic evidence. This seminar is for new and experienced attorneys and will help with every fire case on your docket.


Tesco isn't normally the place you head to get mobile phone exclusives, but if you want the new Motorola Motoluxe in white that's exactly where you will be heading.
The new phone is available in Tesco Phone Shops and online through Tesco Direct in the UK from today, priced free from £20 a month on Tesco Mobile.
"We are dedicated to offering great value and choice to our customers and we see the Motoluxe as one of the must have handsets of the summer," said Tesco Mobile, forgetting briefly about all the other phones available on the market.
Meanwhile Motorola believes the new phone "offers even more choice to UK fashionistas".
Pocket-lint editor Chris Hall isn't so sure: "If you are looking for an Android smartphone that won't break the bank, then the Motorola Motoluxe is well worth consideration," he says.
The white Motorola Motoluxe is available now.


text:
<?php

// ::carousel.html.twig
return array (
);

redpajama_set_name: RedPajamaGithub


We service the entire state of Oklahoma including the Wagoner area and can help you with and answer your questions about Generac Generators Near Me for residential and commercial use. Service, repair and installation - we do it all!
Generators are extraordinary machines that allow you to continue with your life when everybody else is waiting for the power to come back on. This is especially true if you reside in our storm-prone state. Power can be out for days or weeks due to the damage brought on by one of these disasters. Having an extra resource of electric power offers satisfaction, security, comfort, and benefits for your family members at home or your employees and clients at the office.
We advise contacting us directly for the very best solution to your inquiry regarding Generac Generators Near Me. Our service area in Oklahoma is quite extensive and we have installed and serviced generators from one end of the state to the other - even Wagoner!
When you call us, you can also be guided to our support teams that know your model and can supply you with the technological specs or information that you require to keep your unit running in tip top shape. From circuitry to batteries to oil types, you can be assured that when you call us, you will find the most current information and assistance offered anywhere.
If you are thinking about buying a new standby generator and getting it set up at your house or business property, there are very good reasons why you should purchase the generator from a licensed Generac dealer like us and not a big box store.
First, a regional dealership will be around to help you with service after the sale. On the other hand, you never ever know who you will get when you call a retailer and finding the exact same contractor might be tough.
Second of all, dealerships know of the current promotions and discount rate programs available. Also vital, dealing with a neighborhood Generac supplier means that you won't experience any warranty problems that could develop if a non-authorized installer is employed to install your generator.
Call us today for help with your Generac Generators Near Me questions in Wagoner, OK.


text:
Oscar Pistorius denies murdering girlfriend after tearful court appearance
Metro News Reporter and Mark MolloyFriday 15 Feb 2013 2:38 pm
In tears: Paralympic sprinter Oscar Pistorius (Picture: EPA)
Blade runner Oscar Pistorius has denied murdering his girlfriend in the 'strongest terms' in a statement issued through his family and management company.
The Paralympic star was formally charged with the murder of model Reeva Steenkamp, 30, earlier today after she was found dead at his home in Pretoria after being shot in the head and upper body.
'The alleged murder is disputed in the strongest terms,' the statement read.
Pistorius talks to his father in court (Picture: Reuters)
'He [Pistorius] has made it very clear that he would like to send his deepest sympathies to the family of Reeva.
'He would also like to express his thanks through us today for all the messages of support he has received.
'Our thoughts and prayers today should be for Reeva and her family – regardless of the circumstances of this terrible, terrible tragedy.'
Oscar Pistorius weeps in court in (Picture: AP)
The 26-year-old left a police station with a coat over his head early this morning amid a media frenzy.
He broke down in tears and held his head in his hands as the charge of murder, which prosecutors say was pre-meditated, was read out in the city's magistrates' court.
The runner was remanded in custody after an application for bail was postponed until next week.
Pistorius's brother Carl in court (Picture: AP)
There will be no live media coverage of the bail hearings, with the star's lawyers opposing the measure, citing their client's 'extremely traumatised state of mind'.
It was originally reported that Pistorius might have mistaken his model lover for a burglar, but Brigadier Denise Beukes later said police were 'very surprised' by that suggestion, adding: 'These allegations did not come from us.'
Pistorius is led to the court hearing (Picture: AP)
There had been previous incidents of a "domestic nature" at the property on the exclusive, gated Silver Lakes Golf Estate in the South African capital Pretoria, she added.
A 9mm pistol was recovered and, according to unconfirmed reports, four shots were fired through a bathroom door.
Oscar Pistorius was one of the stars of the London 2012 Paralympics (Picture: PA )
Police spokeswoman Lieutenant Colonel Katlego Mogale said: 'Paramedics declared the woman dead on the scene and police proceeded with their investigation.
'The woman sustained wounds to her head and the upper body.'
Police said an application for bail by Pistorius's lawyer Kenny Oldwage would be opposed.
Dressed in a grey hooded jacket, tracksuit trousers and trainers, the man known as Blade Runner for his prosthetic legs, walked with head bowed from Boschkop police station yesterday before being taken to Pretoria's Mamelodi Day Hospital in a police convoy.
Ms Beukes said the medical examination was 'standard procedure'.
Pistorius's spokesman, from the Fast Track agency in London, said he was 'assisting the police with their investigations' but no further comment could be made until matters became clearer.
The couple had only been going out since November and Steenkamp, a model and law graduate, tweeted the day before Valentine's Day: 'What do you have up your sleeve for your love tomorrow??? #getexcited #ValentinesDay.'
A picture taken on January 26, 2013 of Pistorius and Reeva Steenkamp at Melrose Arch in Johannesburg.(Picture: AFP/Getty Images)
On her Twitter biography, Steenkamp described herself as a 'Model, Cover Girl, Tropika Island Of Treasure Celeb Contestant, Law Graduate, Child of God'. Tropika Island Of Treasure is a TV show she was due to appear on this weekend.
Pistorius appeared to have serious concerns about his safety and was said to sleep with a revolver by his side.
Oscar Pistorius and Reeva Steenkamp pictured last November (Picture: AFP/Getty)
The athlete made history at the London 2012 Olympics by becoming the first amputee sprinter to compete in the able-bodied Games, running in the 400m and 4x400m relay.
In the dock: Oscar Pistorius (Picture: EPA)
Oscar Pistorius with Reeva Steenkamp (Picture: AFP/Getty)
Oscar Pistorius seen with his head in his hands whilst sitting in court after being charged with murder of his girlfriend Reeva Steenkamp
Oscar Pistorius seen with his head in his hands whilst sitting in court after being charged with murder of his girlfriend Reeva Steenkamp (Picture: Reuters)
Kenny Oldwage, lawyer to Oscar Pistorius leaves Boschkop Police Station on February 14, 2013 in Pretoria, South Africa. Oscar Pistorius was taken to hospital for a blood test, prior to his appearance at court. He was arrested following a shooting at his residence on the morning of February 14, 2013
Oscar PistoriusReeva Steenkamp
France reveals terrifying armed soldier who flies above Paris on hoverboard
Teacher Brittany Zamora, 28, who had sex with boy, 13, while his pal watched gets 20 years jail
Baby's corpse left in 'unspeakable' condition after parents aged 17 and 25 'battered her to death'
Home › News › World


text:
#include <cstdlib>
#include <cstring>
#include <sstream>
#include <iostream>
#include <string>
#include "v8.h"
#include "v8_wrap.h"

extern "C" {

#include "_cgo_export.h"

using namespace v8;

#define ISOLATE_SCOPE(isolate_ptr) \
	Isolate* isolate = isolate_ptr; \
	Locker locker(isolate); \
	Isolate::Scope isolate_scope(isolate) \

#define ENGINE_SCOPE(engine) \
	V8_Context* the_engine = static_cast<V8_Context*>(engine); \
	ISOLATE_SCOPE(the_engine->GetIsolate()) \

#define CONTEXT_SCOPE(engine) \
	V8_Context* the_context = static_cast<V8_Context*>(engine); \
	ISOLATE_SCOPE(the_context->GetIsolate()) \

#define VALUE_SCOPE(value) \
	V8_Value* the_value = static_cast<V8_Value*>(value); \
	ISOLATE_SCOPE(the_value->GetIsolate()); \
	Local<Value> local_value = Local<Value>::New(isolate, the_value->self) \

#define OBJECT_TEMPLATE_SCOPE(tpl) \
	V8_ObjectTemplate* the_template = static_cast<V8_ObjectTemplate*>(tpl); \
	ISOLATE_SCOPE(the_template->GetIsolate()); \
	Local<ObjectTemplate> local_template = Local<ObjectTemplate>::New(isolate, the_template->self) \

#define OBJECT_TEMPLATE_HANDLE_SCOPE(tpl) \
	V8_ObjectTemplate* the_template = static_cast<V8_ObjectTemplate*>(tpl); \
	ISOLATE_SCOPE(the_template->GetIsolate()); \
	HandleScope scope(isolate); \
	Local<ObjectTemplate> local_template = Local<ObjectTemplate>::New(isolate, the_template->self) \

#define FUNCTION_TEMPLATE_SCOPE(tpl) \
	V8_FunctionTemplate* the_template = static_cast<V8_FunctionTemplate*>(tpl); \
	ISOLATE_SCOPE(the_template->GetIsolate()); \
	Local<FunctionTemplate> local_template = Local<FunctionTemplate>::New(isolate, the_template->self) \

#define FUNCTION_TEMPLATE_HANDLE_SCOPE(tpl) \
	V8_FunctionTemplate* the_template = static_cast<V8_FunctionTemplate*>(tpl); \
	ISOLATE_SCOPE(the_template->GetIsolate()); \
	HandleScope scope(isolate); \
	Local<FunctionTemplate> local_template = Local<FunctionTemplate>::New(isolate, the_template->self) \

#define PREV_CONTEXT_SLOT 1

class V8_Context {
public:
	V8_Context(Isolate* isolate, Handle<Context> context) {
		isolate_ = isolate;
		self.Reset(isolate_, context);
	}

	V8_Context(V8_Context* engine, Handle<Context> context) {
		isolate_ = engine->GetIsolate();
		self.Reset(isolate_, context);
	}

	~V8_Context() {
		Locker locker(isolate_);
		Isolate::Scope isolate_scope(isolate_);

		self.Reset();
	}

	Isolate* GetIsolate() {
		return isolate_;
	}

	Isolate* isolate_;
	Persistent<Context> self;
};

class V8_Script {
public:
	V8_Script(V8_Context* the_engine, Handle<UnboundScript> script) {
		engine = the_engine;
		self.Reset(engine->GetIsolate(), script);
	}

	~V8_Script() {
		ISOLATE_SCOPE(GetIsolate());
		self.Reset();
	}

	Isolate* GetIsolate() {
		return engine->GetIsolate();
	}

	V8_Context* engine;
	Persistent<UnboundScript> self;
};

class V8_FieldOwnerInfo {
public:
	V8_FieldOwnerInfo(void* e, int64_t o) : engine(e), ownerId(o) {

	}

	void*   engine;
	int64_t ownerId;
};

void FieldOwnerWeakCallback(const WeakCallbackData<Value, V8_FieldOwnerInfo> &data) {
	V8_FieldOwnerInfo* info = data.GetParameter();
	go_field_owner_weak_callback(info->engine, info->ownerId);
	delete info;
}

class V8_Value {
public:
	V8_Value(V8_Context* the_context, Handle<Value> value) {
		isolate_ = the_context->GetIsolate();
		self.Reset(isolate_, value);
		context_handler.Reset(isolate_, the_context->self);
		fieldOwnerInfo = NULL;
	}

	~V8_Value() {
		Locker locker(isolate_);
		Isolate::Scope isolate_scope(isolate_);

		if (fieldOwnerInfo == NULL) {
			self.Reset();
		} else {
			self.SetWeak<V8_FieldOwnerInfo>(fieldOwnerInfo, FieldOwnerWeakCallback);
		}
		context_handler.Reset();
	}

	Isolate* GetIsolate() {
		return isolate_;
	}

	Isolate*            isolate_;
	Persistent<Value>   self;
	Persistent<Context> context_handler;
	V8_FieldOwnerInfo*  fieldOwnerInfo;
};

typedef struct V8_ReturnValue {
	V8_ReturnValue(V8_Context* the_context, ReturnValue<Value> the_value) :
		context(the_context),
		value(the_value) {
	}

	V8_Context*        context;
	ReturnValue<Value> value;
} V8_ReturnValue;

class V8_ObjectTemplate {
public:
	V8_ObjectTemplate(V8_Context* the_engine, Handle<ObjectTemplate> the_template) {
		engine = the_engine;
		self.Reset(engine->GetIsolate(), the_template);
	}

	~V8_ObjectTemplate() {
		Locker locker(GetIsolate());
		Isolate::Scope isolate_scope(GetIsolate());

		self.Reset();
	}

	Isolate* GetIsolate() {
		return engine->GetIsolate();
	}

	V8_Context* engine;
	Persistent<ObjectTemplate> self;
};

class V8_FunctionTemplate {
public:
	V8_FunctionTemplate(V8_Context* the_engine, Handle<FunctionTemplate> the_template) {
		engine = the_engine;
		self.Reset(engine->GetIsolate(), the_template);
	}

	~V8_FunctionTemplate() {
		Locker locker(GetIsolate());
		Isolate::Scope isolate_scope(GetIsolate());

		self.Reset();
	}

	Isolate* GetIsolate() {
		return engine->GetIsolate();
	}

	V8_Context* engine;
	Persistent<FunctionTemplate> self;
};

void* new_V8_Value(V8_Context* context, Handle<Value> value) {
	if (value.IsEmpty())
		return NULL;
	return (void*)new V8_Value(context, value);
}

/*
engine
*/
void* V8_NewEngine() {
	//V8::InitializeICU();

	ISOLATE_SCOPE(Isolate::New());

	HandleScope handle_scope(isolate);
	Handle<Context> context = Context::New(isolate);

	if (context.IsEmpty())
		return NULL;

	context->Enter();

	return (void*)(new V8_Context(isolate, context));
}

Isolate* DisposeEngineStep1(V8_Context* the_engine) {
	ISOLATE_SCOPE(the_engine->GetIsolate());

	// Error: "Cannot exit non-entered context"
	// See V8_NewEngine(), the context->Enter() invoked.
	// Why ?!!!
	//
	// HandleScope handle_scope(isolate);
	// Local<Context> local_context = Local<Context>::New(isolate, the_engine->self);
	// local_context->Exit();

	delete the_engine;

	return isolate;
}

void V8_DisposeEngine(void* engine) {
	V8_Context* the_engine = static_cast<V8_Context*>(engine);
	Isolate* isolate = DisposeEngineStep1(the_engine);
	isolate->Dispose();
}

void* V8_ParseJSON(void* context, const char* json, int json_length) {
	CONTEXT_SCOPE(context);

	Handle<Value> value = JSON::Parse(
		String::NewFromUtf8(isolate, json, String::kInternalizedString, json_length)
	);

	if (value.IsEmpty())
		return NULL;

	return new_V8_Value(the_context, value);
}

void V8_ForceGC(void* engine) {
	V8_Context* the_engine = static_cast<V8_Context*>(engine);
	ISOLATE_SCOPE(the_engine->GetIsolate());

	while(!isolate->IdleNotification(100)) {};
}

/*
context
*/
void* V8_NewContext(void* engine, void* global_template) {
	V8_Context* the_engine = static_cast<V8_Context*>(engine);

	ISOLATE_SCOPE(the_engine->GetIsolate());

	HandleScope handle_scope(isolate);
	Handle<Context> context = Context::New(
		isolate, NULL,
		global_template == NULL ? Handle<ObjectTemplate>() : Local<ObjectTemplate>::New(
			isolate, static_cast<V8_ObjectTemplate*>(global_template)->self
		)
	);

	if (context.IsEmpty())
		return NULL;

	return (void*)(new V8_Context(the_engine, context));
}

void V8_DisposeContext(void* context) {
	delete static_cast<V8_Context*>(context);
}

typedef struct scope_data {
	void* context;
	void* context_ptr;
} scope_data;

void V8_Context_Scope(void* context, void* context_ptr, void* callback) {
	V8_Context* ctx = static_cast<V8_Context*>(context);
	ISOLATE_SCOPE(ctx->GetIsolate());

	void* prev_context = isolate->GetData(PREV_CONTEXT_SLOT);
	scope_data data;
	data.context = context;
	data.context_ptr = context_ptr;
	isolate->SetData(PREV_CONTEXT_SLOT, &data);

	// Make nested context scropt use the outermost HandleScope
	if (prev_context == NULL) {
		HandleScope handle_scope(isolate);
		Context::Scope scope(Local<Context>::New(isolate, ctx->self));
		go_context_scope_callback(context_ptr, callback);
	} else {
		Context::Scope scope(Local<Context>::New(isolate, ctx->self));
		go_context_scope_callback(context_ptr, callback);
	}

	isolate->SetData(PREV_CONTEXT_SLOT, prev_context);
}

V8_Context* V8_Current_Context(Isolate* isolate) {
	void* data = isolate->GetData(PREV_CONTEXT_SLOT);
	if (data == NULL)
		go_panic((char*)"Please call this API in a context scope");
	return static_cast<V8_Context*>(static_cast<scope_data*>(isolate->GetData(PREV_CONTEXT_SLOT))->context);
}

void* V8_Current_ContextPtr(Isolate* isolate) {
	void* data = isolate->GetData(PREV_CONTEXT_SLOT);
	if (data == NULL)
		go_panic((char*)"Please call this API in a context scope");
	return static_cast<scope_data*>(isolate->GetData(PREV_CONTEXT_SLOT))->context_ptr;
}

void* V8_Context_Global(void* context) {
	CONTEXT_SCOPE(context);
	Local<Context> local_context = Local<Context>::New(isolate, the_context->self);
	return new_V8_Value(the_context, local_context->Global());
}

// Extracts a C string from a V8 Utf8Value.
const char* ToCString(const String::Utf8Value& value) {
  return *value ? *value : "<string conversion failed>";
}

char* CopyString(const String::Utf8Value& value) {
	const char* value_string = *value ? *value : "";
	char *cstr = (char*)malloc(value.length() + 1);
	std::strcpy(cstr, value_string);
	return cstr;
}

void V8_Context_ThrowException(void* context, const char* err, int err_length) {
	V8_Context* ctx = static_cast<V8_Context*>(context);
	ISOLATE_SCOPE(ctx->GetIsolate());

	isolate->ThrowException(
		String::NewFromUtf8(isolate, err, String::kInternalizedString, err_length)
	);
}

void V8_Context_ThrowException2(void* value) {
	VALUE_SCOPE(value);

	isolate->ThrowException(Local<Value>::New(isolate, local_value));
}

void* V8_Make_Message(Handle<Message> message) {
	Handle<StackTrace> stack_trace = message->GetStackTrace();
	void* go_stack_trace = NULL;

	if (!stack_trace.IsEmpty()) {
		go_stack_trace = go_make_stacktrace();

		for (int i = 0; i < stack_trace->GetFrameCount(); ++i) {
			Local<StackFrame> frame = stack_trace->GetFrame(i);
			String::Utf8Value script_name(frame->GetScriptName());
			String::Utf8Value script_name_or_url(frame->GetScriptNameOrSourceURL());
			String::Utf8Value function_name(frame->GetFunctionName());

			void* go_frame = go_make_stackframe(
				frame->GetLineNumber(),
				frame->GetColumn(),
				frame->GetScriptId(),
				CopyString(script_name),
				CopyString(script_name_or_url),
				CopyString(function_name),
				frame->IsEval(),
				frame->IsConstructor()
			);

			go_push_stackframe(go_stack_trace, go_frame);
		}
	}

	String::Utf8Value message_str(message->Get());
	String::Utf8Value source_line(message->GetSourceLine());
	String::Utf8Value script_resource_name(message->GetScriptResourceName());

	void* go_message = go_make_message(
		CopyString(message_str),
		CopyString(source_line),
		CopyString(script_resource_name),
		go_stack_trace,
		message->GetLineNumber(),
		message->GetStartPosition(),
		message->GetEndPosition(),
		message->GetStartColumn(),
		message->GetEndColumn()
	);

	return go_message;
}

void* V8_Context_TryCatch(void* context, void* callback) {
	V8_Context* ctx = static_cast<V8_Context*>(context);
	ISOLATE_SCOPE(ctx->GetIsolate());

	TryCatch try_catch;

	go_try_catch_callback(callback);

	if (!try_catch.HasCaught()) {
		return NULL;
	}

	String::Utf8Value exception(try_catch.Exception());
	Handle<Message> message = try_catch.Message();

	if (message.IsEmpty()) {
		return go_make_message(
			CopyString(exception),
			NULL,
			NULL,
			NULL,
			0,
			0,
			0,
			0,
			0
		);
	}

	return V8_Make_Message(message);
}

void* V8_Context_TryCatchException(void* context, void* callback) {
	V8_Context* ctx = static_cast<V8_Context*>(context);
	ISOLATE_SCOPE(ctx->GetIsolate());

	TryCatch try_catch;

	go_try_catch_callback(callback);

	if (!try_catch.HasCaught()) {
		return NULL;
	}

	String::Utf8Value exception(try_catch.Exception());
	Handle<Message> message = try_catch.Message();

	if (message.IsEmpty()) {
		return go_make_message(
			CopyString(exception),
			NULL,
			NULL,
			NULL,
			0,
			0,
			0,
			0,
			0
		);
	}

	return go_make_exception(new_V8_Value(ctx, try_catch.Exception()), V8_Make_Message(message));
}

/*
script
*/
void* V8_Compile(void* engine, const char* code, int length, void* go_script_origin) {
	ENGINE_SCOPE(engine);

	HandleScope handle_scope(isolate);

	ScriptOrigin script_origin(String::NewFromUtf8(isolate, ""));

	if (go_script_origin) {
		char * cstr = go_script_origin_get_name(go_script_origin);
		int line    = go_script_origin_get_line(go_script_origin);
		int column  = go_script_origin_get_line(go_script_origin);

		script_origin = ScriptOrigin(
			String::NewFromUtf8(isolate, cstr),
			Integer::New(isolate, line),
			Integer::New(isolate, column)
		);

		free(cstr);
	}

	ScriptCompiler::Source source(
		String::NewFromUtf8(isolate, code, String::kInternalizedString, length),
		script_origin
	);

	Handle<UnboundScript> script = ScriptCompiler::CompileUnbound(isolate, &source);

	if (script.IsEmpty())
		return NULL;

	return (void*)(new V8_Script(the_engine, script));
}

void V8_DisposeScript(void* script) {
	delete static_cast<V8_Script*>(script);
}

void* V8_Script_Run(void* script) {
	V8_Script* the_script = static_cast<V8_Script*>(script);
	ISOLATE_SCOPE(the_script->engine->GetIsolate());
	V8_Context* the_context = V8_Current_Context(isolate);
	Local<UnboundScript> local_unbound_script = Local<UnboundScript>::New(isolate, the_script->self);
	Local<Script> local_script = local_unbound_script->BindToCurrentContext();
	return new_V8_Value(the_context, local_script->Run());
}

/*
Value wrappers
*/
void V8_DisposeValue(void* value) {
	delete static_cast<V8_Value*>(value);
}

int V8_Value_IsUndefined(void* value) {
	VALUE_SCOPE(value);
	return local_value->IsUndefined();
}

int V8_Value_IsNull(void* value) {
	VALUE_SCOPE(value);
	return local_value->IsNull();
}

int V8_Value_IsTrue(void* value) {
	VALUE_SCOPE(value);
	return local_value->IsTrue();
}

int V8_Value_IsFalse(void* value) {
	VALUE_SCOPE(value);
	return local_value->IsFalse();
}

int V8_Value_IsString(void* value) {
	VALUE_SCOPE(value);
	return local_value->IsString();
}

int V8_Value_IsFunction(void* value) {
	VALUE_SCOPE(value);
	return local_value->IsFunction();
}

int V8_Value_IsArray(void* value) {
	VALUE_SCOPE(value);
	return local_value->IsArray();
}

int V8_Value_IsObject(void* value) {
	VALUE_SCOPE(value);
	return local_value->IsObject();
}

int V8_Value_IsBoolean(void* value) {
	VALUE_SCOPE(value);
	return local_value->IsBoolean();
}

int V8_Value_IsNumber(void* value) {
	VALUE_SCOPE(value);
	return local_value->IsNumber();
}

int V8_Value_IsExternal(void* value) {
	VALUE_SCOPE(value);
	return local_value->IsExternal();
}

int V8_Value_IsInt32(void* value) {
	VALUE_SCOPE(value);
	return local_value->IsInt32();
}

int V8_Value_IsUint32(void* value) {
	VALUE_SCOPE(value);
	return local_value->IsUint32();
}

int V8_Value_IsDate(void* value) {
	VALUE_SCOPE(value);
	return local_value->IsDate();
}

int V8_Value_IsBooleanObject(void* value) {
	VALUE_SCOPE(value);
	return local_value->IsBooleanObject();
}

int V8_Value_IsNumberObject(void* value) {
	VALUE_SCOPE(value);
	return local_value->IsNumberObject();
}

int V8_Value_IsStringObject(void* value) {
	VALUE_SCOPE(value);
	return local_value->IsStringObject();
}

int V8_Value_IsNativeError(void* value) {
	VALUE_SCOPE(value);
	return local_value->IsNativeError();
}

int V8_Value_IsRegExp(void* value) {
	VALUE_SCOPE(value);
	return local_value->IsRegExp();
}

int V8_Value_ToBoolean(void* value) {
	VALUE_SCOPE(value);
	return local_value->BooleanValue();
}

double V8_Value_ToNumber(void* value) {
	VALUE_SCOPE(value);
	return local_value->NumberValue();
}

int64_t V8_Value_ToInteger(void* value) {
	VALUE_SCOPE(value);
	return local_value->IntegerValue();
}

uint32_t V8_Value_ToUint32(void* value) {
	VALUE_SCOPE(value);
	return local_value->Uint32Value();
}

int32_t V8_Value_ToInt32(void* value) {
	VALUE_SCOPE(value);
	return local_value->Int32Value();
}

char* V8_Value_ToString(void* value) {
	VALUE_SCOPE(value);

	Handle<String> string = local_value->ToString();
	char* str = (char*)malloc(string->Length() + 1);
	string->WriteUtf8(str);

	return str;
}

void* V8_Undefined(void* engine) {
	V8_Context* the_engine = static_cast<V8_Context*>(engine);
	ISOLATE_SCOPE(the_engine->GetIsolate());
	return new_V8_Value(the_engine, Undefined(isolate));
}

void* V8_Null(void* engine) {
	V8_Context* the_engine = static_cast<V8_Context*>(engine);
	ISOLATE_SCOPE(the_engine->GetIsolate());
	return new_V8_Value(the_engine, Null(isolate));
}

void* V8_True(void* engine) {
	V8_Context* the_engine = static_cast<V8_Context*>(engine);
	ISOLATE_SCOPE(the_engine->GetIsolate());
	return new_V8_Value(the_engine, True(isolate));
}

void* V8_False(void* engine) {
	V8_Context* the_engine = static_cast<V8_Context*>(engine);
	ISOLATE_SCOPE(the_engine->GetIsolate());
	return new_V8_Value(the_engine, False(isolate));
}

void* V8_NewNumber(void* engine, double val) {
	V8_Context* the_engine = static_cast<V8_Context*>(engine);
	ISOLATE_SCOPE(the_engine->GetIsolate());
	return new_V8_Value(the_engine, Number::New(isolate, val));
}

void* V8_NewDate(void* engine, double val) {
	V8_Context* the_engine = static_cast<V8_Context*>(engine);
	ISOLATE_SCOPE(the_engine->GetIsolate());
	return new_V8_Value(the_engine, Date::New(isolate, val));
}

void* V8_NewString(void* engine, const char* val, int val_length) {
	V8_Context* the_engine = static_cast<V8_Context*>(engine);
	ISOLATE_SCOPE(the_engine->GetIsolate());
	return new_V8_Value(the_engine,
		String::NewFromUtf8(isolate, val, String::kInternalizedString, val_length)
	);
}

void* V8_NewExternal(void* engine, void* data) {
	V8_Context* the_engine = static_cast<V8_Context*>(engine);
	ISOLATE_SCOPE(the_engine->GetIsolate());
	return new_V8_Value(the_engine, External::New(isolate, data));
}

void* V8_External_Value(void* value) {
	VALUE_SCOPE(value);
	Local<External> local_external = Local<External>::Cast(local_value);
	return local_external->Value();
}

void V8_Value_SetFieldOwnerInfo(void* value, void* engine, int64_t ownerId) {
	V8_Value* the_value = static_cast<V8_Value*>(value);
	the_value->fieldOwnerInfo = new V8_FieldOwnerInfo(engine, ownerId);
}

/*
object
*/
void* V8_NewObject(void* engine) {
	V8_Context* the_engine = static_cast<V8_Context*>(engine);
	ISOLATE_SCOPE(the_engine->GetIsolate());
	return new_V8_Value(the_engine, Object::New(isolate));
}

int V8_Object_InternalFieldCount(void* value) {
	VALUE_SCOPE(value);
	return Local<Object>::Cast(local_value)->InternalFieldCount();
}

void* V8_Object_GetInternalField(void* value, int index) {
	VALUE_SCOPE(value);
	Local<Object> obj = Local<Object>::Cast(local_value);
	Local<Value> data = obj->GetInternalField(index);
	return Local<External>::Cast(data)->Value();
}

void V8_Object_SetInternalField(void* value, int index, void* data) {
	VALUE_SCOPE(value);
	Local<Object> obj = Local<Object>::Cast(local_value);
	obj->SetInternalField(index, External::New(isolate, data));
}

int V8_Object_SetProperty(void* value, const char* key, int key_length, void* prop_value) {
	VALUE_SCOPE(value);

	return Local<Object>::Cast(local_value)->Set(
		String::NewFromUtf8(isolate, key, String::kInternalizedString, key_length),
		Local<Value>::New(isolate, static_cast<V8_Value*>(prop_value)->self)
	);
}

void* V8_Object_GetProperty(void* value, const char* key, int key_length) {
	VALUE_SCOPE(value);

	return new_V8_Value(V8_Current_Context(isolate),
		Local<Object>::Cast(local_value)->Get(
			String::NewFromUtf8(isolate, key, String::kInternalizedString, key_length)
		)
	);
}

int V8_Object_SetElement(void* value, uint32_t index, void* elem_value) {
	VALUE_SCOPE(value);

	return Local<Object>::Cast(local_value)->Set(
		index,
		Local<Value>::New(isolate, static_cast<V8_Value*>(elem_value)->self)
	);
}

void* V8_Object_GetElement(void* value, uint32_t index) {
	VALUE_SCOPE(value);

	return new_V8_Value(V8_Current_Context(isolate),
		Local<Object>::Cast(local_value)->Get(index)
	);
}

int V8_Object_GetPropertyAttributes(void* value, const char* key, int key_length) {
	VALUE_SCOPE(value);

	return Local<Object>::Cast(local_value)->GetPropertyAttributes(
		String::NewFromUtf8(isolate, key, String::kInternalizedString, key_length)
	);
}

int V8_Object_ForceSetProperty(void* value, const char* key, int key_length, void* prop_value, int attribs) {
	VALUE_SCOPE(value);

	return Local<Object>::Cast(local_value)->ForceSet(
		String::NewFromUtf8(isolate, key, String::kInternalizedString, key_length),
		Local<Value>::New(isolate, static_cast<V8_Value*>(prop_value)->self),
		(PropertyAttribute)attribs
	);
}

int V8_Object_HasProperty(void* value, const char* key, int key_length) {
	VALUE_SCOPE(value);

	return Local<Object>::Cast(local_value)->Has(
		String::NewFromUtf8(isolate, key, String::kInternalizedString, key_length)
	);
}

int V8_Object_DeleteProperty(void* value, const char* key, int key_length) {
	VALUE_SCOPE(value);

	return Local<Object>::Cast(local_value)->Delete(
		String::NewFromUtf8(isolate, key, String::kInternalizedString, key_length)
	);
}

int V8_Object_ForceDeleteProperty(void* value, const char* key, int key_length) {
	VALUE_SCOPE(value);

	return Local<Object>::Cast(local_value)->ForceDelete(
		String::NewFromUtf8(isolate, key, String::kInternalizedString, key_length)
	);
}

int V8_Object_HasElement(void* value, uint32_t index) {
	VALUE_SCOPE(value);

	return Local<Object>::Cast(local_value)->Has(index);
}

int V8_Object_DeleteElement(void* value, uint32_t index) {
	VALUE_SCOPE(value);

	return Local<Object>::Cast(local_value)->Delete(index);
}

void* V8_Object_GetPropertyNames(void* value) {
	VALUE_SCOPE(value);

	return new_V8_Value(V8_Current_Context(isolate),
		Local<Object>::Cast(local_value)->GetPropertyNames()
	);
}

void* V8_Object_GetOwnPropertyNames(void* value) {
	VALUE_SCOPE(value);

	return new_V8_Value(V8_Current_Context(isolate),
		Local<Object>::Cast(local_value)->GetOwnPropertyNames()
	);
}

void* V8_Object_GetPrototype(void* value) {
	VALUE_SCOPE(value);

	return new_V8_Value(V8_Current_Context(isolate),
		Local<Object>::Cast(local_value)->GetPrototype()
	);
}

int V8_Object_SetPrototype(void* value, void* proto) {
	VALUE_SCOPE(value);

	return Local<Object>::Cast(local_value)->SetPrototype(
		Local<Value>::New(isolate, static_cast<V8_Value*>(proto)->self)
	);
}

int V8_Object_IsCallable(void* value) {
	VALUE_SCOPE(value);

	return Local<Object>::Cast(local_value)->IsCallable();
}

void V8_AccessorGetterCallback(Local<String> property, const PropertyCallbackInfo<Value>& info) {
	Isolate* isolate_ptr = info.GetIsolate();
	ISOLATE_SCOPE(isolate_ptr);

	Local<Array> callback_data = Local<Array>::Cast(info.Data());

	V8_AccessorCallbackInfo callback_info;
	callback_info.engine = Local<External>::Cast(callback_data->Get(OTA_Context))->Value();
	callback_info.info = (void*)&info;
	callback_info.returnValue = NULL;
	callback_info.data = Local<External>::Cast(callback_data->Get(OTA_Data))->Value();
	callback_info.callback = Local<External>::Cast(callback_data->Get(OTA_Getter))->Value();
	callback_info.key = (const char*)Local<External>::Cast(callback_data->Get(OTA_KeyString))->Value();
	callback_info.key_length = Local<Integer>::Cast(callback_data->Get(OTA_KeyLength))->Value();

	void* context_ptr = V8_Current_ContextPtr(isolate);

	go_accessor_callback(OTA_Getter, &callback_info, context_ptr);

	if (callback_info.returnValue != NULL)
		delete static_cast<V8_ReturnValue*>(callback_info.returnValue);
}

void V8_AccessorSetterCallback(Local<String> property, Local<Value> value, const PropertyCallbackInfo<void>& info) {
	Isolate* isolate_ptr = info.GetIsolate();
	ISOLATE_SCOPE(isolate_ptr);

	Local<Array> callback_data = Local<Array>::Cast(info.Data());

	V8_AccessorCallbackInfo callback_info;
	callback_info.engine = Local<External>::Cast(callback_data->Get(OTA_Context))->Value();
	callback_info.info = (void*)&info;
	callback_info.returnValue = NULL;
	callback_info.setValue = new_V8_Value(static_cast<V8_Context*>(callback_info.engine), value);
	callback_info.data = Local<External>::Cast(callback_data->Get(OTA_Data))->Value();
	callback_info.callback = Local<External>::Cast(callback_data->Get(OTA_Setter))->Value();
	callback_info.key = (const char*)Local<External>::Cast(callback_data->Get(OTA_KeyString))->Value();
	callback_info.key_length = Local<Integer>::Cast(callback_data->Get(OTA_KeyLength))->Value();

	void* context_ptr = V8_Current_ContextPtr(isolate);

	go_accessor_callback(OTA_Setter, &callback_info, context_ptr);

	if (callback_info.returnValue != NULL)
		delete static_cast<V8_ReturnValue*>(callback_info.returnValue);
}

// sync with V8_ObjectTemplate_SetAccessor
void V8_Object_SetAccessor(void *value, const char* key, int key_length, void* getter, void* setter, void* data, int attribs) {
	VALUE_SCOPE(value);

	Handle<Array> callback_info = Array::New(isolate, OTA_Num);
	callback_info->Set(OTA_Context, External::New(isolate, (void*)V8_Current_Context(isolate)));
	callback_info->Set(OTA_Getter, External::New(isolate, getter));
	callback_info->Set(OTA_Setter, External::New(isolate, setter));
	callback_info->Set(OTA_KeyString, External::New(isolate, (void*)key));
	callback_info->Set(OTA_KeyLength, Integer::New(isolate, key_length));
	callback_info->Set(OTA_Data, External::New(isolate, data));

	if (callback_info.IsEmpty())
		return;

	Local<Object>::Cast(local_value)->SetAccessor(
		String::NewFromUtf8(isolate, key, String::kInternalizedString, key_length),
		V8_AccessorGetterCallback, setter == NULL ? NULL : V8_AccessorSetterCallback,
 		callback_info
	);
}

void* V8_PropertyCallbackInfo_This(void *info, PropertyDataEnum typ ) {
	V8_PropertyCallbackInfo* the_info = (V8_PropertyCallbackInfo*)info;
	V8_Context* engine = static_cast<V8_Context*>(the_info->engine);
	ENGINE_SCOPE(engine);
	switch(typ) {
	case OTP_Getter:
		return new_V8_Value(engine, static_cast<PropertyCallbackInfo<Value>*>(the_info->info)->This());
	case OTP_Setter:
		return new_V8_Value(engine, static_cast<PropertyCallbackInfo<Value>*>(the_info->info)->This());
	case OTP_Deleter:
		return new_V8_Value(engine, static_cast<PropertyCallbackInfo<Boolean>*>(the_info->info)->This());
	case OTP_Query:
		return new_V8_Value(engine, static_cast<PropertyCallbackInfo<Integer>*>(the_info->info)->This());
	case OTP_Enumerator:
		return new_V8_Value(engine, static_cast<PropertyCallbackInfo<Array>*>(the_info->info)->This());
	default:
		//impossible, should panic
		return NULL;
	}
}

void* V8_PropertyCallbackInfo_Holder(void *info, PropertyDataEnum typ) {
	V8_PropertyCallbackInfo* the_info = (V8_PropertyCallbackInfo*)info;
	V8_Context* engine = static_cast<V8_Context*>(the_info->engine);
	ENGINE_SCOPE(engine);
	switch(typ) {
	case OTP_Getter:
		return new_V8_Value(engine, static_cast<PropertyCallbackInfo<Value>*>(the_info->info)->Holder());
	case OTP_Setter:
		return new_V8_Value(engine, static_cast<PropertyCallbackInfo<Value>*>(the_info->info)->Holder());
	case OTP_Deleter:
		return new_V8_Value(engine, static_cast<PropertyCallbackInfo<Boolean>*>(the_info->info)->Holder());
	case OTP_Query:
		return new_V8_Value(engine, static_cast<PropertyCallbackInfo<Integer>*>(the_info->info)->Holder());
	case OTP_Enumerator:
		return new_V8_Value(engine, static_cast<PropertyCallbackInfo<Array>*>(the_info->info)->Holder());
	default:
		//impossible, should panic
		return NULL;
	}
}

void* V8_PropertyCallbackInfo_ReturnValue(void *info,  PropertyDataEnum typ) {
	V8_PropertyCallbackInfo* the_info = (V8_PropertyCallbackInfo*)info;
	V8_Context* engine = static_cast<V8_Context*>(the_info->engine);
	ENGINE_SCOPE(engine);
	if (the_info->returnValue == NULL) {
		switch(typ) {
		case OTP_Getter:
			the_info->returnValue = new V8_ReturnValue(
				engine,
				static_cast<PropertyCallbackInfo<Value>*>(the_info->info)->GetReturnValue()
			);
			break;
		case OTP_Setter:
			the_info->returnValue = new V8_ReturnValue(
				engine,
				static_cast<PropertyCallbackInfo<Value>*>(the_info->info)->GetReturnValue()
			);
			break;
		case OTP_Deleter:
			the_info->returnValue = new V8_ReturnValue(
				engine,
				ReturnValue<Value>(static_cast<PropertyCallbackInfo<Boolean>*>(the_info->info)->GetReturnValue())
			);
			break;
		case OTP_Query:
			the_info->returnValue = new V8_ReturnValue(
				engine,
				ReturnValue<Value>(static_cast<PropertyCallbackInfo<Integer>*>(the_info->info)->GetReturnValue())
			);
			break;
		case OTP_Enumerator:
			the_info->returnValue = new V8_ReturnValue(
				engine,
				ReturnValue<Value>(static_cast<PropertyCallbackInfo<Array>*>(the_info->info)->GetReturnValue())
			);
		default:
			//impossible, should panic
			break;
		}
	}
	return the_info->returnValue;
}

void* V8_AccessorCallbackInfo_This(void *info, AccessorDataEnum typ) {
	V8_AccessorCallbackInfo* the_info = (V8_AccessorCallbackInfo*)info;
	V8_Context* engine = static_cast<V8_Context*>(the_info->engine);
	ENGINE_SCOPE(engine);
	switch(typ) {
	case OTA_Getter:
		return new_V8_Value(engine, static_cast<PropertyCallbackInfo<Value>*>(the_info->info)->This());
	case OTA_Setter:
		return new_V8_Value(engine, static_cast<PropertyCallbackInfo<void>*>(the_info->info)->This());
	default:
		return NULL;
	}
}

void* V8_AccessorCallbackInfo_Holder(void *info, AccessorDataEnum typ) {
	V8_AccessorCallbackInfo* the_info = (V8_AccessorCallbackInfo*)info;
	V8_Context* engine = static_cast<V8_Context*>(the_info->engine);
	ENGINE_SCOPE(engine);
	switch(typ) {
	case OTA_Getter:
		return new_V8_Value(engine, static_cast<PropertyCallbackInfo<Value>*>(the_info->info)->Holder());
	case OTA_Setter:
		return new_V8_Value(engine, static_cast<PropertyCallbackInfo<void>*>(the_info->info)->Holder());
	default:
		return NULL;
	}
}

void* V8_AccessorCallbackInfo_ReturnValue(void *info, AccessorDataEnum typ) {
	V8_AccessorCallbackInfo* the_info = (V8_AccessorCallbackInfo*)info;
	V8_Context* engine = static_cast<V8_Context*>(the_info->engine);
	if (the_info->returnValue == NULL) {
		if (typ == OTA_Getter) {
			the_info->returnValue = new V8_ReturnValue(
				engine,
				static_cast<PropertyCallbackInfo<Value>*>(the_info->info)->GetReturnValue()
			);
		}
	}
	return the_info->returnValue;
}

/*
array
*/
void* V8_NewArray(void* engine, int length) {
	V8_Context* the_engine = static_cast<V8_Context*>(engine);
	ISOLATE_SCOPE(the_engine->GetIsolate());
	return new_V8_Value(the_engine, Array::New(isolate, length));
}

int V8_Array_Length(void* value) {
	VALUE_SCOPE(value);
	return Local<Array>::Cast(local_value)->Length();
}

/*
regexp
*/
void* V8_NewRegExp(void* engine, const char* pattern, int length, int flags) {
	V8_Context* the_engine = static_cast<V8_Context*>(engine);
	ISOLATE_SCOPE(the_engine->GetIsolate());
	return new_V8_Value(the_engine, RegExp::New(
		String::NewFromUtf8(isolate, pattern, String::kInternalizedString, length),
		(RegExp::Flags)flags
	));
}

char* V8_RegExp_Pattern(void* value) {
	VALUE_SCOPE(value);

	Local<String> pattern = Local<RegExp>::Cast(local_value)->GetSource();

	char* str = (char*)malloc(pattern->Length() + 1);
	pattern->WriteUtf8(str);

	return str;
}

int V8_RegExp_Flags(void* value) {
	VALUE_SCOPE(value);
	return Local<RegExp>::Cast(local_value)->GetFlags();
}

/*
error
*/
void* V8_Exception_RangeError(void* engine, const char* val, int val_length) {
	V8_Context* the_engine = static_cast<V8_Context*>(engine);
	ISOLATE_SCOPE(the_engine->GetIsolate());
	return new_V8_Value(the_engine,	Exception::RangeError(
		String::NewFromUtf8(isolate, val, String::kInternalizedString, val_length)
	));
}

void* V8_Exception_ReferenceError(void* engine, const char* val, int val_length) {
	V8_Context* the_engine = static_cast<V8_Context*>(engine);
	ISOLATE_SCOPE(the_engine->GetIsolate());
	return new_V8_Value(the_engine,	Exception::ReferenceError(
		String::NewFromUtf8(isolate, val, String::kInternalizedString, val_length)
	));
}

void* V8_Exception_SyntaxError(void* engine, const char* val, int val_length) {
	V8_Context* the_engine = static_cast<V8_Context*>(engine);
	ISOLATE_SCOPE(the_engine->GetIsolate());
	return new_V8_Value(the_engine,	Exception::SyntaxError(
		String::NewFromUtf8(isolate, val, String::kInternalizedString, val_length)
	));
}

void* V8_Exception_TypeError(void* engine, const char* val, int val_length) {
	V8_Context* the_engine = static_cast<V8_Context*>(engine);
	ISOLATE_SCOPE(the_engine->GetIsolate());
	return new_V8_Value(the_engine,	Exception::TypeError(
		String::NewFromUtf8(isolate, val, String::kInternalizedString, val_length)
	));
}

void* V8_Exception_Error(void* engine, const char* val, int val_length) {
	V8_Context* the_engine = static_cast<V8_Context*>(engine);
	ISOLATE_SCOPE(the_engine->GetIsolate());
	return new_V8_Value(the_engine,	Exception::Error(
		String::NewFromUtf8(isolate, val, String::kInternalizedString, val_length)
	));
}

/*
return value
*/
void V8_ReturnValue_Set(void* rv, void* result) {
	V8_ReturnValue* the_rv = (V8_ReturnValue*)rv;
	ENGINE_SCOPE(the_rv->context);
	the_rv->value.Set(static_cast<V8_Value*>(result)->self);
}

void V8_ReturnValue_SetBoolean(void* rv, int v) {
	V8_ReturnValue* the_rv = (V8_ReturnValue*)rv;
	ENGINE_SCOPE(the_rv->context);
	the_rv->value.Set((bool)v);
}

void V8_ReturnValue_SetNumber(void* rv, double v) {
	V8_ReturnValue* the_rv = (V8_ReturnValue*)rv;
	ENGINE_SCOPE(the_rv->context);
	the_rv->value.Set(v);
}

void V8_ReturnValue_SetInt32(void* rv, int32_t v) {
	V8_ReturnValue* the_rv = (V8_ReturnValue*)rv;
	ENGINE_SCOPE(the_rv->context);
	the_rv->value.Set(v);
}

void V8_ReturnValue_SetUint32(void* rv, uint32_t v) {
	V8_ReturnValue* the_rv = (V8_ReturnValue*)rv;
	ENGINE_SCOPE(the_rv->context);
	the_rv->value.Set(v);
}

void V8_ReturnValue_SetString(void* rv, const char* str, int str_length) {
	V8_ReturnValue* the_rv = (V8_ReturnValue*)rv;
	ENGINE_SCOPE(the_rv->context);
	if (str_length == 0) {
		the_rv->value.SetEmptyString();
	} else {
		the_rv->value.Set(
			String::NewFromUtf8(isolate, str, String::kInternalizedString, str_length)
		);
	}
}

void V8_ReturnValue_SetNull(void* rv) {
	V8_ReturnValue* the_rv = (V8_ReturnValue*)rv;
	ENGINE_SCOPE(the_rv->context);
	the_rv->value.SetNull();
}

void V8_ReturnValue_SetUndefined(void* rv) {
	V8_ReturnValue* the_rv = (V8_ReturnValue*)rv;
	ENGINE_SCOPE(the_rv->context);
	the_rv->value.SetUndefined();
}

/*
function
*/
typedef struct {
	V8_Context*                            engine;
	const v8::FunctionCallbackInfo<Value>* info;
	V8_ReturnValue*                        returnValue;
} V8_FunctionCallbackInfo;

void V8_FunctionCallback(const v8::FunctionCallbackInfo<Value>& info) {
	Isolate* isolate_ptr = info.GetIsolate();
	ISOLATE_SCOPE(isolate_ptr);

	Local<Array> callback_data = Local<Array>::Cast(info.Data());

	V8_FunctionCallbackInfo callback_info;
	callback_info.engine = (V8_Context*)Local<External>::Cast(callback_data->Get(0))->Value();
	callback_info.info = &info;
	callback_info.returnValue = NULL;

	void* callback = Local<External>::Cast(callback_data->Get(1))->Value();
	void* data = Local<External>::Cast(callback_data->Get(2))->Value();

	void* context_ptr = V8_Current_ContextPtr(isolate);

	go_function_callback(&callback_info, callback, context_ptr, data);

	if (callback_info.returnValue != NULL)
		delete callback_info.returnValue;
}

void* V8_NewFunction(void* engine, void* callback, void* data) {
	ENGINE_SCOPE(engine);

	Handle<Array> callback_data = Array::New(isolate, 3);

	if (callback_data.IsEmpty())
		return NULL;

	callback_data->Set(0, External::New(isolate, engine));
	callback_data->Set(1, External::New(isolate, callback));
	callback_data->Set(2, External::New(isolate, data));

	return new_V8_Value(V8_Current_Context(isolate),
		Function::New(isolate, V8_FunctionCallback, callback_data)
	);
}

void* V8_Function_Call(void* value, int argc, void* argv) {
	VALUE_SCOPE(value);

	Handle<Value>* real_argv = new Handle<Value>[argc];
	V8_Value* *argv_ptr = (V8_Value**)argv;

	for (int i = 0; i < argc; i ++) {
		real_argv[i] = Local<Value>::New(isolate, static_cast<V8_Value*>(argv_ptr[i])->self);
	}

	void* result = new_V8_Value(V8_Current_Context(isolate),
		Local<Function>::Cast(local_value)->Call(local_value, argc, real_argv)
	);

	delete[] real_argv;

	return result;
}

void* V8_Function_NewInstance(void* value, int argc, void* argv) {
	VALUE_SCOPE(value);

	Handle<Value>* real_argv = new Handle<Value>[argc];
	V8_Value* *argv_ptr = (V8_Value**)argv;

	for (int i = 0; i < argc; i ++) {
		real_argv[i] = Local<Value>::New(isolate, static_cast<V8_Value*>(argv_ptr[i])->self);
	}

	void* result = new_V8_Value(V8_Current_Context(isolate),
		Local<Function>::Cast(local_value)->NewInstance(argc, real_argv)
	);

	delete[] real_argv;

	return result;
}

void* V8_FunctionCallbackInfo_Get(void* info, int i) {
	V8_FunctionCallbackInfo* the_info = (V8_FunctionCallbackInfo*)info;
	ENGINE_SCOPE(the_info->engine);
	return new_V8_Value(the_info->engine, (*(the_info->info))[i]);
}

int V8_FunctionCallbackInfo_Length(void* info) {
	V8_FunctionCallbackInfo* the_info = (V8_FunctionCallbackInfo*)info;
	ENGINE_SCOPE(the_info->engine);
	return the_info->info->Length();
}

void* V8_FunctionCallbackInfo_Callee(void* info) {
	V8_FunctionCallbackInfo* the_info = (V8_FunctionCallbackInfo*)info;
	ENGINE_SCOPE(the_info->engine);
	return new_V8_Value(the_info->engine, the_info->info->Callee());
}

void* V8_FunctionCallbackInfo_This(void* info) {
	V8_FunctionCallbackInfo* the_info = (V8_FunctionCallbackInfo*)info;
	ENGINE_SCOPE(the_info->engine);
	return new_V8_Value(the_info->engine, the_info->info->This());
}

void* V8_FunctionCallbackInfo_Holder(void* info) {
	V8_FunctionCallbackInfo* the_info = (V8_FunctionCallbackInfo*)info;
	ENGINE_SCOPE(the_info->engine);
	return new_V8_Value(the_info->engine, the_info->info->Holder());
}

void* V8_FunctionCallbackInfo_ReturnValue(void* info) {
	V8_FunctionCallbackInfo* the_info = (V8_FunctionCallbackInfo*)info;
	if (the_info->returnValue == NULL) {
		the_info->returnValue = new V8_ReturnValue(
			the_info->engine,
			the_info->info->GetReturnValue()
		);;
	}
	return (void*)the_info->returnValue;
}

/*
object template
*/
void* V8_NewObjectTemplate(void* engine) {
	ENGINE_SCOPE(engine);
	HandleScope handle_scope(isolate);
	Handle<ObjectTemplate> tpl = ObjectTemplate::New(isolate);
	if (tpl.IsEmpty())
		return NULL;
	return (void*)new V8_ObjectTemplate(the_engine, tpl);
}

void V8_DisposeObjectTemplate(void* tpl) {
	delete static_cast<V8_ObjectTemplate*>(tpl);
}

#include "v8_plugin.h"

typedef void (*plugin_init)(void*, void*);

void V8_ObjectTemplate_Plugin(void* tpl, void* init) {
	OBJECT_TEMPLATE_HANDLE_SCOPE(tpl);

	((plugin_init)init)(isolate, &local_template);
}

void V8_ObjectTemplate_SetProperty(void* tpl, const char* key, int key_length, void* prop_value, int attribs) {
	OBJECT_TEMPLATE_SCOPE(tpl);

	local_template->Set(
		String::NewFromUtf8(isolate, key, String::kInternalizedString, key_length),
		Local<Value>::New(isolate, static_cast<V8_Value*>(prop_value)->self)
	);
}

void* V8_ObjectTemplate_NewInstance(void* engine, void* tpl) {
	OBJECT_TEMPLATE_SCOPE(tpl);
	V8_Context* the_engine = static_cast<V8_Context*>(engine);
	return new_V8_Value(the_engine, local_template->NewInstance());
}

// sync with V8_Object_SetAccessor
void V8_ObjectTemplate_SetAccessor(void *tpl, const char* key, int key_length, void* getter, void* setter, void* data, int attribs) {
	OBJECT_TEMPLATE_HANDLE_SCOPE(tpl);

	Handle<Array> callback_info = Array::New(isolate, 5);
	callback_info->Set(0, External::New(isolate, (void*)the_template->engine));
	callback_info->Set(1, External::New(isolate, getter));
	callback_info->Set(2, External::New(isolate, setter));
	callback_info->Set(3, External::New(isolate, (void*)key));
	callback_info->Set(4, Integer::New(isolate, key_length));
	callback_info->Set(5, External::New(isolate, data));

	if (callback_info.IsEmpty())
		return;

	local_template->SetAccessor(
		String::NewFromUtf8(isolate, key, String::kInternalizedString, key_length),
		V8_AccessorGetterCallback, setter == NULL ? NULL : V8_AccessorSetterCallback,
 		callback_info
	);
}

void V8_NamedPropertyGetterCallbackBase(
	PropertyDataEnum typ,
	Local<String> property,
	Local<Value> value,
	void* info_ptr,
	Isolate* isolate_ptr,
	Local<Value> callback_data_val
) {
    ISOLATE_SCOPE(isolate_ptr);
    Local<Array> callback_data = Local<Array>::Cast(callback_data_val);
    V8_PropertyCallbackInfo callback_info;
    callback_info.engine = Local<External>::Cast(callback_data->Get(OTP_Context))->Value();
    callback_info.info = info_ptr;
    callback_info.returnValue = NULL;
    callback_info.data = Local<External>::Cast(callback_data->Get(OTP_Data))->Value();
    callback_info.callback = Local<External>::Cast(callback_data->Get(typ))->Value();
    callback_info.key = NULL;

	if (typ != OTP_Enumerator) {
		char* key = (char*)malloc(property->Length() + 1);
		property->WriteUtf8(key);
		callback_info.key = key;
	}

	if (typ == OTP_Setter) {
		callback_info.setValue = new_V8_Value(
			V8_Current_Context(isolate_ptr),
			value
		);
	}

	void* context_ptr = V8_Current_ContextPtr(isolate);

	go_named_property_callback(typ, &callback_info, context_ptr);

	if (typ != OTP_Enumerator) {
		free(callback_info.key);
	}

	if (callback_info.returnValue != NULL)
		delete static_cast<V8_ReturnValue*>(callback_info.returnValue);
}

void V8_NamedPropertyGetterCallback(Local<String> property, const PropertyCallbackInfo<Value> &info) {
	V8_NamedPropertyGetterCallbackBase(OTP_Getter, property, Local<Value>(), (void*)&info, info.GetIsolate(), info.Data());
}

void V8_NamedPropertySetterCallback(Local<String> property, Local<Value> value, const PropertyCallbackInfo<Value> &info) {
	V8_NamedPropertyGetterCallbackBase(OTP_Setter, property, value, (void*)&info, info.GetIsolate(), info.Data());
}

void V8_NamedPropertyDeleterCallback(Local<String> property, const PropertyCallbackInfo<Boolean> &info) {
	V8_NamedPropertyGetterCallbackBase(OTP_Deleter, property, Local<Value>(), (void*)&info, info.GetIsolate(), info.Data());
}

void V8_NamedPropertyQueryCallback(Local<String> property, const PropertyCallbackInfo<Integer> &info) {
	V8_NamedPropertyGetterCallbackBase(OTP_Query, property, Local<Value>(), (void*)&info, info.GetIsolate(), info.Data());
}

void V8_NamedPropertyEnumeratorCallback(const PropertyCallbackInfo<Array> &info) {
	V8_NamedPropertyGetterCallbackBase(OTP_Enumerator, Local<String>(), Local<Value>(), (void*)&info, info.GetIsolate(), info.Data());
}

void V8_ObjectTemplate_SetNamedPropertyHandler(
	void* tpl,
	void* getter,
	void* setter,
	void* query,
	void* deleter,
	void* enumerator,
	void* data
) {
	OBJECT_TEMPLATE_HANDLE_SCOPE(tpl);

	Handle<Array> callback_info = Array::New(isolate, OTP_Num);
	callback_info->Set(OTP_Context, External::New(isolate, (void*)the_template->engine));
	callback_info->Set(OTP_Getter, External::New(isolate, getter));
	callback_info->Set(OTP_Setter, External::New(isolate, setter));
	callback_info->Set(OTP_Query, External::New(isolate, query));
	callback_info->Set(OTP_Deleter, External::New(isolate, deleter));
	callback_info->Set(OTP_Enumerator, External::New(isolate, enumerator));
	callback_info->Set(OTP_Data, External::New(isolate, data));

	if (callback_info.IsEmpty())
		return;

	local_template->SetNamedPropertyHandler(
		V8_NamedPropertyGetterCallback,
		setter == NULL ? NULL : V8_NamedPropertySetterCallback,
		query == NULL ? NULL : V8_NamedPropertyQueryCallback,
		deleter == NULL ? NULL : V8_NamedPropertyDeleterCallback,
		enumerator == NULL ? NULL : V8_NamedPropertyEnumeratorCallback,
 		callback_info
	);
}

void V8_IndexedPropertyGetterCallbackBase(
	PropertyDataEnum typ,
	uint32_t index,
	Local<Value> value,
	void* info_ptr,
	Isolate* isolate_ptr,
	Local<Value> callback_data_val
) {
    ISOLATE_SCOPE(isolate_ptr);

    Local<Array> callback_data = Local<Array>::Cast(callback_data_val);
    V8_PropertyCallbackInfo callback_info;
    callback_info.engine = Local<External>::Cast(callback_data->Get(OTP_Context))->Value();
    callback_info.info = info_ptr;
    callback_info.returnValue = NULL;
    callback_info.data = Local<External>::Cast(callback_data->Get(OTP_Data))->Value();
    callback_info.callback = Local<External>::Cast(callback_data->Get(typ))->Value();
	callback_info.index = index;

	if (typ == OTP_Setter) {
		callback_info.setValue = new_V8_Value(
			V8_Current_Context(isolate_ptr),
			value
		);
	}

	void* context_ptr = V8_Current_ContextPtr(isolate);

	go_indexed_property_callback(typ, &callback_info, context_ptr);

	if (callback_info.returnValue != NULL)
		delete static_cast<V8_ReturnValue*>(callback_info.returnValue);
}

void V8_IndexedPropertyGetterCallback(uint32_t index, const PropertyCallbackInfo<Value> &info) {
	V8_IndexedPropertyGetterCallbackBase(OTP_Getter, index, Local<Value>(), (void*)&info, info.GetIsolate(), info.Data());
}

void V8_IndexedPropertySetterCallback(uint32_t index, Local<Value> value, const PropertyCallbackInfo<Value> &info) {
	V8_IndexedPropertyGetterCallbackBase(OTP_Setter, index, value, (void*)&info, info.GetIsolate(), info.Data());
}

void V8_IndexedPropertyDeleterCallback(uint32_t index, const PropertyCallbackInfo<Boolean> &info) {
	V8_IndexedPropertyGetterCallbackBase(OTP_Getter, index, Local<Value>(), (void*)&info, info.GetIsolate(), info.Data());
}

void V8_IndexedPropertyQueryCallback(uint32_t index, const PropertyCallbackInfo<Integer> &info) {
	V8_IndexedPropertyGetterCallbackBase(OTP_Getter, index, Local<Value>(), (void*)&info, info.GetIsolate(), info.Data());
}

void V8_IndexedPropertyEnumeratorCallback(const PropertyCallbackInfo<Array> &info) {
	V8_IndexedPropertyGetterCallbackBase(OTP_Getter, 0, Local<Value>(), (void*)&info, info.GetIsolate(), info.Data());
}

void V8_ObjectTemplate_SetIndexedPropertyHandler(
	void* tpl,
	void* getter,
	void* setter,
	void* query,
	void* deleter,
	void* enumerator,
	void* data
) {
	OBJECT_TEMPLATE_HANDLE_SCOPE(tpl);

	Handle<Array> callback_info = Array::New(isolate, OTP_Num);
	callback_info->Set(OTP_Context, External::New(isolate, (void*)the_template->engine));
	callback_info->Set(OTP_Getter, External::New(isolate, getter));
	callback_info->Set(OTP_Setter, External::New(isolate, setter));
	callback_info->Set(OTP_Query, External::New(isolate, query));
	callback_info->Set(OTP_Deleter, External::New(isolate, deleter));
	callback_info->Set(OTP_Enumerator, External::New(isolate, enumerator));
	callback_info->Set(OTP_Data, External::New(isolate, data));

	if (callback_info.IsEmpty())
		return;

	local_template->SetIndexedPropertyHandler(
		V8_IndexedPropertyGetterCallback,
		setter == NULL ? NULL : V8_IndexedPropertySetterCallback,
		query == NULL ? NULL : V8_IndexedPropertyQueryCallback,
		deleter == NULL ? NULL : V8_IndexedPropertyDeleterCallback,
		enumerator == NULL ? NULL : V8_IndexedPropertyEnumeratorCallback,
 		callback_info
	);
}

void V8_ObjectTemplate_SetInternalFieldCount(void* tpl, int count) {
	OBJECT_TEMPLATE_HANDLE_SCOPE(tpl);
	local_template->SetInternalFieldCount(count);
}

/*
function template
*/
void* V8_NewFunctionTemplate(void* engine, void* callback, void* data) {
	ENGINE_SCOPE(engine);

	HandleScope scope(isolate);

	Handle<Array> callback_data = Array::New(isolate, 3);

	if (callback_data.IsEmpty())
		return NULL;

	callback_data->Set(0, External::New(isolate, engine));
	callback_data->Set(1, External::New(isolate, callback));
	callback_data->Set(2, External::New(isolate, data));

	Handle<FunctionTemplate> tpl = callback == NULL ? FunctionTemplate::New(isolate) : FunctionTemplate::New(
		isolate, V8_FunctionCallback, callback_data
	);

	if (tpl.IsEmpty())
		return NULL;

	return (void*)new V8_FunctionTemplate(the_engine, tpl);
}

void V8_DisposeFunctionTemplate(void* tpl) {
	delete static_cast<V8_FunctionTemplate*>(tpl);
}

void* V8_FunctionTemplate_GetFunction(void* tpl) {
	FUNCTION_TEMPLATE_SCOPE(tpl);
	V8_Context* the_context = V8_Current_Context(isolate);
	return new_V8_Value(the_context, local_template->GetFunction());
}

void V8_FunctionTemplate_SetClassName(void* tpl, const char* name, int name_length) {
	FUNCTION_TEMPLATE_HANDLE_SCOPE(tpl);
	return local_template->SetClassName(
		String::NewFromUtf8(isolate, name, String::kInternalizedString, name_length)
	);
}

void* V8_FunctionTemplate_InstanceTemplate(void* tpl) {
	FUNCTION_TEMPLATE_HANDLE_SCOPE(tpl);
	return new V8_ObjectTemplate(the_template->engine, local_template->InstanceTemplate());
}

/*
V8
*/
const char* V8_GetVersion() {
	return V8::GetVersion();
}

void V8_SetFlagsFromString(const char* str, int length) {
	V8::SetFlagsFromString(str, length);
}

class DefaultArrayBufferAllocator : public ArrayBuffer::Allocator {
public:
	DefaultArrayBufferAllocator() {
	}

	virtual void* Allocate(size_t length) {
		void* result = malloc(length);
		memset(result, 0, length);
		return result;
	}

	virtual void* AllocateUninitialized(size_t length) {
		return malloc(length);
	}

	virtual void Free(void* data, size_t length) {
		free(data);
	}
};

void V8_UseDefaultArrayBufferAllocator() {
	V8::SetArrayBufferAllocator(new DefaultArrayBufferAllocator());
}

void V8_MessageCallback(Handle<Message> message, Handle<Value> error) {
	Handle<Array> args = Handle<Array>::Cast(error);

	void* go_engine = Handle<External>::Cast(args->Get(0))->Value();
	void* msg = V8_Make_Message(message);

	go_message_callback(go_engine, msg);
}

void V8_EnableMessageListener(void* engine, void* go_engine, int enable) {
	ENGINE_SCOPE(engine);

	if (enable == 1) {
		HandleScope scope(isolate);
		Handle<Array> args = Array::New(isolate, 1);
		args->Set(0, External::New(isolate, go_engine));
		V8::AddMessageListener(V8_MessageCallback, args);
	} else if (enable == 0) {
		V8::RemoveMessageListeners(V8_MessageCallback);
	}
}

void V8_SetCaptureStackTraceForUncaughtExceptions(void* engine, int capture, int frame_limit) {
	ENGINE_SCOPE(engine);
	V8::SetCaptureStackTraceForUncaughtExceptions(capture, frame_limit);
}

} // extern "C"


Many logo designing companies design logos and artworks for a large clientele. The client lists include many start-ups, industrial organisations, manufacturers, consumer producers and so on. There are many logo designing companies in Canada who provide the very best logos for many companies.
The first step into making the logo for the company is to try and talk to the client about the various requirements that the company logo should have. Try to understand the needs and values that the client wants to emulate through their company logos. Try to make the logo that it specifically tailored to meet the client's taste and preference. Also, make sure that the logo you have produced to your client is copyrighted, so as to prevent any infringement from other parties. Many logo designing company in Toronto and other cities follows a similar protocol. This prevents in copying of ideas for commercial purposes by any third parties.
Providing the perfect logo is a very hard and an unpredictable procedure. There are many rules and regulations that the logo designer should follow while making the most appropriate logo for the company. Depending on the company the logo should change. In some cases, the logo should be fun, attractive and eye catching, while in some cases a logo should have some kind of sophistication and some formality added to it. Also, another factor that should be kept in mind is the resolution and the size of the logos. Most logo design company in Canada and also in many other metropolitan areas try to provide the best logos that are compatible with most of the websites and have a high design quality. They also should try to make the logo compatible in size so that the logo can be used for other purposes such as being printed on the company merchandises, letter heads, and also on business cards. Hence, the main priority of a logo is that it should look good and smart wherever it is printed or used.
Most logo designing companies combine art and technology together to give the required logo that the customers wants. They provide a variety of designs and sketches that are added with various artistic effects to give a good aesthetic. The logo of the company decides the overall look for the company and also the overall look of the associated materials such as pamphlets, brochures, letter heads and so on.
Meets with the client and the art director sand discusses about the various ideas that they have for the logo.
Tries to know if the logo is used to attract a certain type of audience. If yes, then tries to design a logo according to it.
Tries to emphasize and create the messages that the logo wants to portray to the public.
What makes a person a good logo designer is his portfolio and previous assignments. Having a great and up to date portfolio is necessary for any good designer.
Visual Connections is the natural evolution of our advertising, VFX and Animation firm from its humble origin and started this company on 2013. After leaving behind a long trail of over 271 happy clients worldwide, we decided to expand our market and reach.


After a focused race season around the globe, Michelle Vesterby is now in Boulder for the last leg of her preparation ahead of the IRONMAN World Championship. This is where Argon 18 presented her a big motivational gift: a custom painted E-119 Tri+.
For Michelle's bike, we wanted to break away from our usual custom bike process. We wanted this to be a complete women's project. We have been working with FatCreations in the UK for some of our custom paint projects and were lucky to collaborate with Bex, the talented woman side of FatCreations. With this custom paint, we wanted to highlight the impact of women in Triathlon and make a statement that Argon 18 is fully dedicated to supporting women in all aspects of the sport.
"Painting Michelle Vesterby's Argon 18 frame was really cool! We get to work on quite a few frames for pro men athletes, but this was the first pro women's frame we have done. I jumped at the chance to be more involved with the paint on this project, not only because she's a woman but because she's an incredible athlete and an inspiration. Ironman is one of those things where I'm just amazed not only by the athlete's dedication to training, strength and endurance but their mental ability to keep pushing on. Best of luck to Michelle in the IRONMAN World Championship, I hope the frames bring you lots of luck and speed!" –Bex, Fatcreations.
The objective for all of our custom projects is always to offer a bike that highlights the athlete's personality. Offering personalized bikes to special athletes is our way of encouraging them in the final stages of their preparation for major events. We know that these special attentions can make a huge difference.
Knowing that pink is Michelle's favourite colour and that she absolutely wanted a pink bike, coming up with a subtle bike cosmetic was never an option. We wanted to do something spectacular, sophisticated and vibrant by adding a gradient with multicoloured layers (holographic).
Michelle Vesterby has always been known for speaking her mind and we wanted to incorporate that aspect of her personality in the design. To do so, we added all sorts of graphic elements on the bike's top tube, including her quote "Keep Smiling" along with Danish, Hawaiian and personal graphic details. These become motivational elements to look at when she's deep into her race to help her push on.
We kept our fingers crossed hoping our ideas and designs could be painted on our E-119 Tri+ and that our vision of Michelle's bike would see the day. Once completed though, all of it: base paint, faded layers, stencils and airbrush integrated perfectly with our 2019 colour scheme. All we could say was: Mission accomplished.
We sincerely hope this custom bike will help her keep smiling on the last stretch leading to the start line of IRONMAN World Championship. We cannot wait to see Michelle race on the Queen K.
ParticuleR is the new internal initiative program from Argon 18 pushing a creative hub for experimentation. Through the ParticuleR Program Argon 18 designers will go to the extreme of their cycling passion to develop new ideas, new designs and possibilities. It is the company's new playground to push creative limits and influence future brand designs. It is only through experimentation that one learns and grows. All the projects from this lab will be unique.
All photos above by United Cycling and FatCreations.
While Michelle is now riding her Keep Smiling custom painted frame, it is the same consumer model E-119 Tri+ which can be found at Argon 18 retailers worldwide.