Knowing which steaks are the most tender is key to choosing the most enjoyable cut since tenderness is arguably the most important factor in steak enjoyment. Of course, you will also have to weigh a number of other factors like cost and ease of cooking. Below is a look at the most tender steak cuts available with a little intel into why each is perfect for your plate.
The tenderloin muscle is cylindrical with a narrow tip, somewhat like a pencil. It runs along the spine and is known for the buttery texture of its meat, hence the tender in the word tenderloin. The tenderloin muscle can be served in large chunks for chateaubriand or it can be sliced into steaks. The tenderloin includes the filet mignon, which is unquestionably the most delicate meat that the cow's carcass has to offer. The meat from this cut is so tender that when it is cooked properly, you should be able to cut a tenderloin steak with a butter-knife. To maximize the tenderness, a tenderloin steak should not be cooked beyond medium rare; rare is ideal.
Flat iron steaks come from the chuck and are a part of the animal's shoulder. Normally the steaks from that part of the animal are relatively tough and contain a lot of connective tissue; however, flatiron steaks are cut so as to eliminate the gristle. By cutting it correctly, you get a steak that is considered second in tenderness only to the filet mignon part of the tenderloin and that is shaped somewhat like an old-fashioned clothes iron. Rare is the ideal degree of doneness for this cut of beef.
Ribeye steaks are cut from the upper part of the rib cage. They come from the 6th through the 12th rib and are essentially the same thing as cutting down a prime rib into steak-sized portions. Ribeye steaks are a great compromise between the flavor of the chuck and the tenderness of the tenderloin in that they taste like the former but have a texture close to that of the latter. They tend to be well-marbled, which means that they stay juicy. Ribeye steaks can be grilled, but inexperienced cooks may be more successful cooking them in a cast iron pan. Rare is ideal, but ribeyes should not be cooked beyond medium rare.
This steak comes from the short loin, which is located behind the ribs and it is usually sold boneless. The meat is fine-textured and may contain a little marbling on its edge, but there is usually not a lot in the meat itself; however, it can be well-marbled in some cows. Grade has a lot to do with this; this steak can vary between mediocre and excellent based on the grade of the beef. Good marbling will make it even more tender. This steak can be good at any level of doneness between rare and medium-rare if it is well-marbled.
Porterhouse steaks come from the short loin and tenderloin area that lies just behind the cow's upper ribs. The porterhouse steak has a T-bone, just like the T-bone steak. The T-bone is a part of the cow's vertebrae and its shape comes the fact that it is a cross-section of the vertebrae. The T-bone separates a tenderloin steak from a top loin steak (New York Strip), which means that you are getting two of the most tender cuts of beef in one piece of meat. Of course, the fact that there are two different cuts makes it more difficult to cook each of them well but the right cooking methods will allow you to maximize this steak's tenderness. Ideally, you should cook the New York strip side rare to medium-rare but keep the filet side as close to rare as possible.


text:
//========================================================================
// GLFW 3.3 - www.glfw.org
//------------------------------------------------------------------------
// Copyright (c) 2010-2016 Camilla Löwy <elmindreda@glfw.org>
//
// This software is provided 'as-is', without any express or implied
// warranty. In no event will the authors be held liable for any damages
// arising from the use of this software.
//
// Permission is granted to anyone to use this software for any purpose,
// including commercial applications, and to alter it and redistribute it
// freely, subject to the following restrictions:
//
// 1. The origin of this software must not be misrepresented; you must not
//    claim that you wrote the original software. If you use this software
//    in a product, an acknowledgment in the product documentation would
//    be appreciated but is not required.
//
// 2. Altered source versions must be plainly marked as such, and must not
//    be misrepresented as being the original software.
//
// 3. This notice may not be removed or altered from any source
//    distribution.
//
//========================================================================
// As glfw_config.h.in, this file is used by CMake to produce the
// glfw_config.h configuration header file.  If you are adding a feature
// requiring conditional compilation, this is where to add the macro.
//========================================================================
// As glfw_config.h, this file defines compile-time option macros for a
// specific platform and development environment.  If you are using the
// GLFW CMake files, modify glfw_config.h.in instead of this file.  If you
// are using your own build system, make this file define the appropriate
// macros in whatever way is suitable.
//========================================================================

// Define this to 1 if building GLFW for X11
/* #undef _GLFW_X11 */
// Define this to 1 if building GLFW for Win32
/* #undef _GLFW_WIN32 */
// Define this to 1 if building GLFW for Cocoa
#define _GLFW_COCOA
// Define this to 1 if building GLFW for Wayland
/* #undef _GLFW_WAYLAND */
// Define this to 1 if building GLFW for OSMesa
/* #undef _GLFW_OSMESA */

// Define this to 1 if building as a shared library / dynamic library / DLL
/* #undef _GLFW_BUILD_DLL */
// Define this to 1 to use Vulkan loader linked statically into application
/* #undef _GLFW_VULKAN_STATIC */

// Define this to 1 to force use of high-performance GPU on hybrid systems
/* #undef _GLFW_USE_HYBRID_HPG */

// Define this to 1 if xkbcommon supports the compose key
/* #undef HAVE_XKBCOMMON_COMPOSE_H */
// Define this to 1 if the libc supports memfd_create()
/* #undef HAVE_MEMFD_CREATE */

redpajama_set_name: RedPajamaGithub


text:
Audi A1 e-tron : 2010
Electric driving in the city.
« Prev | 3 / 155 | Next »
View all cars for: Audi
Search for Audi A1 e-tron : 2010 on:
The new e-tron model series from Audi will gain another new member at the Geneva Motor Show: The Audi A1 e-tron is a Mega City Vehicle (MCV) with an innovative drive technology. It comes equipped with a powerful electric motor for zero-emission driving in the city. There is also an internal combustion engine on board that recharges the battery in exceptional circumstances. The A1 e-tron is very agile thanks to the 75 kW (102 hp) peak power of its electric motor.
2010 Audi A1 e-tron.
The technology of the Audi A1 e-tron.
The e-tron model family from Audi is just a few months old, but it already has a number of members, for each of which Audi has chosen a different drive technology. The first e-tron, which debuted at the 2009 IAA in Frankfurt/Main, is a near-series high-performance sports car with electric motors for all four wheels. The study shown at the Detroit Motor Show in 2010 is a lightweight, compact two-seater with two electric motors on the rear axle.
The A1 e-tron now presents another approach – a compact electric car in the premium class. The four-passenger, two-door MCV city car was designed specifically for use in the metropolitan areas of Europe and North America and in the rapidly growing megacities of Asia and South America. The Audi A1 e-tron always drives on electric power; its internal combustion engine is only used to recharge the battery in isolated cases.
The integration of the new technologies shows the holistic approach that Audi is pursuing with electric mobility. The objective is to use the energy with the lowest possible losses. The precise interaction of the components, their intelligent packaging, and the efficient management of the current flows are the product of the expertise that the company has developed in this area.
Audi has developed a proprietary thermal management system to keep the battery, the electric motor, and the power electronics within their respective ideal temperature windows.
Behind the three e-tron models is a broadly diverse and modular technology platform that continues to grow very rapidly as Audi drives development forward.
The electric motor: 75 kW (102 hp) peak power
The synchronous electric motor of the Audi A1 e-tron is mounted transversely at the front of the car. Its low mounting position has a positive effect on the vehicle's center of gravity. Continuous output is rated at 45 kW (61 hp), with peak power of 75 kW (102 hp) available in short bursts. 150 Nm (110.63 lb-ft) of torque is continuously available, and peak torque is 240 Nm (177.01 lb-ft).
The electric motor sends its power to the front wheels via a single-speed transmission. The elegant, retractable selector lever on the console of the center tunnel used to choose between "Drive," "Reverse," and "Neutral" was taken from the first Audi e-tron.
The power electronics are mounted in the engine compartment above the electric motor. The most important components are the pulse-controlled inverter, which serves as the controller between the electric motor and the battery; the DC converter, which connects the high-voltage network with the 14 volt electrical system; a breaker unit to protect the high-voltage components; and the charging module. The socket for the standard charging plug is located behind the rings in the single-frame grille of the Audi A1 e-tron. A fully depleted battery can be recharged in approximately three hours from the 380 volt grid. A display immediately adjacent to the plug-in connection shows the current charge status and the charging time remaining.
The concept of the innovative Mega City Vehicle requires the electrification of key auxiliaries. The refrigerant compressor of the climate control system, for example, is electrically powered by a high-voltage electric motor that supplies only the amount of power needed at the time.
This increases system efficiency substantially compared to conventional concepts. Thanks to a special circuit, the climate control loop also functions as a heat pump that regulates the temperature of the cabin and the battery.
The power steering of the Audi A1 e-tron is electro-mechanical and thus particularly energy-efficient. An electronic brake system makes it possible to tap into the recuperation potential of the electric motors. A hydraulic fixed-caliper brake is mounted on the front axle, with two novel electrically-actuated floating-caliper brakes mounted on the rear axle. These floating calipers are actuated not by any mechanical or hydraulic transfer elements, but rather by wire ("brake by wire"). In addition, this eliminates frictional losses due to residual slip when the brakes are not being applied. In addition, the servo unit received a new, demand-controlled electric vacuum pump.
The large electric motor powering the A1 e-tron can convert braking energy into electric current and feed it back into the electrical system. The high degree of recuperation benefits overall efficiency. The electric control actions are imperceptible to the driver, who notices only the familiar, precise, and perfectly controllable pedal feel.
The battery pack: a compact T arranged below the floor.
The energy storage unit is arranged below the floor, where it is ideal for the center of gravity and weight distribution. The battery pack is shaped like a T, with the short "transverse beam" filling the rear section of the center tunnel and the "cross-beam" filling that area in front of the rear axle where the fuel tank is otherwise located. The 380 volt lithium-ion rechargeable battery has a nominal energy content of 12 kilowatt hours. It comprises 96 prismatic cells and weighs less than 150 kilograms (330.69 lb).
The Audi A1 e-tron can drive 50 kilometers (31.07 miles) emission-free in city traffic on the powerful battery. On longer trips, the battery is recharged by a particularly compact internal combustion engine mounted below the luggage compartment.
The range extender.
The A1 e-tron concept car has a Wankel engine as a range extender, but other compact concepts are also possible. The small single-rotor Wankel has a chamber volume of 254 cc and runs at a constant 5,000 rpm in its peak efficiency window. The electronics also consider navigation data such as the destination and route profile to automatically activate the range extender as needed. The driver can also turn the range extender on and off as necessary with the push of a button The fuel tank holds 12 liters (3.17 US gallons).
The great strengths of the Wankel engine are the nearly vibration-free and quiet operation, the small dimensions, and the extremely low weight. Together with the generator, which is powered by the Wankel engine and produces 15 kW of electric power, the complete assembly weighs only around 70 kilograms (154.32 lb). This weight also includes the special power electronics, the intake, exhaust, and cooling unit, plus the insulation and the subframe.
Driving experience.
The first defining impression that the driver of the Audi A1 e-tron gets is that of nearly total silence. Even the Wankel engine in the back can barely be heard when it is running.
The second characteristic perception is the power of the electric motor, nearly all of which is available instantly and thrusts the Audi A1 e-tron forward with authority. The innovative Mega City Vehicle, which despite its complex drive technology weighs only 1,190 kilograms (2,623.50 lb) delivers zero-emission driving fun in a modern and sophisticated manner. The vehicle accelerates from 0 to 100 km/h (62.14 mph) in 10.2 seconds and has a top speed of more than 130 km/h (80.78 mph).
The Audi A1 e-tron can also cover longer distances if the range extender charges the battery. The extra range, which is intended primarily for interurban driving, is 200 kilometers (124.27 miles).
According to the draft standard, the two different operating modes yield a fuel consumption of only 1.9 l/100 km (123.80 US mpg), which corresponds to CO2 emissions of 45 g/km (72.42 g/mile). In electric mode, there are zero local CO2 emissions - the compact A1 e-tron is thus ecological and economical.
The third impression that the A1 e-tron makes is that of a larger car. The compact two-door boasts all of the strengths of the new A1 model series – the carefully tuned, sporty chassis with specially designed 18 inch alloy wheels and 215/35 R18 tires; the generous, "grown-up" interior; the excellent fit and finish; and a multitude of high-end equipment.
The dark shade "ebony" dominates the interior. The seats – with stone gray seams – and the headliner are in "Alabaster White".
The concept car in Geneva has a special "Aqua Mint, pearl effect" paint finish; the contrasting roof arch is offset in "High Gloss Steel dark." As with the other two e-tron models, the 18-inch wheels with a 20-spoke turbine design convey the high-tech aspiration of the concept.
The rear diffuser with aluminum trim lacks tailpipes. This emphasizes the width of the vehicle and suggests the low emissions. The two front fenders are emblazoned with the "e-tron" logo.
The "Aqua Mint, pearl effect" exterior color carries over into the interior, where it adorns the door panels and the center console. The shift lever is a special leather-wrapped design; as is typical for the e-tron models, the start-stop button was placed in the front of the center console. A specially designed battery cover at the front of the car and the range extender engine with its cooling fins displayed under a sheet of glass in the luggage compartment also serve to visually underscore the clean technology of the A1 e-tron. And because an innovative drive concept also calls for innovative information management, the concept car features a freely programmable instrument cluster with a virtual display surface and innovative display and operating concept.
(source: Audi)
2010 Audi A1 e-tron wheel.
2010 Audi A1 e-tron interior.
2010 Audi A1 e-tron cutaway.
New 2009 Audi logo.
Audi E-Tron : 2009
Audi's E-tron electric concept car virtual test drive Audi driving game on PlayStation®Home starting in December.
Audi A1 iPhone app Game of skill with nine different rock songs.
Audi A1 at Wörthersee Tour 2010 Audi showing seven A1 models as spectacular "motto vehicles".
Audi A1 by Damien Hirst Audi A1 as an "art car" at Elton John's White Tie and Tiara Ball.
Audi R8 e-tron : 2010 Audi electric sports car entered in Silvretta E-Auto Rally.
Audi e-tron Spyder : 2010
Audi A3 e-tron : 2011 Concentrated technical expertise.
Audi A1 S-line : 2012 The compact Audi with five doors.
Audi A1 and Justin Timberlake
Audi A1 Quattro : 2012 Limited production of 333 units.
Audi A1 Amplified : 2012 New sporty edition models can be ordered for the A1 and A1 Sportback.
Audi Official site.

redpajama_set_name: RedPajamaCommonCrawl


text:
Gov. Announces $2.3M to Support 4 Prevention Coalitions in NYC;
Enhance Transport in WNY & Finger Lakes
Funding to Establish Four Prevention Coalitions in New York City; Enhance Transportation Services for Treatment in Western New York and the Finger Lakes
Grants to Build on New York State's Nation-Leading Continuum of Addiction Care
Governor Kathy Hochul today announced $2.3 million to support addiction prevention efforts and enhance access to transportation services for treatment. Administered by the Office of Addiction Services and Supports, the funding will help establish four prevention coalitions in New York City and enhance non-medical transportation services for individuals having difficulty accessing addiction treatment in Western New York and the Finger Lakes.
"Addressing addiction in New York requires a coordinated statewide approach to get people the help they need," Governor Hochul said. "This funding will help better engage vulnerable communities in New York City, while providing transportation to individuals who would otherwise be unable to access treatment in Western New York and the Finger Lakes – supporting our nation leading addiction treatment services."
The funding will provide a total of $1.8 million to establish four New York City-based addiction prevention coalitions to better engage vulnerable populations and isolated communities in developing and implementing environmental change and prevention strategies. The coalitions will develop culturally appropriate and tailored prevention initiatives for underserved communities and populations.
The Archdiocese of NY Drug Abuse Prevention Program in Bronx County, CAMBA Inc. in Kings County, EImcor Youth & Adult Activities, Inc. in Queens County and the Staten Island Partnership for Community Wellness, Inc. in Richmond County will each receive $450,000 over the course of three years to establish a prevention coalition. Funding for the grants was provided through the federal Substance Abuse Prevention and Treatment Block Grant.
Additionally, the initiative will provide about $500,000 in state funding to a pair of pilot programs aimed at enhancing transportation services for individuals in active treatment or recovery, but who lack the resources to travel to these services. The Genesee Council on Alcoholism and Substance Abuse, Inc. in the Finger Lakes Region will receive $249,900 and Save the Michaels of the World in the Western New York Region will receive $250,000.
The awards will fund various transportation needs, including recreational activities likely to increase social connection or emotional well-being; recovery supports; peer interactions; formal or informal mutual support groups such as Self-Management and Recovery Training (SMART) and Alcoholics Anonymous or Narcotics Anonymous meetings; and rides to treatment or harm reduction services or to service providers. Data and information from this program will guide further expansion of these transportation services across the state.
Office of Addiction Services and Supports Commissioner Chinazo Cunningham said, "Meeting people wherever they are and ensuring full access to different types of help is one of the cornerstones of our work. With this funding to enhance prevention, treatment, harm reduction, and recovery supports across New York State, we are giving people more options to find the services they need, and I look forward to the many benefits these new programs will bring."
Representative Paul Tonko said, "Every day, we lose more loved ones to the disease of addiction. Despite our nation's worsening overdose epidemic, access to lifesaving treatment remains out of reach for Americans who need it most. For years, I've worked to improve and expand access to treatment, including through my Mainstreaming Addiction Treatment Act and to increase federal funding for the Substance Abuse Prevention and Treatment Block Grant, which provides critical funding for prevention, recovery, and treatment. I'm grateful to all those whose unwavering leadership and advocacy continue to provide hope and a path forward to those struggling."
Under Governor Hochul's leadership, New York State has instituted an aggressive, multi-pronged approach to addressing the overdose epidemic, and created a nation-leading continuum of addiction care with full prevention, treatment, recovery, and harm reduction services. The state has expanded access to traditional services, including crisis services, inpatient, outpatient, and residential treatment programs, as well as medication to treat addiction, and mobile treatment and transportation services.
Governor Hochul was a member of the New York State Heroin and Opioid Task Force, which recommended new, non-traditional services in 2016, including recovery centers, youth clubhouses, expanded peer services, and open access centers, which provide immediate assessments and referrals to care. These services have since been established in numerous communities around the state and have helped people in need access care closer to where they live.
New Yorkers struggling with an addiction, or whose loved ones are struggling, can find help and hope by calling the state's toll-free, 24-hour, 7-day-a-week HOPEline at 1-877-8-HOPENY (1-877-846-7369) or by texting HOPENY (Short Code 467369).
Available addiction treatment including crisis/detox, inpatient, residential, or outpatient care can be found using the NYS OASAS Treatment Availability Dashboard at FindAddictionTreatment.ny.gov or through the NYS OASAS website.
If you, or a loved one, have experienced insurance obstacles related to treatment or need help filing an appeal for a denied claim, contact the CHAMP helpline by phone at 888-614-5400 or email at ombuds@oasas.ny.gov.


The 'Information and Uncertainty in Data Science' Discussion Forum is a forum for open inquiry and discussion about a wide range of recurring data science fundamentals, including information, uncertainty, entropy, bits, probability, machine learning, generalization, and others. The group facilitates academic discourse on the practical use of the fundamental concepts across a wide variety of research disciplines, and strives for clarity and understanding using real-world scenarios, visual examples, cutting edge questions and unique perspectives. This group focusses on understanding and sharing concepts that are often buried in mathematical language, especially entropy, reduction of uncertainty and connections between physical systems and information systems. All interested members of the UC Berkeley, UCSF, LBL and LLNL communities are welcome and encouraged to attend. More details available at http://compdatascience.org/entropy. Contact: BIDS Senior Fellow Gerald Friedland.


text:
Posted 2:22 AM, June 2, 2019, by FOX59 Web, Updated at 06:34AM, June 2, 2019
Eric Middlebrook
INDIANAPOLIS, Ind. — Indianapolis Metropolitan police arrested a suspect after a man was shot and killed early Sunday morning in downtown Indianapolis.
Officers took 30-year-old Eric Middlebrook into custody in connection with the shooting, which happened around 1:30 a.m. Sunday near the intersection of South Meridian Street and East South Street. IMPD said an officer was patrolling nearby when he heard a gunshot coming from a nearby parking lot and observed a man chase after and shoot another man.
Officers with IMPD's Downtown District were dispatched and located a man suffering from at least one apparent gunshot wound. Emergency Medical Services personnel responded and pronounced the victim dead. The Marion County Coroner's Office identified the deceased as 33-year-old Jeffery Reed.
The shooting suspect, identified later as Middlebrook, was taken into custody for questioning. The Marion County Prosecutor's Office will review the case for a final charging decision. IMPD characterized the shooting as an isolated incident.
Police are asking anyone with information regarding the shooting to call the Indianapolis Metro Police Homicide Office at 317-327-3475 or contact Crime Stoppers at 317-262-TIPS.
IMPD credits 'beat policing' for capturing suspect in Sunday morning's downtown fatal shooting
IMPD: Shooting on city's near northeast side leaves man dead, woman hurt
Person injured in officer-involved shooting in Crawfordsville
IMPD arrests 2 suspects in shooting of Indiana judges
Marion man who allegedly shot victim who refused to give him cigarette now in custody
Man arrested in deadly shooting outside north side strip mall
IMPD officer in good condition after being shot on city's east side


Tachale Chamber Orchestra is a six member band based out of Gainesville, Florida which according to their Twitter profile, the description of their music is "Beatles, Beach Boys and Smiths playing at a funeral." I have to agree with them because their sound does remind me of the Beach Boys and a little of Beatles. I'll also add that their music is pretty dark and if you're in a mood to cry or just want to listen to something that might express some sadness then this is the music for you.
Their first song on the album "You'll Wish You Were Him" is depressing and has a sound of folk music set in the 1970's with hippies singing. The music to the track is nice and soothing, but I don't understand the point in the lyrics especially the line "His ears are full of wax." That's a bad visual for me: full of wax. Maybe I'm too analytical to get it, but just wondering why their songs are written the way they are. I may not get the whole idea of "chamber pop" which is how their music is described.
Next up, "Side of the Road" is another depressing song that is basically saying that they would have wished they could have seen someone die and told the dying individual a joke. Maybe it's a strange form of comfort for someone that they knew and this is a way to deal with their grief. The male vocalist singing has a lovely voice which is soothing and calm, but I couldn't help but wonder what's up with the theme of the album which seems to be: death. Then I remember the title of the album is "Ocean Floor Funeral".
"What's Your Home" is actually a beautiful song that I think is about someone who is dying (at least that's what I gathered based on the lyrics).
There are three more songs on the album; "The Verse Is Over", "Don't Wake Up" and "Cold Winter".
The album includes instrumental versions of all of their songs and I enjoyed the instrumental versions more because there were no lyrics. I can see myself listening just to the instrumental versions cooking or hanging around a campfire with friends.
Try their music out and who knows, they may be the next Beatles or Beach Boys to you and that is what really matters. You are the listener and buyer, and just maybe they can fill a void for you in your life or comfort you. I say go for it… buy it and try it.


text:
Haus Donk ist eine kleine ehemalige Wasserburg in Tönisvorst, Ortsteil Vorst im Kreis Viersen. Der Name Donk ist eine Bezeichnung für einen bebaubaren, erhöhten Platz in einem Sumpfgebiet.

Die Anfänge des Hauses Donk, lange Zeit ein kurkölnisches Mannlehen, gehen auf das Jahr 1259 zurück. Der rechte Fachwerkturm wurde gegen 900 n. Chr. ursprünglich von den Franken auf einer künstlich geschaffenen Anhöhe, einer Motte, errichtet. Er diente als wehrhafte Anlage im Falle der Bedrohung durch Feinde. Das täglich Leben erfolgte in der Vorburg, dem vorgelagerten Bauernhof, der ebenfalls mit einem heute noch erkennbaren Burggraben gesichert war. In den folgenden Jahrhunderten erfolgten weitere Anbauten, unter anderem ein um 1550 errichteter Renaissanceturm. Das heute sichtbare Herrenhaus ist nur Teil des alten, etwa dreimal größeren Herrenhauses. Die ehemalige Wasserburg galt als Grenzbefestigung des kurkölnischen Amtes Kempen gegen die Herzogtümer Jülich und Geldern.

Im 19. Jahrhundert wurde die Burg zerstört und in den 1970er Jahren wieder aufgebaut. Anfang der 1990er Jahre wurde Haus Donk von dem Unternehmer Rod Hützen erworben, komplett restauriert und um einen Unterflurtrakt, sowie diverser Anbauten auf der Südseite erweitert. Der Fachwerkturm erhielt ein neues Schieferdach mit vier Gauben. Nach der zweijährigen Renovierungsphase diente das Anwesen als Wohnsitz der Eigentümer. Die Rekonstruierung wurde durch den, auf Restaurierung spezialisierten Architekten Georg Rütten, umfassend durchgeführt. Nach Wegzug der Familie in das Ausland Anfang der 2000er Jahre wurde Haus Donk für Veranstaltungen und Firmenevents genutzt. Das Standesamt Tönisvorst nutzte u. a. den Rittersaal für standesamtliche Eheschließungen. Danach entschlossen sich die Eigentümer für eine dauerhafte Vermietung.

So war Haus Donk u. a. von 2004 bis 2007 der Wohnsitz des US-amerikanischen Fußballnationaltorhüters Kasey Keller, der für die Mannschaft von Borussia Mönchengladbach spielte.

Seit Februar 2020 finden weitere, umfangreiche Renovierungen statt, die Anfang 2021 abgeschlossen werden.

Weblinks

 Haus Donk auf der Webseite der Stadt Tönisvorst
 Haus Donk offizielle Website des Baudenkmals

Einzelnachweise

Baudenkmal in Tönisvorst
Tonisvorst
Donk
Donk
Bauwerk in Tönisvorst

redpajama_set_name: RedPajamaWikipedia


text:
package proguard.gui.splash;

import proguard.gui.SwingUtil;

import javax.swing.*;
import java.awt.*;
import java.awt.event.*;
import java.lang.reflect.InvocationTargetException;

/**
 * This JPanel renders an animated Sprite.
 *
 * @author Eric Lafortune
 */
public class SplashPanel extends JPanel
{
    private final MyAnimator  animator  = new MyAnimator();
    private final MyRepainter repainter = new MyRepainter();

    private final Sprite sprite;
    private final double sleepFactor;

    private long   startTime = Long.MAX_VALUE;
    private final long   stopTime;

    private volatile Thread animationThread;

    /**
     * Creates a new SplashPanel with the given Sprite, which will be animated
     * indefinitely.
     * @param sprite        the Sprite that will be animated.
     * @param processorLoad the fraction of processing time to be spend on
     *                      animating the Sprite (between 0 and 1).
     */
    public SplashPanel(Sprite sprite, double processorLoad)
    {
        this(sprite, processorLoad, (long)Integer.MAX_VALUE);
    }

    /**
     * Creates a new SplashPanel with the given Sprite, which will be animated
     * for a limited period of time.
     * @param sprite        the Sprite that will be animated.
     * @param processorLoad the fraction of processing time to be spend on
     *                      animating the Sprite (between 0 and 1).
     * @param stopTime      the number of milliseconds after which the
     *                      animation will be stopped automatically.
     */
    public SplashPanel(Sprite sprite, double processorLoad, long stopTime)
    {
        this.sprite      = sprite;
        this.sleepFactor = (1.0-processorLoad) / processorLoad;
        this.stopTime    = stopTime;

        // Restart the animation on a mouse click.
        addMouseListener(new MouseAdapter()
        {
            public void mouseClicked(MouseEvent e)
            {
                SplashPanel.this.start();
            }
        });
    }

    /**
     * Starts the animation.
     */
    public void start()
    {
        // Go to the beginning of the animation.
        startTime = System.currentTimeMillis();

        // Make sure we have an animation thread running.
        if (animationThread == null)
        {
            animationThread = new Thread(animator);
            animationThread.start();
        }
    }

    /**
     * Stops the animation.
     */
    public void stop()
    {
        // Go to the end of the animation.
        startTime = 0L;

        // Let the animation thread stop itself.
        animationThread = null;

        // Repaint the SplashPanel one last time.
        try
        {
            SwingUtil.invokeAndWait(repainter);
        }
        catch (InterruptedException ex)
        {
            // Nothing.
        }
        catch (InvocationTargetException ex)
        {
            // Nothing.
        }
    }

    // Implementation for JPanel.

    public void paintComponent(Graphics graphics)
    {
        super.paintComponent(graphics);

        sprite.paint(graphics, System.currentTimeMillis() - startTime);
    }

    /**
     * This Runnable makes sure its SplashPanel gets repainted regularly,
     * depending on the targeted processor load.
     */
    private class MyAnimator implements Runnable
    {
        public void run()
        {
            try
            {
                while (animationThread != null)
                {
                    // Check if we should stop the animation.
                    long time = System.currentTimeMillis();
                    if (time > startTime + stopTime)
                    {
                        animationThread = null;
                    }

                    // Do a repaint and time it.
                    SwingUtil.invokeAndWait(repainter);

                    // Sleep for a proportional while.
                    long repaintTime = System.currentTimeMillis() - time;
                    long sleepTime   = (long)(sleepFactor * repaintTime);
                    if (sleepTime < 10L)
                    {
                        sleepTime = 10L;
                    }

                    Thread.sleep(sleepTime);
                }
            }
            catch (InterruptedException ex)
            {
                // Nothing.
            }
            catch (InvocationTargetException ex)
            {
                // Nothing.
            }
        }
    }

    /**
     * This Runnable repaints its SplashPanel.
     */
    private class MyRepainter implements Runnable
    {
        public void run()
        {
            SplashPanel.this.repaint();
        }
    }

    /**
     * A main method for testing the splash panel.
     */
    public static void main(String[] args)
    {
        JFrame frame = new JFrame();
        frame.setTitle("Animation");
        frame.setSize(800, 600);
        Dimension screenSize = Toolkit.getDefaultToolkit().getScreenSize();
        Dimension frameSize  = frame.getSize();
        frame.setLocation((screenSize.width - frameSize.width)   / 2,
                          (screenSize.height - frameSize.height) / 2);

        Sprite sprite =
            new ClipSprite(
            new ConstantColor(Color.white),
            new ConstantColor(Color.lightGray),
            new CircleSprite(true,
                             new LinearInt(200, 600, new SineTiming(2345L, 0L)),
                             new LinearInt(200, 400, new SineTiming(3210L, 0L)),
                             new ConstantInt(150)),
            new ColorSprite(new ConstantColor(Color.gray),
            new FontSprite(new ConstantFont(new Font("sansserif", Font.BOLD, 90)),
            new TextSprite(new ConstantString("ProGuard"),
                           new ConstantInt(200),
                           new ConstantInt(300)))));

        SplashPanel panel = new SplashPanel(sprite, 0.5);
        panel.setBackground(Color.white);

        frame.getContentPane().add(panel);
        frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        frame.setVisible(true);

        panel.start();
    }
}


text:
"""Python wrappers around Brain.

This file is MACHINE GENERATED! Do not edit.
"""

from google.protobuf import text_format

from tensorflow.core.framework import op_def_pb2
from tensorflow.python.framework import op_def_registry
from tensorflow.python.framework import ops
from tensorflow.python.ops import op_def_library

def _delete_session_tensor(handle, name=None):
  r"""Delete the tensor specified by its handle in the session.

  Args:
    handle: A `Tensor` of type `string`.
      The handle for a tensor stored in the session state.
    name: A name for the operation (optional).

  Returns:
    The created Operation.
  """
  return _op_def_lib.apply_op("DeleteSessionTensor", handle=handle, name=name)

def dynamic_partition(data, partitions, num_partitions, name=None):
  r"""Partitions `data` into `num_partitions` tensors using indices from `partitions`.

  For each index tuple `js` of size `partitions.ndim`, the slice `data[js, ...]`
  becomes part of `outputs[partitions[js]]`.  The slices with `partitions[js] = i`
  are placed in `outputs[i]` in lexicographic order of `js`, and the first
  dimension of `outputs[i]` is the number of entries in `partitions` equal to `i`.
  In detail,

      outputs[i].shape = [sum(partitions == i)] + data.shape[partitions.ndim:]

      outputs[i] = pack([data[js, ...] for js if partitions[js] == i])

  `data.shape` must start with `partitions.shape`.

  For example:

      # Scalar partitions
      partitions = 1
      num_partitions = 2
      data = [10, 20]
      outputs[0] = []  # Empty with shape [0, 2]
      outputs[1] = [[10, 20]]

      # Vector partitions
      partitions = [0, 0, 1, 1, 0]
      num_partitions = 2
      data = [10, 20, 30, 40, 50]
      outputs[0] = [10, 20, 50]
      outputs[1] = [30, 40]

  Args:
    data: A `Tensor`.
    partitions: A `Tensor` of type `int32`.
      Any shape.  Indices in the range `[0, num_partitions)`.
    num_partitions: An `int` that is `>= 1`.
      The number of partitions to output.
    name: A name for the operation (optional).

  Returns:
    A list of `num_partitions` `Tensor` objects of the same type as data.
  """
  return _op_def_lib.apply_op("DynamicPartition", data=data,
                              partitions=partitions,
                              num_partitions=num_partitions, name=name)

def dynamic_stitch(indices, data, name=None):
  r"""Interleave the values from the `data` tensors into a single tensor.

  Builds a merged tensor such that

      merged[indices[m][i, ..., j], ...] = data[m][i, ..., j, ...]

  For example, if each `indices[m]` is scalar or vector, we have

      # Scalar indices
      merged[indices[m], ...] = data[m][...]

      # Vector indices
      merged[indices[m][i], ...] = data[m][i, ...]

  Each `data[i].shape` must start with the corresponding `indices[i].shape`,
  and the rest of `data[i].shape` must be constant w.r.t. `i`.  That is, we
  must have `data[i].shape = indices[i].shape + constant`.  In terms of this
  `constant`, the output shape is

      merged.shape = [max(indices)] + constant

  Values are merged in order, so if an index appears in both `indices[m][i]` and
  `indices[n][j]` for `(m,i) < (n,j)` the slice `data[n][j]` will appear in the
  merged result.

  For example:

      indices[0] = 6
      indices[1] = [4, 1]
      indices[2] = [[5, 2], [0, 3]]
      data[0] = [61, 62]
      data[1] = [[41, 42], [11, 12]]
      data[2] = [[[51, 52], [21, 22]], [[1, 2], [31, 32]]]
      merged = [[1, 2], [11, 12], [21, 22], [31, 32], [41, 42],
                [51, 52], [61, 62]]

  Args:
    indices: A list of at least 2 `Tensor` objects of type `int32`.
    data: A list with the same number of `Tensor` objects as `indices` of `Tensor` objects of the same type.
    name: A name for the operation (optional).

  Returns:
    A `Tensor`. Has the same type as `data`.
  """
  return _op_def_lib.apply_op("DynamicStitch", indices=indices, data=data,
                              name=name)

def _fifo_queue(component_types, shapes=None, capacity=None, container=None,
                shared_name=None, name=None):
  r"""A queue that produces elements in first-in first-out order.

  Args:
    component_types: A list of `tf.DTypes` that has length `>= 1`.
      The type of each component in a value.
    shapes: An optional list of shapes (each a `tf.TensorShape` or list of `ints`). Defaults to `[]`.
      The shape of each component in a value. The length of this attr must
      be either 0 or the same as the length of component_types. If the length of
      this attr is 0, the shapes of queue elements are not constrained, and
      only one element may be dequeued at a time.
    capacity: An optional `int`. Defaults to `-1`.
      The upper bound on the number of elements in this queue.
      Negative numbers mean no limit.
    container: An optional `string`. Defaults to `""`.
      If non-empty, this queue is placed in the given container.
      Otherwise, a default container is used.
    shared_name: An optional `string`. Defaults to `""`.
      If non-empty, this queue will be shared under the given name
      across multiple sessions.
    name: A name for the operation (optional).

  Returns:
    A `Tensor` of type mutable `string`. The handle to the queue.
  """
  return _op_def_lib.apply_op("FIFOQueue", component_types=component_types,
                              shapes=shapes, capacity=capacity,
                              container=container, shared_name=shared_name,
                              name=name)

def _get_session_handle(value, name=None):
  r"""Store the input tensor in the state of the current session.

  Args:
    value: A `Tensor`. The tensor to be stored.
    name: A name for the operation (optional).

  Returns:
    A `Tensor` of type `string`.
    The handle for the tensor stored in the session state.
  """
  return _op_def_lib.apply_op("GetSessionHandle", value=value, name=name)

def _get_session_tensor(handle, dtype, name=None):
  r"""Get the value of the tensor specified by its handle.

  Args:
    handle: A `Tensor` of type `string`.
      The handle for a tensor stored in the session state.
    dtype: A `tf.DType`. The type of the output value.
    name: A name for the operation (optional).

  Returns:
    A `Tensor` of type `dtype`. The tensor for the given handle.
  """
  return _op_def_lib.apply_op("GetSessionTensor", handle=handle, dtype=dtype,
                              name=name)

def _hash_table(key_dtype, value_dtype, container=None, shared_name=None,
                name=None):
  r"""Creates a non-initialized hash table.

  This op creates a hash table, specifying the type of its keys and values.
  Before using the table you will have to initialize it.  After initialization the
  table will be immutable.

  Args:
    key_dtype: A `tf.DType`. Type of the table keys.
    value_dtype: A `tf.DType`. Type of the table values.
    container: An optional `string`. Defaults to `""`.
      If non-empty, this table is placed in the given container.
      Otherwise, a default container is used.
    shared_name: An optional `string`. Defaults to `""`.
      If non-empty, this table is shared under the given name across
      multiple sessions.
    name: A name for the operation (optional).

  Returns:
    A `Tensor` of type mutable `string`. Handle to a table.
  """
  return _op_def_lib.apply_op("HashTable", key_dtype=key_dtype,
                              value_dtype=value_dtype, container=container,
                              shared_name=shared_name, name=name)

def _initialize_table(table_handle, keys, values, name=None):
  r"""Table initializer that takes two tensors for keys and values respectively.

  Args:
    table_handle: A `Tensor` of type mutable `string`.
      Handle to a table which will be initialized.
    keys: A `Tensor`. Keys of type Tkey.
    values: A `Tensor`. Values of type Tval. Same shape as `keys`.
    name: A name for the operation (optional).

  Returns:
    The created Operation.
  """
  return _op_def_lib.apply_op("InitializeTable", table_handle=table_handle,
                              keys=keys, values=values, name=name)

def _lookup_table_find(table_handle, keys, default_value, name=None):
  r"""Looks up keys in a table, outputs the corresponding values.

  The tensor `keys` must of the same type as the keys of the table.
  The output `values` is of the type of the table values.

  The scalar `default_value` is the value output for keys not present in the
  table. It must also be of the same type as the table values.

  Args:
    table_handle: A `Tensor` of type mutable `string`. Handle to the table.
    keys: A `Tensor`. Any shape.  Keys to look up.
    default_value: A `Tensor`.
    name: A name for the operation (optional).

  Returns:
    A `Tensor`. Has the same type as `default_value`.
    Same shape as `keys`.  Values found in the table, or `default_values`
    for missing keys.
  """
  return _op_def_lib.apply_op("LookupTableFind", table_handle=table_handle,
                              keys=keys, default_value=default_value,
                              name=name)

def _lookup_table_size(table_handle, name=None):
  r"""Computes the number of elements in the given table.

  Args:
    table_handle: A `Tensor` of type mutable `string`. Handle to the table.
    name: A name for the operation (optional).

  Returns:
    A `Tensor` of type `int64`.
    Scalar that contains number of elements in the table.
  """
  return _op_def_lib.apply_op("LookupTableSize", table_handle=table_handle,
                              name=name)

def _padding_fifo_queue(component_types, shapes=None, capacity=None,
                        container=None, shared_name=None, name=None):
  r"""A queue that produces elements in first-in first-out order.

  Variable-size shapes are allowed by setting the corresponding shape dimensions
  to 0 in the shape attr.  In this case DequeueMany will pad up to the maximum
  size of any given element in the minibatch.  See below for details.

  Args:
    component_types: A list of `tf.DTypes` that has length `>= 1`.
      The type of each component in a value.
    shapes: An optional list of shapes (each a `tf.TensorShape` or list of `ints`). Defaults to `[]`.
      The shape of each component in a value. The length of this attr must
      be either 0 or the same as the length of component_types.
      Shapes of fixed rank but variable size are allowed by setting
      any shape dimension to -1.  In this case, the inputs' shape may vary along
      the given dimension, and DequeueMany will pad the given dimension with
      zeros up to the maximum shape of all elements in the given batch.
      If the length of this attr is 0, different queue elements may have
      different ranks and shapes, but only one element may be dequeued at a time.
    capacity: An optional `int`. Defaults to `-1`.
      The upper bound on the number of elements in this queue.
      Negative numbers mean no limit.
    container: An optional `string`. Defaults to `""`.
      If non-empty, this queue is placed in the given container.
      Otherwise, a default container is used.
    shared_name: An optional `string`. Defaults to `""`.
      If non-empty, this queue will be shared under the given name
      across multiple sessions.
    name: A name for the operation (optional).

  Returns:
    A `Tensor` of type mutable `string`. The handle to the queue.
  """
  return _op_def_lib.apply_op("PaddingFIFOQueue",
                              component_types=component_types, shapes=shapes,
                              capacity=capacity, container=container,
                              shared_name=shared_name, name=name)

def _queue_close(handle, cancel_pending_enqueues=None, name=None):
  r"""Closes the given queue.

  This operation signals that no more elements will be enqueued in the
  given queue. Subsequent Enqueue(Many) operations will fail.
  Subsequent Dequeue(Many) operations will continue to succeed if
  sufficient elements remain in the queue. Subsequent Dequeue(Many)
  operations that would block will fail immediately.

  Args:
    handle: A `Tensor` of type mutable `string`. The handle to a queue.
    cancel_pending_enqueues: An optional `bool`. Defaults to `False`.
      If true, all pending enqueue requests that are
      blocked on the given queue will be cancelled.
    name: A name for the operation (optional).

  Returns:
    The created Operation.
  """
  return _op_def_lib.apply_op("QueueClose", handle=handle,
                              cancel_pending_enqueues=cancel_pending_enqueues,
                              name=name)

def _queue_dequeue(handle, component_types, timeout_ms=None, name=None):
  r"""Dequeues a tuple of one or more tensors from the given queue.

  This operation has k outputs, where k is the number of components
  in the tuples stored in the given queue, and output i is the ith
  component of the dequeued tuple.

  N.B. If the queue is empty, this operation will block until an element
  has been dequeued (or 'timeout_ms' elapses, if specified).

  Args:
    handle: A `Tensor` of type mutable `string`. The handle to a queue.
    component_types: A list of `tf.DTypes` that has length `>= 1`.
      The type of each component in a tuple.
    timeout_ms: An optional `int`. Defaults to `-1`.
      If the queue is empty, this operation will block for up to
      timeout_ms milliseconds.
      Note: This option is not supported yet.
    name: A name for the operation (optional).

  Returns:
    A list of `Tensor` objects of type `component_types`.
    One or more tensors that were dequeued as a tuple.
  """
  return _op_def_lib.apply_op("QueueDequeue", handle=handle,
                              component_types=component_types,
                              timeout_ms=timeout_ms, name=name)

def _queue_dequeue_many(handle, n, component_types, timeout_ms=None,
                        name=None):
  r"""Dequeues n tuples of one or more tensors from the given queue.

  If the queue is closed and there are fewer than n elements, then an
  OutOfRange error is returned.

  This operation concatenates queue-element component tensors along the
  0th dimension to make a single component tensor.  All of the components
  in the dequeued tuple will have size n in the 0th dimension.

  This operation has k outputs, where k is the number of components in
  the tuples stored in the given queue, and output i is the ith
  component of the dequeued tuple.

  N.B. If the queue is empty, this operation will block until n elements
  have been dequeued (or 'timeout_ms' elapses, if specified).

  Args:
    handle: A `Tensor` of type mutable `string`. The handle to a queue.
    n: A `Tensor` of type `int32`. The number of tuples to dequeue.
    component_types: A list of `tf.DTypes` that has length `>= 1`.
      The type of each component in a tuple.
    timeout_ms: An optional `int`. Defaults to `-1`.
      If the queue has fewer than n elements, this operation
      will block for up to timeout_ms milliseconds.
      Note: This option is not supported yet.
    name: A name for the operation (optional).

  Returns:
    A list of `Tensor` objects of type `component_types`.
    One or more tensors that were dequeued as a tuple.
  """
  return _op_def_lib.apply_op("QueueDequeueMany", handle=handle, n=n,
                              component_types=component_types,
                              timeout_ms=timeout_ms, name=name)

def _queue_dequeue_up_to(handle, n, component_types, timeout_ms=None,
                         name=None):
  r"""Dequeues n tuples of one or more tensors from the given queue.

  This operation is not supported by all queues.  If a queue does not support
  DequeueUpTo, then an Unimplemented error is returned.

  If the queue is closed and there are more than 0 but less than n elements
  remaining, then instead of returning an OutOfRange error like
  QueueDequeueMany, the remaining elements are returned immediately.  If the queue
  is closed and there are 0 elements left in the queue, then an OutOfRange
  error is returned just like in QueueDequeueMany.  Otherwise the behavior
  is identical to QueueDequeueMany:

  This operation concatenates queue-element component tensors along the
  0th dimension to make a single component tensor.  All of the components
  in the dequeued tuple will have size n in the 0th dimension.

  This operation has k outputs, where k is the number of components in
  the tuples stored in the given queue, and output i is the ith
  component of the dequeued tuple.

  Args:
    handle: A `Tensor` of type mutable `string`. The handle to a queue.
    n: A `Tensor` of type `int32`. The number of tuples to dequeue.
    component_types: A list of `tf.DTypes` that has length `>= 1`.
      The type of each component in a tuple.
    timeout_ms: An optional `int`. Defaults to `-1`.
      If the queue has fewer than n elements, this operation
      will block for up to timeout_ms milliseconds.
      Note: This option is not supported yet.
    name: A name for the operation (optional).

  Returns:
    A list of `Tensor` objects of type `component_types`.
    One or more tensors that were dequeued as a tuple.
  """
  return _op_def_lib.apply_op("QueueDequeueUpTo", handle=handle, n=n,
                              component_types=component_types,
                              timeout_ms=timeout_ms, name=name)

def _queue_enqueue(handle, components, timeout_ms=None, name=None):
  r"""Enqueues a tuple of one or more tensors in the given queue.

  The components input has k elements, which correspond to the components of
  tuples stored in the given queue.

  N.B. If the queue is full, this operation will block until the given
  element has been enqueued (or 'timeout_ms' elapses, if specified).

  Args:
    handle: A `Tensor` of type mutable `string`. The handle to a queue.
    components: A list of `Tensor` objects.
      One or more tensors from which the enqueued tensors should be taken.
    timeout_ms: An optional `int`. Defaults to `-1`.
      If the queue is full, this operation will block for up to
      timeout_ms milliseconds.
      Note: This option is not supported yet.
    name: A name for the operation (optional).

  Returns:
    The created Operation.
  """
  return _op_def_lib.apply_op("QueueEnqueue", handle=handle,
                              components=components, timeout_ms=timeout_ms,
                              name=name)

def _queue_enqueue_many(handle, components, timeout_ms=None, name=None):
  r"""Enqueues zero or more tuples of one or more tensors in the given queue.

  This operation slices each component tensor along the 0th dimension to
  make multiple queue elements. All of the tuple components must have the
  same size in the 0th dimension.

  The components input has k elements, which correspond to the components of
  tuples stored in the given queue.

  N.B. If the queue is full, this operation will block until the given
  elements have been enqueued (or 'timeout_ms' elapses, if specified).

  Args:
    handle: A `Tensor` of type mutable `string`. The handle to a queue.
    components: A list of `Tensor` objects.
      One or more tensors from which the enqueued tensors should
      be taken.
    timeout_ms: An optional `int`. Defaults to `-1`.
      If the queue is too full, this operation will block for up
      to timeout_ms milliseconds.
      Note: This option is not supported yet.
    name: A name for the operation (optional).

  Returns:
    The created Operation.
  """
  return _op_def_lib.apply_op("QueueEnqueueMany", handle=handle,
                              components=components, timeout_ms=timeout_ms,
                              name=name)

def _queue_size(handle, name=None):
  r"""Computes the number of elements in the given queue.

  Args:
    handle: A `Tensor` of type mutable `string`. The handle to a queue.
    name: A name for the operation (optional).

  Returns:
    A `Tensor` of type `int32`. The number of elements in the given queue.
  """
  return _op_def_lib.apply_op("QueueSize", handle=handle, name=name)

def _random_shuffle_queue(component_types, shapes=None, capacity=None,
                          min_after_dequeue=None, seed=None, seed2=None,
                          container=None, shared_name=None, name=None):
  r"""A queue that randomizes the order of elements.

  Args:
    component_types: A list of `tf.DTypes` that has length `>= 1`.
      The type of each component in a value.
    shapes: An optional list of shapes (each a `tf.TensorShape` or list of `ints`). Defaults to `[]`.
      The shape of each component in a value. The length of this attr must
      be either 0 or the same as the length of component_types. If the length of
      this attr is 0, the shapes of queue elements are not constrained, and
      only one element may be dequeued at a time.
    capacity: An optional `int`. Defaults to `-1`.
      The upper bound on the number of elements in this queue.
      Negative numbers mean no limit.
    min_after_dequeue: An optional `int`. Defaults to `0`.
      Dequeue will block unless there would be this
      many elements after the dequeue or the queue is closed. This
      ensures a minimum level of mixing of elements.
    seed: An optional `int`. Defaults to `0`.
      If either seed or seed2 is set to be non-zero, the random number
      generator is seeded by the given seed.  Otherwise, a random seed is used.
    seed2: An optional `int`. Defaults to `0`.
      A second seed to avoid seed collision.
    container: An optional `string`. Defaults to `""`.
      If non-empty, this queue is placed in the given container.
      Otherwise, a default container is used.
    shared_name: An optional `string`. Defaults to `""`.
      If non-empty, this queue will be shared under the given name
      across multiple sessions.
    name: A name for the operation (optional).

  Returns:
    A `Tensor` of type mutable `string`. The handle to the queue.
  """
  return _op_def_lib.apply_op("RandomShuffleQueue",
                              component_types=component_types, shapes=shapes,
                              capacity=capacity,
                              min_after_dequeue=min_after_dequeue, seed=seed,
                              seed2=seed2, container=container,
                              shared_name=shared_name, name=name)

def _stack(elem_type, stack_name=None, name=None):
  r"""A stack that produces elements in first-in last-out order.

  Args:
    elem_type: A `tf.DType`. The type of the elements on the stack.
    stack_name: An optional `string`. Defaults to `""`.
      Overrides the name used for the temporary stack resource. Default
      value is the name of the 'Stack' op (which is guaranteed unique).
    name: A name for the operation (optional).

  Returns:
    A `Tensor` of type mutable `string`. The handle to the stack.
  """
  return _op_def_lib.apply_op("Stack", elem_type=elem_type,
                              stack_name=stack_name, name=name)

def _stack_close(handle, name=None):
  r"""Delete the stack from its resource container.

  Args:
    handle: A `Tensor` of type mutable `string`. The handle to a stack.
    name: A name for the operation (optional).

  Returns:
    The created Operation.
  """
  return _op_def_lib.apply_op("StackClose", handle=handle, name=name)

def _stack_pop(handle, elem_type, name=None):
  r"""Pop the element at the top of the stack.

  Args:
    handle: A `Tensor` of type mutable `string`. The handle to a stack.
    elem_type: A `tf.DType`. The type of the elem that is popped.
    name: A name for the operation (optional).

  Returns:
    A `Tensor` of type `elem_type`.
    The tensor that is popped from the top of the stack.
  """
  return _op_def_lib.apply_op("StackPop", handle=handle, elem_type=elem_type,
                              name=name)

def _stack_push(handle, elem, swap_memory=None, name=None):
  r"""Push an element onto the stack.

  Args:
    handle: A `Tensor` of type mutable `string`. The handle to a stack.
    elem: A `Tensor`. The tensor to be pushed onto the stack.
    swap_memory: An optional `bool`. Defaults to `False`.
      Swap `elem` to CPU. Default to false.
    name: A name for the operation (optional).

  Returns:
    A `Tensor`. Has the same type as `elem`.
    The same tensor as the input 'elem'.
  """
  return _op_def_lib.apply_op("StackPush", handle=handle, elem=elem,
                              swap_memory=swap_memory, name=name)

def _tensor_array(size, dtype, dynamic_size=None, clear_after_read=None,
                  tensor_array_name=None, name=None):
  r"""An array of Tensors of given size, with data written via Write and read

  via Read or Pack.

  Args:
    size: A `Tensor` of type `int32`. The size of the array.
    dtype: A `tf.DType`. The type of the elements on the tensor_array.
    dynamic_size: An optional `bool`. Defaults to `False`.
      A boolean that determines whether writes to the TensorArray
      are allowed to grow the size.  By default, this is not allowed.
    clear_after_read: An optional `bool`. Defaults to `True`.
      If true (default), Tensors in the TensorArray are cleared
      after being read.  This disables multiple read semantics but allows early
      release of memory.
    tensor_array_name: An optional `string`. Defaults to `""`.
      Overrides the name used for the temporary tensor_array
      resource. Default value is the name of the 'TensorArray' op (which
      is guaranteed unique).
    name: A name for the operation (optional).

  Returns:
    A `Tensor` of type mutable `string`. The handle to the TensorArray.
  """
  return _op_def_lib.apply_op("TensorArray", size=size, dtype=dtype,
                              dynamic_size=dynamic_size,
                              clear_after_read=clear_after_read,
                              tensor_array_name=tensor_array_name, name=name)

def _tensor_array_close(handle, name=None):
  r"""Delete the TensorArray from its resource container.  This enables

  the user to close and release the resource in the middle of a step/run.

  Args:
    handle: A `Tensor` of type mutable `string`.
      The handle to a TensorArray (output of TensorArray or TensorArrayGrad).
    name: A name for the operation (optional).

  Returns:
    The created Operation.
  """
  return _op_def_lib.apply_op("TensorArrayClose", handle=handle, name=name)

def _tensor_array_concat(handle, flow_in, dtype, name=None):
  r"""Concat the elements from the TensorArray into value `value`.

  Takes `T` elements of shapes

    ```
    (n0 x d0 x d1 x ...), (n1 x d0 x d1 x ...), ..., (n(T-1) x d0 x d1 x ...)
    ```

  and concatenates them into a Tensor of shape:

    ```(n0 + n1 + ... + n(T-1) x d0 x d1 x ...)```

  All elements must have the same shape (excepting the first dimension).

  Args:
    handle: A `Tensor` of type mutable `string`. The handle to a TensorArray.
    flow_in: A `Tensor` of type `float32`.
      A float scalar that enforces proper chaining of operations.
    dtype: A `tf.DType`. The type of the elem that is returned.
    name: A name for the operation (optional).

  Returns:
    A tuple of `Tensor` objects (value, lengths).
    value: A `Tensor` of type `dtype`. All of the elements in the TensorArray, concatenated along the first
      axis.
    lengths: A `Tensor` of type `int64`. A vector of the row sizes of the original T elements in the
      value output.  In the example above, this would be the values:
      `(n1, n2, ..., n(T-1))`.
  """
  return _op_def_lib.apply_op("TensorArrayConcat", handle=handle,
                              flow_in=flow_in, dtype=dtype, name=name)

def _tensor_array_grad(handle, flow_in, source, name=None):
  r"""Creates a TensorArray for storing the gradients of values in the given handle.

  If the given TensorArray gradient already exists, returns a reference to it.

  Locks the size of the original TensorArray by disabling its dynamic size flag.

  **A note about the input flow_in:**

  The handle flow_in forces the execution of the gradient lookup to occur
  only after certain other operations have occurred.  For example, when
  the forward TensorArray is dynamically sized, writes to this TensorArray
  may resize the object.  The gradient TensorArray is statically sized based
  on the size of the forward TensorArray when this operation executes.
  Furthermore, the size of the forward TensorArray is frozen by this call.
  As a result, the flow is used to ensure that the call to generate the gradient
  TensorArray only happens after all writes are executed.

  In terms of e.g. python TensorArray sugar wrappers when using dynamically sized

  Args:
    handle: A `Tensor` of type mutable `string`.
    flow_in: A `Tensor` of type `float32`.
    source: A `string`.
    name: A name for the operation (optional).

  Returns:
    A `Tensor` of type mutable `string`.
  """
  return _op_def_lib.apply_op("TensorArrayGrad", handle=handle,
                              flow_in=flow_in, source=source, name=name)

def _tensor_array_pack(handle, flow_in, dtype, name=None):
  r"""Pack the elements from the TensorArray into output `value`.

  All elements must have the same shape.

  Args:
    handle: A `Tensor` of type mutable `string`. The handle to a TensorArray.
    flow_in: A `Tensor` of type `float32`.
      A float scalar that enforces proper chaining of operations.
    dtype: A `tf.DType`. The type of the elem that is returned.
    name: A name for the operation (optional).

  Returns:
    A `Tensor` of type `dtype`.
    All of the elements in the TensorArray, concatenated along a new
    axis (the new dimension 0).
  """
  return _op_def_lib.apply_op("TensorArrayPack", handle=handle,
                              flow_in=flow_in, dtype=dtype, name=name)

def _tensor_array_read(handle, index, flow_in, dtype, name=None):
  r"""Read an element from the TensorArray into output `value`.

  Args:
    handle: A `Tensor` of type mutable `string`. The handle to a TensorArray.
    index: A `Tensor` of type `int32`.
    flow_in: A `Tensor` of type `float32`.
      A float scalar that enforces proper chaining of operations.
    dtype: A `tf.DType`. The type of the elem that is returned.
    name: A name for the operation (optional).

  Returns:
    A `Tensor` of type `dtype`. The tensor that is read from the TensorArray.
  """
  return _op_def_lib.apply_op("TensorArrayRead", handle=handle, index=index,
                              flow_in=flow_in, dtype=dtype, name=name)

def _tensor_array_size(handle, flow_in, name=None):
  r"""Get the current size of the TensorArray.

  Args:
    handle: A `Tensor` of type mutable `string`.
      The handle to a TensorArray (output of TensorArray or TensorArrayGrad).
    flow_in: A `Tensor` of type `float32`.
      A float scalar that enforces proper chaining of operations.
    name: A name for the operation (optional).

  Returns:
    A `Tensor` of type `int32`. The current size of the TensorArray.
  """
  return _op_def_lib.apply_op("TensorArraySize", handle=handle,
                              flow_in=flow_in, name=name)

def _tensor_array_split(handle, value, lengths, flow_in, name=None):
  r"""Split the data from the input value into TensorArray elements.

  Assuming that `lengths` takes on values

    ```(n0, n1, ..., n(T-1))```

  and that `value` has shape

    ```(n0 + n1 + ... + n(T-1) x d0 x d1 x ...)```,

  this splits values into a TensorArray with T tensors.

  TensorArray index t will be the subtensor of values with starting position

    ```(n0 + n1 + ... + n(t-1), 0, 0, ...)```

  and having size

    ```nt x d0 x d1 x ...```

  Args:
    handle: A `Tensor` of type mutable `string`. The handle to a TensorArray.
    value: A `Tensor`. The concatenated tensor to write to the TensorArray.
    lengths: A `Tensor` of type `int64`.
      The vector of lengths, how to split the rows of value into the
      TensorArray.
    flow_in: A `Tensor` of type `float32`.
      A float scalar that enforces proper chaining of operations.
    name: A name for the operation (optional).

  Returns:
    A `Tensor` of type `float32`.
    A float scalar that enforces proper chaining of operations.
  """
  return _op_def_lib.apply_op("TensorArraySplit", handle=handle, value=value,
                              lengths=lengths, flow_in=flow_in, name=name)

def _tensor_array_unpack(handle, value, flow_in, name=None):
  r"""Unpack the data from the input value into TensorArray elements.

  Args:
    handle: A `Tensor` of type mutable `string`. The handle to a TensorArray.
    value: A `Tensor`. The concatenated tensor to write to the TensorArray.
    flow_in: A `Tensor` of type `float32`.
      A float scalar that enforces proper chaining of operations.
    name: A name for the operation (optional).

  Returns:
    A `Tensor` of type `float32`.
    A float scalar that enforces proper chaining of operations.
  """
  return _op_def_lib.apply_op("TensorArrayUnpack", handle=handle, value=value,
                              flow_in=flow_in, name=name)

def _tensor_array_write(handle, index, value, flow_in, name=None):
  r"""Push an element onto the tensor_array.

  Args:
    handle: A `Tensor` of type mutable `string`. The handle to a TensorArray.
    index: A `Tensor` of type `int32`.
      The position to write to inside the TensorArray.
    value: A `Tensor`. The tensor to write to the TensorArray.
    flow_in: A `Tensor` of type `float32`.
      A float scalar that enforces proper chaining of operations.
    name: A name for the operation (optional).

  Returns:
    A `Tensor` of type `float32`.
    A float scalar that enforces proper chaining of operations.
  """
  return _op_def_lib.apply_op("TensorArrayWrite", handle=handle, index=index,
                              value=value, flow_in=flow_in, name=name)

def _InitOpDefLibrary():
  op_list = op_def_pb2.OpList()
  text_format.Merge(_InitOpDefLibrary.op_list_ascii, op_list)
  op_def_registry.register_op_list(op_list)
  op_def_lib = op_def_library.OpDefLibrary()
  op_def_lib.add_op_list(op_list)
  return op_def_lib

_InitOpDefLibrary.op_list_ascii = """op {
  name: "DeleteSessionTensor"
  input_arg {
    name: "handle"
    type: DT_STRING
  }
}
op {
  name: "DynamicPartition"
  input_arg {
    name: "data"
    type_attr: "T"
  }
  input_arg {
    name: "partitions"
    type: DT_INT32
  }
  output_arg {
    name: "outputs"
    type_attr: "T"
    number_attr: "num_partitions"
  }
  attr {
    name: "num_partitions"
    type: "int"
    has_minimum: true
    minimum: 1
  }
  attr {
    name: "T"
    type: "type"
  }
}
op {
  name: "DynamicStitch"
  input_arg {
    name: "indices"
    type: DT_INT32
    number_attr: "N"
  }
  input_arg {
    name: "data"
    type_attr: "T"
    number_attr: "N"
  }
  output_arg {
    name: "merged"
    type_attr: "T"
  }
  attr {
    name: "N"
    type: "int"
    has_minimum: true
    minimum: 2
  }
  attr {
    name: "T"
    type: "type"
  }
}
op {
  name: "FIFOQueue"
  output_arg {
    name: "handle"
    type: DT_STRING
    is_ref: true
  }
  attr {
    name: "component_types"
    type: "list(type)"
    has_minimum: true
    minimum: 1
  }
  attr {
    name: "shapes"
    type: "list(shape)"
    default_value {
      list {
      }
    }
    has_minimum: true
  }
  attr {
    name: "capacity"
    type: "int"
    default_value {
      i: -1
    }
  }
  attr {
    name: "container"
    type: "string"
    default_value {
      s: ""
    }
  }
  attr {
    name: "shared_name"
    type: "string"
    default_value {
      s: ""
    }
  }
  is_stateful: true
}
op {
  name: "GetSessionHandle"
  input_arg {
    name: "value"
    type_attr: "T"
  }
  output_arg {
    name: "handle"
    type: DT_STRING
  }
  attr {
    name: "T"
    type: "type"
  }
}
op {
  name: "GetSessionTensor"
  input_arg {
    name: "handle"
    type: DT_STRING
  }
  output_arg {
    name: "value"
    type_attr: "dtype"
  }
  attr {
    name: "dtype"
    type: "type"
  }
}
op {
  name: "HashTable"
  output_arg {
    name: "table_handle"
    type: DT_STRING
    is_ref: true
  }
  attr {
    name: "container"
    type: "string"
    default_value {
      s: ""
    }
  }
  attr {
    name: "shared_name"
    type: "string"
    default_value {
      s: ""
    }
  }
  attr {
    name: "key_dtype"
    type: "type"
  }
  attr {
    name: "value_dtype"
    type: "type"
  }
  is_stateful: true
}
op {
  name: "InitializeTable"
  input_arg {
    name: "table_handle"
    type: DT_STRING
    is_ref: true
  }
  input_arg {
    name: "keys"
    type_attr: "Tkey"
  }
  input_arg {
    name: "values"
    type_attr: "Tval"
  }
  attr {
    name: "Tkey"
    type: "type"
  }
  attr {
    name: "Tval"
    type: "type"
  }
}
op {
  name: "LookupTableFind"
  input_arg {
    name: "table_handle"
    type: DT_STRING
    is_ref: true
  }
  input_arg {
    name: "keys"
    type_attr: "Tin"
  }
  input_arg {
    name: "default_value"
    type_attr: "Tout"
  }
  output_arg {
    name: "values"
    type_attr: "Tout"
  }
  attr {
    name: "Tin"
    type: "type"
  }
  attr {
    name: "Tout"
    type: "type"
  }
}
op {
  name: "LookupTableSize"
  input_arg {
    name: "table_handle"
    type: DT_STRING
    is_ref: true
  }
  output_arg {
    name: "size"
    type: DT_INT64
  }
}
op {
  name: "PaddingFIFOQueue"
  output_arg {
    name: "handle"
    type: DT_STRING
    is_ref: true
  }
  attr {
    name: "component_types"
    type: "list(type)"
    has_minimum: true
    minimum: 1
  }
  attr {
    name: "shapes"
    type: "list(shape)"
    default_value {
      list {
      }
    }
    has_minimum: true
  }
  attr {
    name: "capacity"
    type: "int"
    default_value {
      i: -1
    }
  }
  attr {
    name: "container"
    type: "string"
    default_value {
      s: ""
    }
  }
  attr {
    name: "shared_name"
    type: "string"
    default_value {
      s: ""
    }
  }
  is_stateful: true
}
op {
  name: "QueueClose"
  input_arg {
    name: "handle"
    type: DT_STRING
    is_ref: true
  }
  attr {
    name: "cancel_pending_enqueues"
    type: "bool"
    default_value {
      b: false
    }
  }
}
op {
  name: "QueueDequeue"
  input_arg {
    name: "handle"
    type: DT_STRING
    is_ref: true
  }
  output_arg {
    name: "components"
    type_list_attr: "component_types"
  }
  attr {
    name: "component_types"
    type: "list(type)"
    has_minimum: true
    minimum: 1
  }
  attr {
    name: "timeout_ms"
    type: "int"
    default_value {
      i: -1
    }
  }
}
op {
  name: "QueueDequeueMany"
  input_arg {
    name: "handle"
    type: DT_STRING
    is_ref: true
  }
  input_arg {
    name: "n"
    type: DT_INT32
  }
  output_arg {
    name: "components"
    type_list_attr: "component_types"
  }
  attr {
    name: "component_types"
    type: "list(type)"
    has_minimum: true
    minimum: 1
  }
  attr {
    name: "timeout_ms"
    type: "int"
    default_value {
      i: -1
    }
  }
}
op {
  name: "QueueDequeueUpTo"
  input_arg {
    name: "handle"
    type: DT_STRING
    is_ref: true
  }
  input_arg {
    name: "n"
    type: DT_INT32
  }
  output_arg {
    name: "components"
    type_list_attr: "component_types"
  }
  attr {
    name: "component_types"
    type: "list(type)"
    has_minimum: true
    minimum: 1
  }
  attr {
    name: "timeout_ms"
    type: "int"
    default_value {
      i: -1
    }
  }
}
op {
  name: "QueueEnqueue"
  input_arg {
    name: "handle"
    type: DT_STRING
    is_ref: true
  }
  input_arg {
    name: "components"
    type_list_attr: "Tcomponents"
  }
  attr {
    name: "Tcomponents"
    type: "list(type)"
    has_minimum: true
    minimum: 1
  }
  attr {
    name: "timeout_ms"
    type: "int"
    default_value {
      i: -1
    }
  }
}
op {
  name: "QueueEnqueueMany"
  input_arg {
    name: "handle"
    type: DT_STRING
    is_ref: true
  }
  input_arg {
    name: "components"
    type_list_attr: "Tcomponents"
  }
  attr {
    name: "Tcomponents"
    type: "list(type)"
    has_minimum: true
    minimum: 1
  }
  attr {
    name: "timeout_ms"
    type: "int"
    default_value {
      i: -1
    }
  }
}
op {
  name: "QueueSize"
  input_arg {
    name: "handle"
    type: DT_STRING
    is_ref: true
  }
  output_arg {
    name: "size"
    type: DT_INT32
  }
}
op {
  name: "RandomShuffleQueue"
  output_arg {
    name: "handle"
    type: DT_STRING
    is_ref: true
  }
  attr {
    name: "component_types"
    type: "list(type)"
    has_minimum: true
    minimum: 1
  }
  attr {
    name: "shapes"
    type: "list(shape)"
    default_value {
      list {
      }
    }
    has_minimum: true
  }
  attr {
    name: "capacity"
    type: "int"
    default_value {
      i: -1
    }
  }
  attr {
    name: "min_after_dequeue"
    type: "int"
    default_value {
      i: 0
    }
  }
  attr {
    name: "seed"
    type: "int"
    default_value {
      i: 0
    }
  }
  attr {
    name: "seed2"
    type: "int"
    default_value {
      i: 0
    }
  }
  attr {
    name: "container"
    type: "string"
    default_value {
      s: ""
    }
  }
  attr {
    name: "shared_name"
    type: "string"
    default_value {
      s: ""
    }
  }
  is_stateful: true
}
op {
  name: "Stack"
  output_arg {
    name: "handle"
    type: DT_STRING
    is_ref: true
  }
  attr {
    name: "elem_type"
    type: "type"
  }
  attr {
    name: "stack_name"
    type: "string"
    default_value {
      s: ""
    }
  }
  is_stateful: true
}
op {
  name: "StackClose"
  input_arg {
    name: "handle"
    type: DT_STRING
    is_ref: true
  }
}
op {
  name: "StackPop"
  input_arg {
    name: "handle"
    type: DT_STRING
    is_ref: true
  }
  output_arg {
    name: "elem"
    type_attr: "elem_type"
  }
  attr {
    name: "elem_type"
    type: "type"
  }
}
op {
  name: "StackPush"
  input_arg {
    name: "handle"
    type: DT_STRING
    is_ref: true
  }
  input_arg {
    name: "elem"
    type_attr: "T"
  }
  output_arg {
    name: "output"
    type_attr: "T"
  }
  attr {
    name: "T"
    type: "type"
  }
  attr {
    name: "swap_memory"
    type: "bool"
    default_value {
      b: false
    }
  }
}
op {
  name: "TensorArray"
  input_arg {
    name: "size"
    type: DT_INT32
  }
  output_arg {
    name: "handle"
    type: DT_STRING
    is_ref: true
  }
  attr {
    name: "dtype"
    type: "type"
  }
  attr {
    name: "dynamic_size"
    type: "bool"
    default_value {
      b: false
    }
  }
  attr {
    name: "clear_after_read"
    type: "bool"
    default_value {
      b: true
    }
  }
  attr {
    name: "tensor_array_name"
    type: "string"
    default_value {
      s: ""
    }
  }
  is_stateful: true
}
op {
  name: "TensorArrayClose"
  input_arg {
    name: "handle"
    type: DT_STRING
    is_ref: true
  }
}
op {
  name: "TensorArrayConcat"
  input_arg {
    name: "handle"
    type: DT_STRING
    is_ref: true
  }
  input_arg {
    name: "flow_in"
    type: DT_FLOAT
  }
  output_arg {
    name: "value"
    type_attr: "dtype"
  }
  output_arg {
    name: "lengths"
    type: DT_INT64
  }
  attr {
    name: "dtype"
    type: "type"
  }
}
op {
  name: "TensorArrayGrad"
  input_arg {
    name: "handle"
    type: DT_STRING
    is_ref: true
  }
  input_arg {
    name: "flow_in"
    type: DT_FLOAT
  }
  output_arg {
    name: "grad_handle"
    type: DT_STRING
    is_ref: true
  }
  attr {
    name: "source"
    type: "string"
  }
  is_stateful: true
}
op {
  name: "TensorArrayPack"
  input_arg {
    name: "handle"
    type: DT_STRING
    is_ref: true
  }
  input_arg {
    name: "flow_in"
    type: DT_FLOAT
  }
  output_arg {
    name: "value"
    type_attr: "dtype"
  }
  attr {
    name: "dtype"
    type: "type"
  }
}
op {
  name: "TensorArrayRead"
  input_arg {
    name: "handle"
    type: DT_STRING
    is_ref: true
  }
  input_arg {
    name: "index"
    type: DT_INT32
  }
  input_arg {
    name: "flow_in"
    type: DT_FLOAT
  }
  output_arg {
    name: "value"
    type_attr: "dtype"
  }
  attr {
    name: "dtype"
    type: "type"
  }
}
op {
  name: "TensorArraySize"
  input_arg {
    name: "handle"
    type: DT_STRING
    is_ref: true
  }
  input_arg {
    name: "flow_in"
    type: DT_FLOAT
  }
  output_arg {
    name: "size"
    type: DT_INT32
  }
}
op {
  name: "TensorArraySplit"
  input_arg {
    name: "handle"
    type: DT_STRING
    is_ref: true
  }
  input_arg {
    name: "value"
    type_attr: "T"
  }
  input_arg {
    name: "lengths"
    type: DT_INT64
  }
  input_arg {
    name: "flow_in"
    type: DT_FLOAT
  }
  output_arg {
    name: "flow_out"
    type: DT_FLOAT
  }
  attr {
    name: "T"
    type: "type"
  }
}
op {
  name: "TensorArrayUnpack"
  input_arg {
    name: "handle"
    type: DT_STRING
    is_ref: true
  }
  input_arg {
    name: "value"
    type_attr: "T"
  }
  input_arg {
    name: "flow_in"
    type: DT_FLOAT
  }
  output_arg {
    name: "flow_out"
    type: DT_FLOAT
  }
  attr {
    name: "T"
    type: "type"
  }
}
op {
  name: "TensorArrayWrite"
  input_arg {
    name: "handle"
    type: DT_STRING
    is_ref: true
  }
  input_arg {
    name: "index"
    type: DT_INT32
  }
  input_arg {
    name: "value"
    type_attr: "T"
  }
  input_arg {
    name: "flow_in"
    type: DT_FLOAT
  }
  output_arg {
    name: "flow_out"
    type: DT_FLOAT
  }
  attr {
    name: "T"
    type: "type"
  }
}
"""

_op_def_lib = _InitOpDefLibrary()


text:
<RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:tools="http://schemas.android.com/tools"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    android:paddingBottom="@dimen/activity_vertical_margin"
    android:paddingLeft="@dimen/activity_horizontal_margin"
    android:paddingRight="@dimen/activity_horizontal_margin"
    android:paddingTop="@dimen/activity_vertical_margin"
    tools:context=".EditItemActivity" >

    <TextView
        android:id="@+id/textView"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:text="@string/text_edit_item" />

    <EditText
        android:id="@+id/editText"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:layout_alignLeft="@+id/textView"
        android:layout_below="@+id/textView"
        android:layout_marginTop="20dp"
        android:ems="10"
        android:inputType="textMultiLine" >

        <requestFocus />
    </EditText>

    <Button
        android:id="@+id/button"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:layout_alignLeft="@+id/editText"
        android:layout_below="@+id/editText"
        android:layout_marginTop="22dp"
        android:onClick="saveItemAndFinish"
        android:text="@string/button_save" />

</RelativeLayout>


text:
Q: Interbase 2007 .net provider with Entity Framework support I'd like to use Entity Framework for lazy loading and easy binding to controls.
I've tried to use IBProvider but it does not work for me. It's based on OleDb that's why I have got this exception:

The store provider factory type 'System.Data.OleDb.OleDbFactory' does not implement the IServiceProvider interface. Use a store provider that implements this interface.

when I connected to Interbase with IBProvider with following connection string:

add name="InterbaseEntities"
  connectionString="metadata=res://*/db.csdl|db.Interbase.ssdl|res://*/db.msl;provider=System.Data.EntityClient;provider connection string="Provider=LCPI.IBProvider.3;Data Source=db.IBS;User ID=SYSDBA;Password=masterkey;Location=db.IBS""providerName="System.Data.EntityClient"

OK. OleDbFactory really does not implement IServiceProvider interface.
Then I've tried to use FirebirdClient 3.0.2.0 and got exception "unsupported on-disk structure for file %path to file%;found 11.2,support 11.2".
OK. This is not Firebird database.
Does anyone know any solution to connect to interbase server and use it with Entity framework?

redpajama_set_name: RedPajamaStackExchange


This lovely 3 bdrm family home is located on a quiet no through street that ends in a cul-de-sac. Situated on a 6700sf lot your children will love playing in the back yard while you watch from the protected patio. The formal living room and dining room w/hardwood floors are great spaces to entertain. The renovated kitchen has S/S fridge/dishwasher, laminate flooring and maple cabinets and overlooks the family room. This home also has a new roof, newer windows, a newer hot water tank. At this price...what's not to love?
Floor Area 1,799 Sq. Ft.


Norway carved out their first win of the event so far with a 5-4 victory over Scotland in Tuesday morning's fourth session of women's round-robin play at the World Junior Curling Championships 2019 in Liverpool, Canada.
Meanwhile, Switzerland moved into a clear lead at the top of the table, beating Russia by 7-6 for a fourth win that keeps their unbeaten record intact.
The game between Switzerland and Russia looked like it was heading for an extra end, but Russia's last take-out effort sailed through the house to give Russia just two points from the end rather than the three points they needed to keep the game going.
China beat Japan by 9-3 while Korea were 9-6 winners over United States. These results, along with Russia's loss mean that China, Korea and Russia share second spot on three wins, while Japan are still without a win so far.
Session four: United States 6-9 Korea; China 9-3 Japan; Switzerland 7-6 Russia; Norway 5-4 Scotland; Canada 3-9 Sweden.


Last edited by Wing Saber on Wed Jul 20, 2011 9:06 pm, edited 1 time in total.
Oh, dude! We're gonna have fun with this one.
However, my mind's currently drawing a blank to some of my favorite villains (I just woke up a little while ago), so I'll have to get back to ya on this.
Where's the fun in that? A lot of series had more than one great villain.
Plus, in regards to his Power Rangers villains, each series counts as its own franchise.
I'm gonna have to disagree on a few of these.
Rita was awful. Her plans were one-dimensional, her lines of dialogue were terrible, and she never quite accomplished anything on her own.
Scorpina, however, was probably the most competent season 1 villain. She could take on all the Rangers by herself, turn into her own giant monster form, and successfully trapped the Rangers on more than one occasion. Not to mention that, unlike Rita, her dialogue matched her lip movement.
Divatox was even worse. She was just pathetic. She wined about everything, her plans were just stupid, and she really had no business even being the Rangers' primary enemy anyway. She's just a space pirate, not some great conqueror. It's like if some petty thief tried to become the greatest criminal mastermind of all time. She was overstepping her place as a mere pirate trying to bring down the Rangers. And what makes it even worse is that, despite it took Rita and Zedd THREE YEARS to beat the Rangers, and despite that the Machine Empire (an entire empire with a vast army of its own) couldn't beat the Zeo Rangers (whose powers were said to ALWAYS be increasing over time), it was Divatox's band of lowly common thugs who ultimately defeated the Rangers. That is just insulting.
A much better villain than Divatox form Turbo was her brother, General Havoc. Once he came into the picture, he should have taken over as the main villain. He was far more competent and calculating than his dumb sister ever was. His plans were more well thought out and his tactics were more ingenious. Why he didn't take over is beyond all comprehension (aside from the "Carranger vs. Turbo" technical differences, that is).
While Astronema was indeed a very good villain (in fact, In Space had wide variety of great villains), I think I'd have to say I liked Ecliptor just a little better. He had this sort of dark knight thing going for him with his own code of ethics that he abided by. He showed genuine care and concern for Astronema, viewing her as his own daughter, and even enabled her to escape to safety to the Rangers's care, knowing that she'd be safe with them even if it risked losing her and any bit of evil she had left inside herself. Of all the villains, he had the best character arc up until he (and Astronema) were given cybernetic enhancements and had their minds reworked to remove any traces of goodness and honor from within themselves. Though, in the last episode, some of his old care for Astronema resurfaced after she was mortally wounded by the Red Ranger, in spite of his cybernetic upgrades.
Though, honorable mention goes out to Darkonda (for being such a terrifying schemer) and the Psycho Rangers (for obvious reasons).
Scorpina wasn't in Lost Galaxy, so I'm guessing you're referring to Trakeena. While she was also a very good villain, again, I'd be inclined to lean more towards Villamax instead. He never struck me as being authentically evil, but more evil out of loyalty. Like Ecliptor, he too had his own sense of honor and nobility that he stuck by, even commending his comrades for their good works when necessary. I especially liked when he saved an innocent child from danger during the finale, coming to his senses about what honor really was and how his loyalty to Trakeena had blinded him from seeing the unethical status of her agenda. His demise was sad one (though not as sad as Beast Wars Dinobot's), and it was shame to see him die the way he did. Still, he remained that better person through to the very end.
Of all of the Lightspeed Rescue villains, only Diabolico struck me as being interesting. Queen Bansheera was frightening, but she was a typical villain nonetheless. Now, granted, Diabolico wasn't all that interesting for the most part either... until closer to the end of the series when he turned on Bansheera after she forced him to kill Loki. While Diabolico may have had a disliking of the Rangers, he grew to hate his queen even more than them after that, and when the Rangers took notice of them, they attempted to help Diabolico on at least one occasion, and he returned the favor shortly before his own demise. However, even in death, he remained interesting, for when, during the finale, Queen Bansheera tried to pull the Red Ranger into the Shadow World with her, Diabolico's spirit appeared before them and struck Bansheera, causing her to fall to her fate in the Shadow World and allowing the other Rangers to safely pull Carter free.
Master Org was definitely ruthless and driven by hatred and revenge, but I kinda like Zen Aku better. His mysterious nature of being locked away for so many years and being able to control his own Dark Wild Zords made his character all the more mesmerizing. He had this air of mystique and wonder that kept us engaged in his discovering of who he was and what had happened to him in the past that turned him into the monster that he had become. Though, while the revelation of his identity was a bit predictable, it was still kinda reminiscient of some of the past series events that had similar scenarios to his reveal. So, I guess it remains consistent with the greater continuity.
Lothor... suuuuuuuuuucked. He was just a big joke. He never took anything seriously, his plans were no better than Divatox's, he looked absolutely ridiculous, and he was never ever intimidating. I mean, the one thing this guy had going for him was that he was an excellent fighter who had some darn good moves and skills, but not even that can save his ludicrous personality. Practically all of his screentime was one big facepalm after another.
Zurgane, on the other hand, was the only one who actually took his job seriously. All of his plans were well thought out, seemed pretty effective, and actually put up a good opposition against the Rangers. If it weren't for his (foolish, yet admirable) loyalty to Lothor, I'd think he would have made a much much better main villain. Though, during the time that they served Lothor, the Thunder Rangers were pretty intense too. They both had some excellent fighting prowess and truly gave the Wind Rangers their greatest challenege on the long run.
While Imperious was an interesting villain, I'd have to choose Koragg over him instead. Like Ecliptor and Villamax, he had pretty devious yet honorable streak to his nature. Hey, he even beat down and stole the powers of the White Ranger, whom we later learn turned out to be his own wife! His character arc of when we learn of his true identity of Leanbow became only more and more fascinating as it went on. And, unlike the previous honorable villains, he actually gained full redemption and purification, keeping his powers and becoming the Wolf Warrior to boot!
Venjix was okay, but kinda bland. We really don't know much about him other than him being an evil computer virus who wants to take over the world because... he's... just... evil. Tenaya 7/15, however, was a bit more interesting and lot more capable. She was like Astronema if she were a saboteur, and even had a similar character arc to her. She infiltrated the Rangers' headquarters multiple times, and even came close to acquiring the Ranger Green morpher powers in her debut. Her obscured past made her all the more mysterious, and the big reveal of her connection to one of the Rangers nearer towards the end really made the plot thicken.
As for the rest, I pretty much agree with you.
Sabrblade wrote: Where's the fun in that? A lot of series had more than one great villain.


Sq. Ft.:1,533 to 3,825Sq. Ft.
This neighborhood is perfect for those seeking single-family homes. The community's homes were mostly developed around 2005, but newer construction homes were built as recently as 2012. In general, homes in Suncoast Lakes are about $165,000 – $315,000 and sit on quarter-acre lots with three bedrooms and two bathrooms. The most common types of parking are 2-car garage and garage.
How would you rate Suncoast Lakes?
Homes in Suncoast Lakes are on the market for an average of 129 days and are typically purchased at close to asking price. Property taxes hover around $2,595 per year, and homeowners' association fees are approximately $346. On average, homes here are $104 per square foot and typically list for around $225,000.