text:
Scanning electron microscopy studies of YBa2Cu3O7-δ superconductors
Wei Sha*
Microstructures of bulk and thin film YBa 2Cu 3O 7-δ superconductors were studied by using scanning electron microscopy (SEM). It was confirmed that viscous technique processed bulk YBa 2Cu 3O 7-δ has a homogeneous microstructure across the pellet diameter. Concerning the thin film, it was found that 2H + ion implantation with a dose of 1×10 12cm -2 at 50 keV does not cause microstructural change of the film at a micrometre level. Combined with previous studies by using high resolution transmission electron microscopy, it appears that the structural modification is at an atomic scale.
Rare Metals
Dive into the research topics of 'Scanning electron microscopy studies of YBa2Cu3O7-δ superconductors'. Together they form a unique fingerprint.
Superconductor Chemical Compounds 85%
Thin films Engineering & Materials Science 72%
Ion implantation Engineering & Materials Science 51%
Microstructure Chemical Compounds 51%
Ion Implantation Chemical Compounds 46%
Scanning Electron Microscopy Chemical Compounds 45%
thin films Physics & Astronomy 39%
pellets Physics & Astronomy 38%
Sha, W. (1995). Scanning electron microscopy studies of YBa2Cu3O7-δ superconductors. Rare Metals, 14(4), 245-248.
Sha, Wei. / Scanning electron microscopy studies of YBa2Cu3O7-δ superconductors. In: Rare Metals. 1995 ; Vol. 14, No. 4. pp. 245-248.
@article{90d9d4ee48cd45ab9ac0c94635cb4e8a,
title = "Scanning electron microscopy studies of YBa2Cu3O7-δ superconductors",
abstract = "Microstructures of bulk and thin film YBa 2Cu 3O 7-δ superconductors were studied by using scanning electron microscopy (SEM). It was confirmed that viscous technique processed bulk YBa 2Cu 3O 7-δ has a homogeneous microstructure across the pellet diameter. Concerning the thin film, it was found that 2H + ion implantation with a dose of 1×10 12cm -2 at 50 keV does not cause microstructural change of the film at a micrometre level. Combined with previous studies by using high resolution transmission electron microscopy, it appears that the structural modification is at an atomic scale.",
author = "Wei Sha",
journal = "Rare Metals",
publisher = "University of Science and Technology Beijing",
Sha, W 1995, 'Scanning electron microscopy studies of YBa2Cu3O7-δ superconductors', Rare Metals, vol. 14, no. 4, pp. 245-248.
Scanning electron microscopy studies of YBa2Cu3O7-δ superconductors. / Sha, Wei.
In: Rare Metals, Vol. 14, No. 4, 01.10.1995, p. 245-248.
T1 - Scanning electron microscopy studies of YBa2Cu3O7-δ superconductors
AU - Sha, Wei
N2 - Microstructures of bulk and thin film YBa 2Cu 3O 7-δ superconductors were studied by using scanning electron microscopy (SEM). It was confirmed that viscous technique processed bulk YBa 2Cu 3O 7-δ has a homogeneous microstructure across the pellet diameter. Concerning the thin film, it was found that 2H + ion implantation with a dose of 1×10 12cm -2 at 50 keV does not cause microstructural change of the film at a micrometre level. Combined with previous studies by using high resolution transmission electron microscopy, it appears that the structural modification is at an atomic scale.
AB - Microstructures of bulk and thin film YBa 2Cu 3O 7-δ superconductors were studied by using scanning electron microscopy (SEM). It was confirmed that viscous technique processed bulk YBa 2Cu 3O 7-δ has a homogeneous microstructure across the pellet diameter. Concerning the thin film, it was found that 2H + ion implantation with a dose of 1×10 12cm -2 at 50 keV does not cause microstructural change of the film at a micrometre level. Combined with previous studies by using high resolution transmission electron microscopy, it appears that the structural modification is at an atomic scale.
JO - Rare Metals
JF - Rare Metals
Sha W. Scanning electron microscopy studies of YBa2Cu3O7-δ superconductors. Rare Metals. 1995 Oct 1;14(4):245-248.


The pastor at our church often prays, "Lord, give us the 'want to.'"
I don't think I've ever heard him talk about this little prayer that he prays or explain it in any way.
Most Sundays, he just prays and skips right along to the next topic. But every time he says this one little line, it sticks in my heart like a field burr. I can't get past it.
It's similar to what King David prayed in Psalm 119:36. "Lord, give me the desire to follow your laws." And like the verse above, I believe that God gives us the desires of our heart, which means that he actually places the appropriate desires within our hearts and then grants those desires.
So any time I don't "want to" do something--when I have absolutely no desire to do it--the answer is as simple of a little prayer. Lord, give me the "want to."
There are a million things that I know I should or should not be doing at any given time.
There are people I don't "want to" forgive or love or even be in the same room with.
There are plenty of personal character traits that I don't "want to" work on.
There are days that I don't "want to" pray or be empathic or think compassionate thoughts.
Hell, there are even days I don't "want to" even get out of bed.
There are certainly days that I don't "want to" follow God's laws or accept his love or have faith.
Some days, the most...the very most...that I can do is whisper a small Lord, give me the "want to."
Believing that this small whisper is the most pleasing, profound prayer in God's ear.
A prayer that He loves to answer.


Anyone doing a Confessional must be on or have done a Confessional course or internship in the handling of Confessionals.
119. IN THIS CONFESSIONAL, HAVE YOU TOLD ALL?
BY THE POWER INVESTED IN ME, ANY OVERTS AND WITHHOLDS YOU HAVE FULLY AND TRUTHFULLY TOLD ME ARE FORGIVEN BY SCIENTOLOGISTS.
Hubbard, L. R. (1980, 25 December). LRH Communicator Confessional List. Technical Bulletins of Dianetics and Scientology (1991 ed., Vol XII, pp. 237-243). Los Angeles: Bridge Publications, Inc.


text:
Q: Add a column in an SQL query that should only filtered results I have the below table:
TABLE
+--------------------------+
| STUDENT  CLASS     SCORE |
+--------------------------+
| Student1 Science   Pass  |
| Student1 Math      Fail  |
| Student1 Geography Fail  |
| Student2 Science   Pass  |
| Student2 Math      Pass  |
| Student2 Geography Fail  |
+--------------------------+

I'd like to see results as follows
+------------------------------------+
| STUDENT  Science   Math  Geography |
+------------------------------------+
| Student1 Pass     Fail   Fail      |
| Student2 Pass     Pass   Fail      |
+------------------------------------+

Any idea on how I can do so this?

A: For a fixed list of classes, you can just use conditional aggregation:
select student,
    max(case when class = 'Science'   then score end) as science,
    max(case when class = 'Math'      then score end) as math,
    max(case when class = 'Geography' then score end) as geography
from mytable
group by student

redpajama_set_name: RedPajamaStackExchange


Please let me chose box size according to each product.
You guys are talented coders but I don't think you've ever actually SOLD and SHIPPED anything using your own store's USPS Calculated shipping.
Choosing which box size to use according to weight is quite possibly the WORST way of calculating shipping costs. You just made your USPS shipping module useless.
This one feature is basically holding me back and keeping me with eBay (who does calculated shipping and rules VERY well).
There are a lot of products that are large but light weight (like the giant calendars that I'm selling and need to be shipped flat) and lots of products that are small but heavy (my other productsl). Your USPS module doesn't make any sense by associating box size with weight. It doesn't work like that.
I should be able to specify a box size for EACH product.
I will pass this along to Aaron for review.
We looked at both options, but forcing people to enter a size for every product didn't seem to make sense. We figure for bulk items you can add an extra shipping charge.
I make $5 profit on my item. Being just 1 lb off or 10 inches off on calculations when shipping to California will cost me $2 out of my profit. Over time I'm losing $hundreds because of inaccurate shipping. The box for each item weighs 1LB+ as well.
So I sell large items that are lite in weight, and small items that are heavy in weight. Your shipping module thinks I can put a 17x26 calendar in a small box (undercharge) and a bunch of heavier magnet pens in a giant box (overcharging).
In real world usage. Bulky items fluctuate MASSIVELY depending on where you ship them to. Being over a certain girth adds costs as well.
You can't just add an extra price for bulky items because for me, shipping to Chicago is $4 cheaper than shipping to California. Am I suppose to over charge one group of customers because my store can't calculate shipping accurately?
Nevermind I moved back to WP E-commerce.
You guys have a really nice store system, I love the checkout, the integrated stripe and usps options. I just wish it had Paypal Payments Standard.
But its not set up to sell diverse physical products.The shipping option is keeping me from recommending you.
Ik do agree unfortunately. The weight rate is not covering up how it works in practice.
I would advise you guys to listen to your customers who bump into the practical issues in real life.
What I also miss very much is the possibility to choose for pick-up in the end, so there will be no charging for delivery costs.


Buy amazon kindle fire discount code It, buy It, lili Aromatherapy Meditation Amongst Lotuses.
Hair Color Master Class: 15 Tips from the Best Colorists.Get an amazing bargain on these luxe bamboo pillows vadimguzhva via Getty Images 6 Halloween costumes that are already in your closet.American Express, american Girl, ann Taylor, annas Linens.Carousel showing slide 1 of 5 - Trending on eBay 1, patagonia Better Sweater 5,267 Views 2, world Series Tickets 1,182 Views 3, jasmine Disney Designer Doll 1,504 Views 4, the Golden Girls Cereal koa keystone giveaway 6,931 Views 5, supreme x The North Face 120,192 Views.SlayCase Vanity Travel Case Buy It Buy It Eva NYC Mini Blow Dryer Buy It Buy It Fresh Manicure how to use creosote sweeping log Fix Buy It Buy It Kat Von D Saint Eau de Parfum Buy It Buy It Wooden Multi-Device Charging Dock Buy It Buy It Dry Erase.Buy It Buy It kiehl'S since 1851 Groom with Greatness Collection Buy It Buy It La Mer The Endless Transformation Collection Gift Set Buy It Buy It stephanie johnson Java Coffee ML Traveler Cosmetics.Aldo, allen Edmonds m, aMC Theatres, american Apparel, american Eagle.
When you call us, we will ask which store your gift card is from and the amount of the card.Read more from Cruise Passengers Are Startled When Ship Grinds To A Halt Before.Vintage Polaroids The original instant photo sharing.Buy It Buy It godiva Taste of Godiva, 3 Month Chocolate Subscription Buy It Buy It Jacques Torres Jacques' Choice Holiday Edition Merry.Ready to sell your gift card or store credit?The Dark-Circles Fix Easy-Breezy Wedding Transportation With Skedaddle By PubExchange I could give up shopping, but I'm not a quitter Anonymous Editors' Picks Over 50 gifts mom will love this Mother's Day These are Miranda Kerr's go-to beauty products 15 beach sprays to give your.
Sometimes the warner brothers studio promo code borrower may choose the option to buy discount points in order to lower the overall interest rate.Refinancing OF construction loans, ETC.This fee, though, is different than points.This list of allowable and non-allowable fees above is not all-inclusive and..
Dealspotr for Shoppers, dealspotr tracks promo codes from online merchants to help shoppers save money at volume discount calculation checkout.Learn how some brands are seeing 500 ROI on influencer marketing using Dealspotr.Apply the deal and get it!Get Deal Dbz Sealed Product Items As Low.75 end..


Object: empty your rack of all tiles. Place your tiles on the board in "runs" and "groups." a run is set of 3 consecutive numbers in the same colour, a group is the same number in 3 different colours.
Educational: Winning Moves games "classic Rummy tiles" is a great game for the classroom promoting, in a fun way, concepts like sequencing and pattern recognition.
Contents: include 4 plastic stadium tile racks, 106 high quality easy-to-read Rummy tiles and illustrated instructions. Family game night: fun for kids and challenging for adults – a great family game!


text:
Beginners' Botany
by Liberty Hyde Bailey
The Holy Earth
The Holy Earth (eBook)
by Liberty Hyde Bailey, Wendell Berry, John Linstrom (Author)
The agrarian tradition runs as an undercurrent through the entire history of literature, carrying the age-old wisdom that the necessary access of independent farmers to their own land both requires the responsibility of good stewardship and provides the foundation for a thriving civilization. At the turn of the last century, when farming first began to face the most rapid and extensive series of changes that industrialization would bring, the most compelling and humane voice representing the agrarian tradition came from the botanist, farmer, philosopher, and public intellectual Liberty Hyde Bailey. In 1915, Bailey's environmental manifesto, The Holy Earth, addressed the industrialization of society by utilizing the full range of human vocabulary to assert that the earth's processes and products, because they form the governing conditions of human life, should therefore be understood not first as economic, but as divine. To grasp the extent of human responsibility for the earth, Bailey called for "a new hold" that society must take to develop a "morals of land management," which would later inspire Aldo Leopold's "land ethic" and several generations of agrarian voices. This message of responsible land stewardship has never been as timely as now.
Categories: Science & Nature, Politics & Current Events
Publisher: Counterpoint
The Holy Earth: The Bi...
Liberty Hyde Bailey ...
Write a Review for The Holy Earth: The Birth of a New Land Ethic
by Liberty Hyde Bailey, Wendell Berry, John Linstrom
The Holy Earth has been added
The Holy Earth has been added to your wish list.

redpajama_set_name: RedPajamaCommonCrawl


Your Branding Statement matters, A Lot!
At Brand-Aid Consulting, LLC "We Brand Businesses from the Inside Out". I say this all the time when I meet people and the response is always the same. "What exactly does that mean?" This is the perfect response because I now have the invitation to tell them how I help businesses just like theirs.
As I mentioned in my previous post "There Is No Brand without Branding" graphical depiction of your brand is one of the final steps.
Here are 4 steps to think about when defining your brand.
So what is branding from the inside out?
Hopefully by now you have a clear brand definition and you can easily express in words what your core values are. If not, take some time to really think about what's important to you, why you started the business (besides to make money) and define this in a sentence or short paragraph. Here's a nice resource from the Houston Chronicle on how to write an effective Branding Statement.
"As the key to attracting new customers, a branding statement tells the world about your business and has the potential to engender long-term loyalty. Think of your brand slogan as a promise about the quality of the goods or services that your business offers."
Everyone and everything must reflect the brand values.
This step is a constant. You must ensure that everyone in the company understands what the brand stands for and represent that consistently. Your products and services should back up your words and actions with the qualities you have defined.
Live the brand. Be the brand.
No one can understand your brand like you, but it is your responsibility to help them get as close as possible. This is especially important for small businesses, but holds true for companies of all sizes. Represent your business values in every aspect of life and your audience will see you and your brand as authentic. Authenticity creates loyalty and loyalty leads to advocacy.
Brand-Aid Consulting, LLC is here to help. Contact us today for a complimentary consultation.
There is no brand without branding.


Graduates of this qualification will be familiar with drilling equipment and tools and be able to work safely at drilling sites under direct supervision. It is expected to take 2 years to complete.
Gain the core skills and knowledge to work as a driller (within the drilling context that the training programme was completed). It is expected to take 2½ years to complete. This programme is eligible for for two years' free industry training. Click here for details.
Graduates will have the skills and knowledge to work as a supervisor or senior driller (within the drilling context that the training programme was completed). It is expected to take 2 years to complete.
MITO is also working in partnership with the Australian Drilling Industry Training Committee (ADITC) and has an exclusive license to use their DICAT distance learning resources in New Zealand. DICAT is made up of learning modules and theory assessments used in the New Zealand Certificate in Drilling programmes.
Learners may complete the DICAT programme independent of gaining any qualification.
DICAT4 covers DICAT Sets 1-3 (Modules 1-11).
If you are currently employed in the industry and your employer is able to support your training programme, contact MITO and we'll arrange an appointment to uncover your drilling career.
As a Trainee Driller, Aiden Stace is thriving in a job he loves after a chance discussion with his mechanic led Aiden to uncover a career in the drilling industry.


text:
Rebecca "Becky" Quinn (* 24. Mai 1971 in Quakertown, Bucks County, Pennsylvania) ist eine ehemalige US-amerikanische Bahnradsportlerin.

Rebecca Quinn wuchs in der Nähe des "Lehigh Valley Velodrome" in Trexlertown auf und kam so zum Bahnradsport. Nach ihrem Studium arbeitete sie kurz als Lehrerin, entschied sich aber dann für den Radsport. Zweimal wurde Rebecca Quinn US-amerikanische Meister, 2005 im Scratch und 2007 im Punktefahren. International erlangte sie zahlreiche Podiumsplätze bei Weltcuprennen. Sie nahm an sechs Bahn-Weltmeisterschaften teil und konnte zweimal einen vierten Platz belegen.

Aufsehen erregte in den USA Quinns Klage gegen den amerikanischen Verband "US Cycling", weil sie nicht für die Olympischen Spiele 2008 in Peking nominiert worden war. Sie führte an, dass Sarah Hammer ihr vorgezogen worden sei, weil sie mit dem Trainer der Mannschaft, Andy Sparks, liiert sei. Das Gericht wies ihre Klage zurück, verurteilte aber "US Cycling" zur Übernahme der Gerichtskosten, da die Trainer Zweifel an der Fairness der Auswahl hätten aufkommen lassen.

Seit dieser gerichtlichen Auseinandersetzung war Quinn international wenig erfolgreich; vor einem geplanten Comeback anlässlich der Bahn-WM 2010 in Kopenhagen brach sie sich bei einem Sturz das Becken. Sie plant einen Start bei den Olympischen Spielen 2012 in London.

Einzelnachweise

Weblinks

Radsportler (Vereinigte Staaten)
US-amerikanischer Meister (Radsport)
Bahnradfahrer
US-Amerikaner
Geboren 1971
Frau

redpajama_set_name: RedPajamaWikipedia


Members of the Legislative Council of the Isle of Man have given a third reading to an act which would give unmarried fathers living on the island parental responsibilities equal to married ones.
The bill was introduced by legislative council member Juan Turner. Mr Turner told members that while married fathers have rights and responsibilities which survive divorce, if an unmarried couple end their relationship, only the mother has automatic responsibility for the child, unless a court order is obtained or an agreement is signed. Therefore unmarried mothers may get no say in their child's welfare, education or upbringing.
The legislation, described by Mr Turner as "long overdue", would automatically grant parental responsibility to unmarried fathers on the island as long as they were named on the child's birth certificate.
The Department of Social Care, Department of Education and Children, and the local family court's welfare officers all expressed support for the bill.
The bill was approved unanimously by the council.
Fathers in England and Wales became automatically entitled to parental responsibility providing they had signed the birth certificate in December 2003.


According to local oral tradition, this cemetery was named for John Carson, who once owned the adjacent land. Some sources say one grave was in existence before 1842; others maintain the first graves date to an 1842 Indian raid at the nearby home Dr. and Mrs. W. M. Hunter. The three victims of the raid were Mrs. Minerva Hunter, her young daughter Elizabeth, and an African American maid whose name is unknown. By 1878, the cemetery trustees acquired title to the land and they later added more acreage. Among those buried here are land donors Mr. & Mrs. W. E. Alderson, Mr. & Mrs. W. R. Luton, and T. M. Newell. Minerva Hunter's grave was marked in 1942, a century after her death.
Location: From Ector, take FM 898 north for 2.5 miles.
Information on the Carson Cemetery is on the Fannin County GenWeb site.
Read about the massacre of the Hunter Family in the History of Fannin County.


Walden Farms Pasta Sauce at Netrition.com.
Pour on most brands of pasta sauce and you pour on hundreds of calories. So instead, enjoy pasta with Walden Farms Calorie Free Pasta Sauces. No calories, fat, carbs, gluten or sugars of any kind. Based on old world recipes, lovingly prepared with crushed tomatoes, minced garlic, sliced onion, freshly ground herbs and spices and the finest imported and domestic aged vinegars. Walden Farms low carb, sugar free pasta sauces are sweetened with Sucralose.


Last night I released the second beta of Adjector, our fast, flexible, open source ad client. There's a couple of small but important fixes: precaching now works correctly (I don't know how it even worked before), and rendering is a bit more stable.
There shouldn't be any trouble updating, no db changes occurred.
The worst thing is, doing it wrong apparently resulted in other things being done to the database... certain cache objects were being set as text, or as not text, when they shouldn't have been. Definitely weird.
I also fixed a bit of a bug with the renderer: this problem you should never see if everything is working correctly, but there is a possible case where when you are looking for multiple text creatives, an appropriate creative might never be found. It now will no longer error or cycle forever looking, but just give up after a few (1000) tries.
I'm glad to "officially" release our open-source ad server, Adjector.
It's been around for about a year in a semi-stable state; ad serving worked fine but there was almost no UI to speak of and click tracking was super broken. I've removed our attempt at a GUI using GWT and written a nice simple HTML one; and fixed form validation, click tracking string substitution, and a bunch of other bugs. Perhaps most importantly it also finds and displays an appropriate random ad three times faster, including view tracking (from about 55 ms to 15 ms). This is due to the weighted probabilities being pre-cached with the new design.
My goal with Adjector was to create a fast, slim, flexible, open-source ad server, which AFAIK didn't exist before. There's quite a few other open source ad servers, most based on phpAds. But PHP doesn't make for a great anything server, and none of the other servers that I know of can integrate directly into your application and allow the client to only make one request, much less allow your application to share the same database and connections. So I think I've accomplished my design goals here, Adjector is so fast that you can't even tell it's there, it has all sorts of ways to weight ads, it can display and randomize text ads, Adsense-style, and it is Python and open-source so it's easy to hack on.
So if you need an ad server for your site, and you can get Pylons going, Adjector might just be what you're looking for. And we're definitely looking for more developers, too.


We thought we'd give you a quick preview of some forthcoming iSMEStorage features. We've been requested for a while to add better tag support and support for photo thumbnails. We've started work on these features and anticipate these being available in a forthcoming release in the next few weeks. In the meantime enjoy the video below.


Cheap international long distance call is made possible by our professional callback service. Customers in 250 countries pay cheapest low US international long distance rates but receive high-quality international call quality.
For example, say you want to make a call from UK to Brazil. From your telephone in UK, you simply dial the "callback computer" in the U.S. and hang up after one or two rings (there is no charge for this part of the call). The callback computer will immediately call you back with a dial tone. You then enter the number in Japan you wish to call and you are connected. That's all there is to it.
BestCallback.Net callback service is a viable alternative to the services offered by inflexible and unresponsive monopolies. By "re-originating" calls to our telecom switch, our callback service system is able to bill calls at rates the monopolies cannot even come close to matching. This international saving service is available worldwide, so all you need is a telephone. Just follow two easy steps to save over 70% on your international long-distance phone calls.


From penguin parades to motorsports, Phillip Island is a world beater when it comes to balancing chilled-out nature and high-octane thrills.
In Phillip Island's slow lane, discover sleepy coastal villages fronting broad beaches. Spot koalas dozing in the gum trees or watch the nightly parade of little penguins waddling back to their rookeries. Hook a fish from the pier or enjoy waterfront dining. Change gears and experience Phillip Island's high-octane appeal. Chase the scent of burning rubber at the annual motorcycle and car-racing champs or wax up your surfboard to take on the roaring ocean breaks.
This family-friendly Inverloch hotel is located by the ocean, within 2 mi (3 km) of Inlet Beach, Eagles Nest, and Bunurong Marine National Park. Rainbow Park and Bunurong Environment Centre & Shell Museum are also within 3 mi (5 km).
This family-friendly Balnarring motel is within 3 mi (5 km) of Stonier Winery and Paradigm Hill. Ashcombe Maze and Lavender Gardens and Redhill Recreation Reserve are also within 9 mi (15 km).
Set in Tyabb, this family-friendly motel is within 6 mi (10 km) of Hastings Foreshore Reserve, Rm Hooper Oval, and Karrawingi Park. Devil Bend Golf Club and B'Darra Estate Vinyard are also within 6 mi (10 km).
Situated by the sea, this motel is 1.1 mi (1.8 km) from Phillip Island Nature Park and 1.8 mi (2.9 km) from Phillip Island Chocolate Factory. National Vietnam Veterans Museum and Churchill Island Heritage Farm are also within 6 mi (10 km).
Snag car hire in Melbourne and cruise 140km south across the Phillip Island bridge. It's a popular weekend trip for Melburnians, weaving through the scenic towns of Western Port before you cross to Phillip Island and start scouting for penguins.
If you're flying into Melbourne and basing yourself in the CBD, book an airport transfer to your hotel so you can get exploring ASAP. When you're ready to get to Phillip Island, it's just a quick drive or bus ride away.
The closest airport to Phillip Island is Tullamarine Airport (MEL), 165km north. Some visitors arrange accommodation in the CBD, then make the trip south to Phillip Island-whether you take a charter bus, car hire, or ferry there is up to you.
To get into the island spirit, head to the Stony Point Terminal on the Mornington Peninsula and take the ferry. Once you're on the island, there is a V/Line bus that runs five times per day, making stops at Cape Woolamai, Smiths Beach, and Cowes. If you want to get even more fresh air, you can rent an e-bike in Cowes and get around the island on two wheels.
Phillip Island is a temperate climate, with hot summers and cool winters. Under the summer sun, the sparkling waves of Western Port Bay will call to you, and the local markets and al fresco dining will be bustling. Spring is a great time to see the newest additions to the country's largest fur seal colony. And if you're looking for the Penguin Parade, rest assured: the penguins come ashore year-round.
Even in the summer, you'll want to rug up in the evenings, so pack a sweater or light jacket.
Thongs are great for the beach, but don't forget your joggers for exploring and wildlife watching.
How big is Phillip Island?
Phillip Island is about 26km end to end, putting it squarely in the medium-sized island category. The main township of Cowes is located in the middle of the northern side of the island, and has loads of shopping and dining. However, you won't be able to hoof it to other parts of the island, so plan on arranging transport.
Where are the penguins on Phillip Island?
The penguins make their homes in the Phillip Island Nature Park, located in the island's southwest corner. The park is a nonprofit dedicated to conservation. Not far from the penguins, you'll find Seal Rock, home to more than 16,000 fur seals.
What time is the Penguin Parade on Phillip Island?
The famous Penguin Parade begins when the penguins come ashore at sunset each night. Ticket holders should generally arrive an hour early, when the access doors open, in order to ensure good seats. There is also a visitor centre and a café to explore as you wait.


text:
' Copyright (c) Microsoft.  All Rights Reserved.  Licensed under the Apache License, Version 2.0.  See License.txt in the project root for license information.

Namespace Microsoft.CodeAnalysis.Editor.UnitTests.FindReferences
    Partial Public Class FindReferencesTests
        <Fact, Trait(Traits.Feature, Traits.Features.FindReferences)>
        Public Sub TestException1()
            Dim input =
<Workspace>
    <Project Language="C#" CommonReferences="true">
        <Document><![CDATA[
        using System;
        class {|Definition:EClass|} : Exception { }
        class Program
        {
            /// <exception cref="[|$$EClass|]"></exception>
            static void Main(string[] pargs)
            {

            }
        }]]>
        </Document>
    </Project>
</Workspace>
            Test(input)
        End Sub

        <Fact, Trait(Traits.Feature, Traits.Features.FindReferences)>
        Public Sub TestException1_VisualBasic()
            Dim input =
<Workspace>
    <Project Language="Visual Basic" CommonReferences="true">
        <Document><![CDATA[
        Imports System
        Class {|Definition:EClass|} : Inherits Exception
        End Class
        Class Program
            ''' <exception cref="[|$$EClass|]"></exception>
            Shared Sub Main(args As String())
            End Sub
        End Class]]>
        </Document>
    </Project>
</Workspace>
            Test(input)
        End Sub

        <Fact, Trait(Traits.Feature, Traits.Features.FindReferences)>
        Public Sub TestException2()
            Dim input =
<Workspace>
    <Project Language="C#" CommonReferences="true">
        <Document><![CDATA[
            using System;
            class EClass
            {
                internal class {|Definition:$$ENClass|} : Exception
                { }
            }
            class Program
            {
                /// <exception cref="EClass.[|ENClass|]"></exception>
                static void Main(string[] pargs)
                {

                }
            }]]>
        </Document>
    </Project>
</Workspace>
            Test(input)
        End Sub

        <Fact, Trait(Traits.Feature, Traits.Features.FindReferences)>
        Public Sub TestException2_VisualBasic()
            Dim input =
<Workspace>
    <Project Language="Visual Basic" CommonReferences="true">
        <Document><![CDATA[
            Imports System
            Class EClass
                Class {|Definition:$$ENClass|} : Inherits Exception
                End Class
            End Class
            Class Program
                ''' <exception cref="EClass.[|ENClass|]"></exception>
                Shared Sub Main(args As String())
                End Sub
            End Class]]>
        </Document>
    </Project>
</Workspace>
            Test(input)
        End Sub

        <Fact, Trait(Traits.Feature, Traits.Features.FindReferences)>
        Public Sub TestException3()
            Dim input =
<Workspace>
    <Project Language="C#" CommonReferences="true">
        <ProjectReference>VBAssembly1</ProjectReference>
        <Document><![CDATA[
            using System;
            class Program
            {
                /// <exception cref="[|EClass|]"></exception>
                static void Main(string[] pargs)
                {
                    [|EClass|] p = new [|EClass|]();
                }
            }]]>
        </Document>
    </Project>
    <Project Language="Visual Basic" CommonReferences="true" AssemblyName="VBAssembly1">
        <Document>
            Imports System
            Public Class {|Definition:$$EClass|}
                Inherits Exception
            End Class
            Module Program
                Sub Main(args As String())

                End Sub
            End Module
        </Document>
    </Project>
</Workspace>
            Test(input)
        End Sub

        <Fact, Trait(Traits.Feature, Traits.Features.FindReferences)>
        Public Sub TestException3_VisualBasic()
            Dim input =
<Workspace>
    <Project Language="Visual Basic" CommonReferences="true">
        <ProjectReference>CSAssembly1</ProjectReference>
        <Document><![CDATA[
            Imports System
            Class Program
                ''' <exception cref="[|EClass|]"></exception>
                Shared Sub Main(args As String())
                    Dim p As [|EClass|] = new [|EClass|]();
                End Sub
            End Class]]>
        </Document>
    </Project>
    <Project Language="C#" CommonReferences="true" AssemblyName="CSAssembly1">
        <Document><![CDATA[
            using System;
            public class {|Definition:$$EClass|} : Exception { }
            static class Program
            {
                public static void Main(string[] args) { }
            }
        ]]></Document>
    </Project>
</Workspace>
            Test(input)
        End Sub

        <Fact, Trait(Traits.Feature, Traits.Features.FindReferences)>
        Public Sub TestException3_Inverse()
            Dim input =
<Workspace>
    <Project Language="C#" CommonReferences="true">
        <ProjectReference>VBAssembly1</ProjectReference>
        <Document><![CDATA[
            using System;
            class Program
            {
                /// <exception cref="[|$$EClass|]"></exception>
                static void Main(string[] pargs)
                {
                    [|EClass|] p = new [|EClass|]();
                }
            }]]>
        </Document>
    </Project>
    <Project Language="Visual Basic" CommonReferences="true" AssemblyName="VBAssembly1">
        <Document>
            Imports System
            Public Class {|Definition:EClass|}
                Inherits Exception
            End Class
            Module Program
                Sub Main(args As String())

                End Sub
            End Module
        </Document>
    </Project>
</Workspace>
            Test(input)
        End Sub

        <Fact, Trait(Traits.Feature, Traits.Features.FindReferences)>
        Public Sub TestException3_Inverse_VisualBasic()
            Dim input =
<Workspace>
    <Project Language="Visual Basic" CommonReferences="true">
        <ProjectReference>CSAssembly1</ProjectReference>
        <Document><![CDATA[
            Imports System
            Class Program
                ''' <exception cref="[|$$EClass|]"></exception>
                Shared Sub Main(args As String())
                    Dim p As [|EClass|] = new [|EClass|]();
                End Sub
            End Class]]>
        </Document>
    </Project>
    <Project Language="C#" CommonReferences="true" AssemblyName="CSAssembly1">
        <Document><![CDATA[
            using System;
            public class {|Definition:EClass|} : Exception { }
            static class Program
            {
                public static void Main(string[] args) { }
            }
        ]]></Document>
    </Project>
</Workspace>
            Test(input)
        End Sub

        <Fact, Trait(Traits.Feature, Traits.Features.FindReferences)>
        Public Sub TestCrefConstructor1()
            Dim input =
<Workspace>
    <Project Language="C#" CommonReferences="true">
        <Document><![CDATA[
            using System;
            class A
            {
                public class B : Exception
                {
                    public {|Definition:B|}() { }
                }
            }

            class Program
            {
                /// <summary>
                ///
                /// </summary>
                /// <param name="args"></param>
                /// <exception cref="A.B.[|B|]"></exception>
                static void Main(string[] args)
                {
                    A.B x = new A.[|$$B|]();
                }
            }]]>
        </Document>
    </Project>
</Workspace>
            Test(input)
        End Sub

        <WorkItem(769369)>
        <Fact, Trait(Traits.Feature, Traits.Features.FindReferences)>
        Public Sub TestCrefConstructor1_VisualBasic()
            Dim input =
<Workspace>
    <Project Language="Visual Basic" CommonReferences="true">
        <Document><![CDATA[
            Imports System
            Class A
                Public Class B : Inherits Exception
                    Public Sub {|Definition:New|}()
                    End Sub
                End Class
            End Class

            Class Program
                ''' <summary>
                ''' </summary>
                ''' <param name="args"></param>
                ''' <exception cref="A.B.[|New|]()"></exception>
                Shared Sub Main(args As String())
                    Dim x As A.B = New A.[|$$B|]()
                End Sub
            End Class]]>
        </Document>
    </Project>
</Workspace>
            Test(input)
        End Sub

        <Fact, Trait(Traits.Feature, Traits.Features.FindReferences)>
        Public Sub TestCrefConstructor2()
            Dim input =
<Workspace>
    <Project Language="C#" CommonReferences="true">
        <Document><![CDATA[
            using System;
            class A
            {
                public A() { }
                public {|Definition:A|}(int x) { }
            }
            class Program
            {
                /// <summary>
                /// <see cref="A.A()"/>
                /// <see cref="A.[|$$A|](int)"/>
                /// </summary>
                /// <param name="args"></param>
                static void Main(string[] args)
                {
                    A a = new A();
                }
            }]]>
        </Document>
    </Project>
</Workspace>
            Test(input)
        End Sub

        <Fact(Skip:="769477"), Trait(Traits.Feature, Traits.Features.FindReferences)>
        Public Sub TestCrefConstructor2_VisualBasic()
            Dim input =
<Workspace>
    <Project Language="Visual Basic" CommonReferences="true">
        <Document><![CDATA[
            Imports System
            Class A
                Public Sub New()
                End Sub
                Public Sub {|Definition:New|}(x As Integer)
                End Sub
            End Class
            Class Program
                ''' <summary>
                ''' <see cref="A.New()"/>
                ''' <see cref="A.[|$$New|](Integer)"/>
                ''' </summary>
                ''' <param name="args"></param>
                Shared Sub Main(args As String())
                    Dim a As A = new A()
                End Sub
            End Class]]>
        </Document>
    </Project>
</Workspace>
            Test(input)
        End Sub

        <Fact, Trait(Traits.Feature, Traits.Features.FindReferences)>
        Public Sub TestParam1()
            Dim input =
<Workspace>
    <Project Language="C#" CommonReferences="true">
        <Document><![CDATA[
            using System;
            class Program
            {
                static void Main(string[] args)
                {

                }
                /// <summary>
                ///
                /// </summary>
                /// <param name="[|x|]"></param>
                static void Foo(int {|Definition:$$x|}) { [|x|] = 1; }
            }]]>
        </Document>
    </Project>
</Workspace>
            Test(input)
        End Sub

        <Fact, Trait(Traits.Feature, Traits.Features.FindReferences)>
        Public Sub TestParam1_VisualBasic()
            Dim input =
<Workspace>
    <Project Language="Visual Basic" CommonReferences="true">
        <Document><![CDATA[
            Imports System
            Class Program
                Shared Sub Main(args As String())
                End Sub
                ''' <summary>
                '''
                ''' </summary>
                ''' <param name="[|x|]"></param>
                Shared Sub Foo({|Definition:$$x|} As Integer)
                    [|x|] = 1
                End Sub
            End Class]]>
        </Document>
    </Project>
</Workspace>
            Test(input)
        End Sub

        <Fact, Trait(Traits.Feature, Traits.Features.FindReferences)>
        Public Sub TestParam2()
            Dim input =
<Workspace>
    <Project Language="C#" CommonReferences="true">
        <Document><![CDATA[
            using System;
            class Program
            {
                static void Main(string[] args)
                {

                }
                /// <summary>
                ///
                /// </summary>
                /// <param name="[|$$x|]"></param>
                static void Foo(int {|Definition:x|}) { [|x|] = 1; }
            }]]>
        </Document>
    </Project>
</Workspace>
            Test(input)
        End Sub

        <Fact, Trait(Traits.Feature, Traits.Features.FindReferences)>
        Public Sub TestParam2_VisualBasic()
            Dim input =
<Workspace>
    <Project Language="Visual Basic" CommonReferences="true">
        <Document><![CDATA[
            Imports System
            Class Program
                Shared Sub Main(args As String())
                End Sub
                ''' <summary>
                '''
                ''' </summary>
                ''' <param name="[|$$x|]"></param>
                Shared Sub Foo({|Definition:x|} As Integer)
                    [|x|] = 1
                End Sub
            End Class]]>
        </Document>
    </Project>
</Workspace>
            Test(input)
        End Sub

        <Fact(Skip:="Bug 640274"), Trait(Traits.Feature, Traits.Features.FindReferences)>
        Public Sub TestParam3()
            Dim input =
<Workspace>
    <Project Language="C#" CommonReferences="true">
        <Document><![CDATA[
            using System;
            class Program
            {
                static void Main(string[] args)
                {

                }
                /// <summary>
                ///
                /// </summary>
                /// <param name="[|@if|]"></param>
                static void Foo(int {|Definition:$$@if|}) { }
            }]]>
        </Document>
    </Project>
</Workspace>
            Test(input)
        End Sub

        <Fact(Skip:="Bug 640274"), Trait(Traits.Feature, Traits.Features.FindReferences)>
        Public Sub TestParam3_VisualBasic()
            Dim input =
<Workspace>
    <Project Language="Visual Basic" CommonReferences="true">
        <Document><![CDATA[
            Imports System
            Class Program
                Shared Sub Main(args As String())
                End Sub
                ''' <summary>
                '''
                ''' </summary>
                ''' <param name="[|@if|]"></param>
                Shared Sub Foo({|Definition:$$[if]|} As Integer)
                End Sub
            End Class]]>
        </Document>
    </Project>
</Workspace>
            Test(input)
        End Sub

        <Fact, Trait(Traits.Feature, Traits.Features.FindReferences)>
        Public Sub TestParamRef1()
            Dim input =
<Workspace>
    <Project Language="C#" CommonReferences="true">
        <Document><![CDATA[
            using System;
            class Program
            {
                static void Main(string[] args)
                {

                }
                /// <summary>
                /// the <paramref name="[|$$x|]"/> parameter takes a number
                /// </summary>
                /// <param name="[|x|]"></param>
                /// <param name="y"></param>
                /// <param name="@if"></param>
                static void Foo(int {|Definition:x|}, int y, out int @if) { @if = 2; [|x|] = 1; }
            }]]>
        </Document>
    </Project>
</Workspace>
            Test(input)
        End Sub

        <Fact, Trait(Traits.Feature, Traits.Features.FindReferences)>
        Public Sub TestParamRef1_VisualBasic()
            Dim input =
<Workspace>
    <Project Language="Visual Basic" CommonReferences="true">
        <Document><![CDATA[
            Imports System
            Class Program
                Shared Sub Main(args As String())
                End Sub
                ''' <summary>
                ''' the <paramref name="[|$$x|]"/> parameter takes a number
                ''' </summary>
                ''' <param name="[|x|]"></param>
                ''' <param name="y"></param>
                ''' <param name="[if]"></param>
                Shared Sub Foo({|Definition:x|} As Integer, y As Integer, ByRef [if] As Integer)
                    [if] = 2
                    [|x|] = 1
                End Sub
            End Class]]>
        </Document>
    </Project>
</Workspace>
            Test(input)
        End Sub

        <Fact, Trait(Traits.Feature, Traits.Features.FindReferences)>
        Public Sub TestPermission()
            Dim input =
<Workspace>
    <Project Language="C#" CommonReferences="true">
        <Document><![CDATA[
            class Program
            {
                static void Main(string[] args)
                {
                    System.[|Security|].PermissionSet x;
                }
                /// <permission cref="System.[|$$Security|].PermissionSet"></permission>
                static void Foo(int x, int y, out int @if) { @if = 2; }
            }]]>
        </Document>
    </Project>
</Workspace>
            Test(input)
        End Sub

        <Fact, Trait(Traits.Feature, Traits.Features.FindReferences)>
        Public Sub TestPermission_VisualBasic()
            Dim input =
<Workspace>
    <Project Language="Visual Basic" CommonReferences="true">
        <Document><![CDATA[
            Class Program
                Shared Sub Main(args As String())
                    Dim x As System.[|Security|].PermissionSet
                End Sub
                ''' <permission cref="System.[|$$Security|].PermissionSet"></permission>
                Shared Sub Foo(x As Integer, y As Integer, ByRef [if] As Integer)
                    [if] = 2
                End Sub
            End Class]]>
        </Document>
    </Project>
</Workspace>
            Test(input)
        End Sub

        <Fact, Trait(Traits.Feature, Traits.Features.FindReferences)>
        Public Sub TestTypeParameters1()
            Dim input =
<Workspace>
    <Project Language="C#" CommonReferences="true">
        <Document><![CDATA[
            using System;
            /// <typeparam name="T"></typeparam>
            class Generic<T>
            {
                public Generic() { }
                public T Foo(T x) { return x; }
                /// <summary>
                /// <typeparam name="[|$$U|]"></typeparam>
                /// </summary>
                /// <param name="x"></param>
                /// <returns></returns>
                public [|U|] Foo<{|Definition:U|}>([|U|] x) {return x; }
            }]]>
        </Document>
    </Project>
</Workspace>
            Test(input)
        End Sub

        <Fact, Trait(Traits.Feature, Traits.Features.FindReferences)>
        Public Sub TestTypeParameters1_VisualBasic()
            Dim input =
<Workspace>
    <Project Language="Visual Basic" CommonReferences="true">
        <Document><![CDATA[
            Imports System
            ''' <typeparam name="T"></typeparam>
            Class Generic(Of T)
                Public Sub New()
                End Sub
                Public Function Foo(x As T) As T
                    Return x
                End Function
                ''' <summary>
                ''' <typeparam name="[|$$U|]"></typeparam>
                ''' </summary>
                ''' <param name="x"></param>
                ''' <returns></returns>
                Public Function Foo(Of {|Definition:U|})(x As [|U|]) As [|U|]
                    Return x
                End Function
            End Class]]>
        </Document>
    </Project>
</Workspace>
            Test(input)
        End Sub

        <Fact, Trait(Traits.Feature, Traits.Features.FindReferences)>
        Public Sub TestTypeParameters2()
            Dim input =
<Workspace>
    <Project Language="C#" CommonReferences="true">
        <Document><![CDATA[
            using System;
            /// <typeparam name="[|T|]"></typeparam>
            class Generic<{|Definition:T|}>
            {
                public Generic() { }
                /// <summary>
                /// <typeparamref name="[|T|]"/>
                /// </summary>
                /// <param name="x"></param>
                /// <returns></returns>
                public [|$$T|] Foo([|T|] x) { return x; }
            }]]>
        </Document>
    </Project>
</Workspace>
            Test(input)
        End Sub

        <Fact, Trait(Traits.Feature, Traits.Features.FindReferences)>
        Public Sub TestTypeParameters2_VisualBasic()
            Dim input =
<Workspace>
    <Project Language="Visual Basic" CommonReferences="true">
        <Document><![CDATA[
            Imports System
            ''' <typeparam name="[|T|]"></typeparam>
            Class Generic(Of {|Definition:T|})
                Public Sub New()
                End Sub
                ''' <summary>
                ''' <typeparamref name="[|T|]"/>
                ''' </summary>
                ''' <param name="x"></param>
                ''' <returns></returns>
                Public Function Foo(x As [|T|]) As [|$$T|]
                    Return x
                End Function
            End Class]]>
        </Document>
    </Project>
</Workspace>
            Test(input)
        End Sub

        <Fact, Trait(Traits.Feature, Traits.Features.FindReferences)>
        Public Sub TestTypeParametersInCref()
            Dim input =
<Workspace>
    <Project Language="C#" CommonReferences="true">
        <Document><![CDATA[
            using System;
            class Tester<{|Definition:T|}>
            {
                /// <summary>
                /// <see cref="Tester{T}.Foo(T)"/>
                /// </summary>
                /// <param name="x"></param>
                public static void Foo([|$$T|] x) { }
            }]]>
        </Document>
    </Project>
</Workspace>
            Test(input)
        End Sub

        <Fact, Trait(Traits.Feature, Traits.Features.FindReferences)>
        Public Sub TestTypeParametersInCref_VisualBasic()
            Dim input =
<Workspace>
    <Project Language="Visual Basic" CommonReferences="true">
        <Document><![CDATA[
            Imports System
            Class Tester(Of {|Definition:T|})
                ''' <summary>
                ''' <see cref="Tester(Of T).Foo(T)"/>
                ''' </summary>
                ''' <param name="x"></param>
                Public Shared Sub Foo(x As [|$$T|])
                End Sub
            End Class]]>
        </Document>
    </Project>
</Workspace>
            Test(input)
        End Sub

        <Fact, Trait(Traits.Feature, Traits.Features.FindReferences)>
        Public Sub TestMethodParametersInCref()
            Dim input =
<Workspace>
    <Project Language="C#" CommonReferences="true">
        <Document><![CDATA[
            using System;
            class {|Definition:Tester|}
            {
                /// <summary>
                /// <seealso cref="[|Tester|].Foo([|Tester|])"/>
                /// </summary>
                /// <param name="x"></param>
                public static void Foo(int x) { }
                public static void Foo([|$$Tester|] x) { }
            }]]>
        </Document>
    </Project>
</Workspace>
            Test(input)
        End Sub

        <Fact, Trait(Traits.Feature, Traits.Features.FindReferences)>
        Public Sub TestMethodParametersInCref_VisualBasic()
            Dim input =
<Workspace>
    <Project Language="Visual Basic" CommonReferences="true">
        <Document><![CDATA[
            Imports System
            Class {|Definition:Tester|}
                ''' <summary>
                ''' <seealso cref="[|Tester|].Foo([|Tester|])"/>
                ''' </summary>
                ''' <param name="x"></param>
                Public Shared Sub Foo(x As Integer)
                End Sub
                Public Shared Sub Foo(x As [|$$Tester|])
                End Sub
            End Class]]>
        </Document>
    </Project>
</Workspace>
            Test(input)
        End Sub

        <Fact, Trait(Traits.Feature, Traits.Features.FindReferences)>
        Public Sub TestFieldInCref()
            Dim input =
<Workspace>
    <Project Language="C#" CommonReferences="true">
        <Document><![CDATA[
            using System;
            class Tester
            {
                private int {|Definition:@if|};
                /// <summary>
                /// <see cref="Tester.[|@if|]"/>
                /// </summary>
                /// <returns>int</returns>
                /// <value>int</value>
                public int X
                {
                    get
                    {
                        return [|@if|]; // Rename x to if
                    }
                    set
                    {
                        [|$$@if|] = value;
                    }
                }
            }]]>
        </Document>
    </Project>
</Workspace>
            Test(input)
        End Sub

        <Fact, Trait(Traits.Feature, Traits.Features.FindReferences)>
        Public Sub TestFieldInCref_VisualBasic()
            Dim input =
<Workspace>
    <Project Language="Visual Basic" CommonReferences="true">
        <Document><![CDATA[
            Imports System
            Class Tester
                Private {|Definition:[if]|} As Integer
                ''' <summary>
                ''' <see cref="Tester.[|[if]|]"/>
                ''' </summary>
                ''' <returns>int</returns>
                ''' <value>int</value>
                Public Property X As Integer
                    Get
                        Return [|[if]|] ' Rename x to if
                    End Get
                    Set
                        [|$$[if]|] = Value
                    End Set
                End Property
            End Class]]>
        </Document>
    </Project>
</Workspace>
            Test(input)
        End Sub

        <Fact, Trait(Traits.Feature, Traits.Features.FindReferences)>
        Public Sub TestSpecialTypeSimpleNameInCref()
            Dim input =
<Workspace>
    <Project Language="C#" CommonReferences="true">
        <Document><![CDATA[
            using System;
            class A
            {
                /// <summary>
                /// <see cref="[|int|]"/>
                /// </summary>
                private [|int|] x;
                /// <summary>
                /// <see cref="[|int|]"/>
                /// </summary>
                /// <returns>int</returns>
                /// <value>int</value>
                public static [|$$int|] Foo() { return 1; } // Invoke FAR on int here
            }]]>
        </Document>
    </Project>
</Workspace>
            Test(input)
        End Sub

        <Fact(), Trait(Traits.Feature, Traits.Features.FindReferences)>
        Public Sub TestSpecialTypeSimpleNameInCref_VisualBasic()
            Dim input =
<Workspace>
    <Project Language="Visual Basic" CommonReferences="true">
        <Document><![CDATA[
            Imports System
            Class A
                ''' <summary>
                ''' <see cref="[|Integer|]"/>
                ''' </summary>
                Private x As [|Integer|]
                ''' <summary>
                ''' <see cref="[|Integer|]"/>
                ''' </summary>
                Public Shared Function Foo() As [|$$Integer|]
                    Return 1 ' Invoke FAR on Integer here
                End Function
            End Class]]>
        </Document>
    </Project>
</Workspace>
            Test(input)
        End Sub

        <Fact(Skip:="Bug 640502"), Trait(Traits.Feature, Traits.Features.FindReferences)>
        Public Sub TestInterfaceInCref1()
            Dim input =
<Workspace>
    <Project Language="C#" CommonReferences="true">
        <Document><![CDATA[
            using System;
            interface I
            {
                void {|Definition:Foo|}();
            }
            abstract class C
            {
                public abstract void Boo();
                public void {|Definition:Foo|}() { }
            }
            class A : C, I
            {
                /// <summary>
                /// <seealso cref="[|Foo|]()"/>
                /// </summary>
                public override void Boo() { [|$$Foo|](); }
            }]]>
        </Document>
    </Project>
</Workspace>
            Test(input)
        End Sub

        <Fact(Skip:="Bug 640502"), Trait(Traits.Feature, Traits.Features.FindReferences)>
        Public Sub TestInterfaceInCref1_VisualBasic()
            Dim input =
<Workspace>
    <Project Language="Visual Basic" CommonReferences="true">
        <Document><![CDATA[
            Imports System
            Interface I
                Sub {|Definition:Foo|}()
            End Interface
            Abstract Class C
                Public MustOverride Sub Boo()
                Public Sub {|Definition:Foo|}()
                End Sub
            End Class
            Class A : Inherits C : Implements I
                ''' <summary>
                ''' <seealso cref="[|Foo|]()"/>
                ''' </summary>
                Public Overrides Sub Boo() Implements I.[|Foo|]
                    [|$$Foo|]()
                End Sub
            End Class]]>
        </Document>
    </Project>
</Workspace>
            Test(input)
        End Sub

        <Fact, Trait(Traits.Feature, Traits.Features.FindReferences)>
        Public Sub TestInterfaceInCref2()
            Dim input =
<Workspace>
    <Project Language="C#" CommonReferences="true">
        <Document><![CDATA[
            using System;
            interface I
            {
                void {|Definition:Foo|}();
            }
            abstract class C
            {
                public abstract void {|Definition:Foo|}();
            }
            class A : C, I
            {
                /// <summary>
                /// <seealso cref="[|Foo|]()"/>
                /// </summary>
                public override void {|Definition:$$Foo|}() {  }
            }]]>
        </Document>
    </Project>
</Workspace>
            Test(input)
        End Sub

        <Fact, Trait(Traits.Feature, Traits.Features.FindReferences)>
        Public Sub TestInterfaceInCref2_VisualBasic()
            Dim input =
<Workspace>
    <Project Language="Visual Basic" CommonReferences="true">
        <Document><![CDATA[
            Imports System
            Interface I
                Sub {|Definition:Foo|}()
            End Interface
            MustInherit Class C
                Public MustOverride Sub {|Definition:Foo|}()
            End Class
            Class A : Inherits C : Implements I
                ''' <summary>
                ''' <seealso cref="[|Foo|]()"/>
                ''' </summary>
                Public Overrides Sub {|Definition:$$Foo|}() Implements I.[|Foo|]
                End Sub
            End Class]]>
        </Document>
    </Project>
</Workspace>
            Test(input)
        End Sub

        <Fact, Trait(Traits.Feature, Traits.Features.FindReferences)>
        Public Sub TestInterfaceInCref3()
            Dim input =
<Workspace>
    <Project Language="C#" CommonReferences="true">
        <Document><![CDATA[
            using System;
            interface I
            {
                void {|Definition:Foo|}();
            }
            abstract class C
            {
                public abstract void Foo();
            }
            class A : C, I
            {
                /// <summary>
                /// <seealso cref="Foo()"/>
                /// </summary>
                public override void Foo() {  }
                /// <summary>
                /// <see cref="I.[|$$Foo|]()"/>
                /// </summary>
                void I.{|Definition:Foo|}() { }
            }]]>
        </Document>
    </Project>
</Workspace>
            Test(input)
        End Sub

        <Fact, Trait(Traits.Feature, Traits.Features.FindReferences)>
        Public Sub TestInterfaceInCref3_VisualBasic()
            Dim input =
<Workspace>
    <Project Language="Visual Basic" CommonReferences="true">
        <Document><![CDATA[
            Imports System
            Interface I
                Sub {|Definition:Foo|}()
            End Interface
            MustInherit Class C
                Public MustOverride Sub Foo()
            End Class
            Class A : Inherits C : Implements I
                ''' <summary>
                ''' <seealso cref="Foo()"/>
                ''' </summary>
                Public Overrides Sub Foo()
                End Sub
                ''' <summary>
                ''' <see cref="I.[|$$Foo|]()"/>
                ''' </summary>
                Public Sub {|Definition:FooImpl|}() Implements I.[|Foo|]
                End Sub
            End Class]]>
        </Document>
    </Project>
</Workspace>
            Test(input)
        End Sub

        <Fact, Trait(Traits.Feature, Traits.Features.FindReferences)>
        Public Sub TestInheritanceInCref1()
            Dim input =
<Workspace>
    <Project Language="C#" CommonReferences="true">
        <Document><![CDATA[
            using System;
            class Base
            {
                public {|Definition:Base|}(int x) { }
            }
            class Derived : Base
            {

                /// <summary>
                /// <see cref="Base.[|Base|](int)"/>
                /// </summary>
                /// <param name="x"></param>
                public Derived(int x) : [|$$base|](x)
                {

                }
                public void Base(int x) { }
            }]]>
        </Document>
    </Project>
</Workspace>
            Test(input)
        End Sub

        <WorkItem(769369)>
        <Fact, Trait(Traits.Feature, Traits.Features.FindReferences)>
        Public Sub TestInheritanceInCref1_VisualBasic()
            Dim input =
<Workspace>
    <Project Language="Visual Basic" CommonReferences="true">
        <Document><![CDATA[
            Imports System
            Class Base
                Public Sub {|Definition:New|}(x As Integer)
                End Sub
            End Class
            Class Derived : Inherits Base
                ''' <summary>
                ''' <see cref="Base.[|New|](Integer)"/>
                ''' </summary>
                ''' <param name="x"></param>
                Public Sub New(x As Integer)
                    MyBase.[|$$New|](x)
                End Sub
            End Class]]>
        </Document>
    </Project>
</Workspace>
            Test(input)
        End Sub

        <Fact, Trait(Traits.Feature, Traits.Features.FindReferences)>
        Public Sub TestOverloadingInCref()
            Dim input =
<Workspace>
    <Project Language="C#" CommonReferences="true">
        <Document><![CDATA[
            using System;
            class B
                {
                    /// <summary>
                    /// <see cref="[|$$Del|]"/>
                    /// </summary>
                    /// <param name="x"></param>
                    public void {|Definition:Del|}(int x) { }
                    public void Del(string x) { }
                }]]>
        </Document>
    </Project>
</Workspace>
            Test(input)
        End Sub

        <Fact, Trait(Traits.Feature, Traits.Features.FindReferences)>
        Public Sub TestOverloadingInCref_VisualBasic()
            Dim input =
<Workspace>
    <Project Language="Visual Basic" CommonReferences="true">
        <Document><![CDATA[
            Imports System
            Class B
                ''' <summary>
                ''' <see cref="[|$$Del|]"/>
                ''' </summary>
                ''' <param name="x"></param>
                Public Sub {|Definition:Del|}(x As Integer)
                End Sub
                Public Sub Del(x As String)
                End Sub
            End Class]]>
        </Document>
    </Project>
</Workspace>
            Test(input)
        End Sub

        <Fact, Trait(Traits.Feature, Traits.Features.FindReferences)>
        Public Sub TestInheritanceInCref()
            Dim input =
<Workspace>
    <Project Language="C#" CommonReferences="true">
        <Document><![CDATA[
class P
{
    public int {|Definition:y|};
}
class Q : P
{
    /// <summary>
    /// <see cref="y"/>
    /// </summary>
    void Sub()
    {
        int x = [|$$y|]; // Invoke FAR here
    }
}]]>
        </Document>
    </Project>
</Workspace>
            Test(input)
        End Sub

        <Fact(), Trait(Traits.Feature, Traits.Features.FindReferences)>
        Public Sub TestInheritanceInCref_VisualBasic()
            Dim input =
<Workspace>
    <Project Language="Visual Basic" CommonReferences="true">
        <Document><![CDATA[
Class P
    Public {|Definition:y|} As Integer
End Class
Class Q : Inherits P
    ''' <summary>
    ''' <see cref="[|y|]"/>
    ''' </summary>
    Sub Subroutine()
        Dim x As Integer = [|$$y|] // Invoke FAR here
    End Sub
End Class]]>
        </Document>
    </Project>
</Workspace>
            Test(input)
        End Sub

        <Fact, Trait(Traits.Feature, Traits.Features.FindReferences)>
        Public Sub TestConstructorInCref()
            Dim input =
<Workspace>
    <Project Language="C#" CommonReferences="true">
        <Document><![CDATA[
                using System;
                class {|Definition:A|}
                {
                    /// <summary>
                    /// <see cref="[|$$A|]"/>
                    /// <see cref="[|A|](int)"/>
                    /// </summary>
                    public {|Definition:A|}() { }
                    public {|Definition:A|}(int x) { }
                }]]>
        </Document>
    </Project>
</Workspace>
            Test(input)
        End Sub

        <WorkItem(769369)>
        <Fact, Trait(Traits.Feature, Traits.Features.FindReferences)>
        Public Sub TestConstructorInCref_VisualBasic()
            Dim input =
<Workspace>
    <Project Language="Visual Basic" CommonReferences="true">
        <Document><![CDATA[
                Imports System
                Class A
                    ''' <summary>
                    ''' <see cref="[|$$New|]()"/>
                    ''' <see cref="[|New|](Integer)"/>
                    ''' </summary>
                    Public Sub {|Definition:New|}()
                    End Sub
                    Public Sub New(x As Integer)
                    End Sub
                End Class]]>
        </Document>
    </Project>
</Workspace>
            Test(input)
        End Sub

        <Fact, Trait(Traits.Feature, Traits.Features.FindReferences)>
        Public Sub TestDelegateInCref()
            Dim input =
<Workspace>
    <Project Language="C#" CommonReferences="true">
        <Document><![CDATA[
                using System;
                class A
                {
                    delegate void Del(int x);
                    class B
                    {
                        /// <summary>
                        /// <see cref="[|$$Del|]"/>
                        /// </summary>
                        /// <param name="x"></param>
                        public void {|Definition:Del|}(int x) { }
                }]]>
        </Document>
    </Project>
</Workspace>
            Test(input)
        End Sub

        <Fact, Trait(Traits.Feature, Traits.Features.FindReferences)>
        Public Sub TestDelegateInCref_VisualBasic()
            Dim input =
<Workspace>
    <Project Language="Visual Basic" CommonReferences="true">
        <Document><![CDATA[
                Imports System
                Class A
                    Delegate Sub Del(x As Integer)
                    Class B
                        ''' <summary>
                        ''' <see cref="[|$$Del|]"/>
                        ''' </summary>
                        ''' <param name="x"></param>
                        Public Sub {|Definition:Del|}(x As Integer)
                        End Sub
                    End Class
                End Class]]>
        </Document>
    </Project>
</Workspace>
            Test(input)
        End Sub

        <Fact, Trait(Traits.Feature, Traits.Features.FindReferences)>
        Public Sub TestScopeInCref()
            Dim input =
<Workspace>
    <Project Language="C#" CommonReferences="true">
        <Document><![CDATA[
                using System;
                class A
                {
                    delegate void Del(int x);
                    /// <summary>
                    /// <see cref="A.[|$$Del|]"/>
                    /// </summary>
                    class B
                    {
                        internal class A
                        {
                            internal class {|Definition:Del|}
                            {

                            }
                        }
                    }
                }]]>
        </Document>
    </Project>
</Workspace>
            Test(input)
        End Sub

        <Fact, Trait(Traits.Feature, Traits.Features.FindReferences)>
        Public Sub TestScopeInCref_VisualBasic()
            Dim input =
<Workspace>
    <Project Language="Visual Basic" CommonReferences="true">
        <Document><![CDATA[
                Imports System
                Class A
                    Delegate Sub Del(x As Integer)
                    ''' <summary>
                    ''' <see cref="A.[|$$Del|]"/>
                    ''' </summary>
                    Class B
                        Class A
                            Class {|Definition:Del|}
                            End Class
                        End Class
                    End Class
                End Class]]>
        </Document>
    </Project>
</Workspace>
            Test(input)
        End Sub

        <Fact(Skip:="641100"), Trait(Traits.Feature, Traits.Features.FindReferences)>
        Public Sub TestOperatorInCref1()
            Dim input =
<Workspace>
    <Project Language="C#" CommonReferences="true">
        <Document><![CDATA[
                using System;
                class Test
                {
                    /// <summary>
                    /// <see cref="[|operator|] !"/>
                    /// <see cref="[|operator|] +"/>
                    /// <see cref="[|$$operator|]"/>
                    /// </summary>
                    /// <param name="t"></param>
                    /// <returns></returns>
                    public static Test {|Definition:operator|} !(Test t)
                    {
                        return new Test();
                    }
                    public static int {|Definition:operator|} +(Test t1, Test t2)
                    {
                        return 1;
                    }
                }]]>
        </Document>
    </Project>
</Workspace>
            Test(input)
        End Sub

        <Fact(Skip:="641100"), Trait(Traits.Feature, Traits.Features.FindReferences)>
        Public Sub TestOperatorInCref1_VisualBasic()
            Dim input =
<Workspace>
    <Project Language="Visual Basic" CommonReferences="true">
        <Document><![CDATA[
                Imports System
                Class Test
                    ''' <summary>
                    ''' <see cref="[|Operator|] Not"/>
                    ''' <see cref="[|Operator|] +"/>
                    ''' <see cref="[|$$Operator|]"/>
                    ''' </summary>
                    ''' <param name="t"></param>
                    ''' <returns></returns>
                    Public Shared {|Definition:Operator|} Not(t As Test) As Test
                        Return New Test()
                    End Operator
                    Public Shared {|Definition:Operator|} +(t1 As Test, t2 As Test) As Integer
                        Return 1
                    End Operator
                End Class]]>
        </Document>
    </Project>
</Workspace>
            Test(input)
        End Sub

        <Fact(Skip:="641100"), Trait(Traits.Feature, Traits.Features.FindReferences)>
        Public Sub TestOperatorInCref2()
            Dim input =
<Workspace>
    <Project Language="C#" CommonReferences="true">
        <Document><![CDATA[
                using System;
                class Test
                {
                    /// <summary>
                    /// <see cref="[|$$operator|] !"/>
                    /// <see cref="operator +"/>
                    /// <see cref="[|operator|]"/>
                    /// </summary>
                    /// <param name="t"></param>
                    /// <returns></returns>
                    public static Test {|Definition:operator|} !(Test t)
                    {
                        return new Test();
                    }
                    public static int operator +(Test t1, Test t2)
                    {
                        return 1;
                    }
                }]]>
        </Document>
    </Project>
</Workspace>
            Test(input)
        End Sub

        <Fact(Skip:="641100"), Trait(Traits.Feature, Traits.Features.FindReferences)>
        Public Sub TestOperatorInCref2_VisualBasic()
            Dim input =
<Workspace>
    <Project Language="Visual Basic" CommonReferences="true">
        <Document><![CDATA[
                Imports System
                Class Test
                    ''' <summary>
                    ''' <see cref="[|$$Operator|] Not"/>
                    ''' <see cref="Operator +"/>
                    ''' <see cref="[|Operator|]"/>
                    ''' </summary>
                    ''' <param name="t"></param>
                    ''' <returns></returns>
                    Public Shared {|Definition:Operator|} Not(t As Test) As Test
                        Return New Test()
                    End Operator
                    Public Shared Operator +(t1 As Test, t2 As Test) As Integer
                        Return 1
                    End Operator
                End Class]]>
        </Document>
    </Project>
</Workspace>
            Test(input)
        End Sub

        <Fact(Skip:="641100"), Trait(Traits.Feature, Traits.Features.FindReferences)>
        Public Sub TestOperatorInCref3()
            Dim input =
<Workspace>
    <Project Language="C#" CommonReferences="true">
        <Document><![CDATA[
                using System;
                class Test
                {
                    /// <summary>
                    /// <see cref="operator !"/>
                    /// <see cref="[|$$operator|] +"/>
                    /// <see cref="[|operator|](Test,Test)"/>
                    /// <see cref="[|operator|]"/>
                    /// </summary>
                    /// <param name="t"></param>
                    /// <returns></returns>
                    public static Test operator !(Test t)
                    {
                        return new Test();
                    }
                    public static int {|Definition:operator|} +(Test t1, Test t2)
                    {
                        return 1;
                    }
                }]]>
        </Document>
    </Project>
</Workspace>
            Test(input)
        End Sub

        <Fact(Skip:="641100"), Trait(Traits.Feature, Traits.Features.FindReferences)>
        Public Sub TestOperatorInCref3_VisualBasic()
            Dim input =
<Workspace>
    <Project Language="Visual Basic" CommonReferences="true">
        <Document><![CDATA[
                Imports System
                Class Test
                    ''' <summary>
                    ''' <see cref="Operator Not"/>
                    ''' <see cref="[|$$Operator|] +"/>
                    ''' <see cref="[|Operator|](Test,Test)"/>
                    ''' <see cref="[|Operator|]"/>
                    ''' </summary>
                    ''' <param name="t"></param>
                    ''' <returns></returns>
                    Public Shared Operator Not(t As Test) As Test
                        Return New Test()
                    End Operator
                    Public Shared {|Definition:Operator|} +(t1 As Test, t2 As Test) As Integer
                        Return 1
                    End Operator
                End Class]]>
        </Document>
    </Project>
</Workspace>
            Test(input)
        End Sub

        <Fact, Trait(Traits.Feature, Traits.Features.FindReferences)>
        Public Sub TestIndexInCref1()
            Dim input =
<Workspace>
    <Project Language="C#" CommonReferences="true">
        <Document><![CDATA[
                using System;
                class Test
                {
                    /// <summary>
                    /// <see cref="[||]this[int]"/>
                    /// </summary>
                    /// <param name="i"></param>
                    /// <returns></returns>
                    public int {|Definition:$$this|}[int i]
                    {
                        get { return i; }
                    }
                    public float this[float i]
                    {
                        get { return i; }
                    }
                }]]>
        </Document>
    </Project>
</Workspace>
            Test(input)
        End Sub

        <Fact, Trait(Traits.Feature, Traits.Features.FindReferences)>
        Public Sub TestIndexInCref1_VisualBasic()
            Dim input =
<Workspace>
    <Project Language="Visual Basic" CommonReferences="true">
        <Document><![CDATA[
                Imports System
                Class Test
                    ''' <summary>
                    ''' <see cref="[|Item|](Integer)"/>
                    ''' </summary>
                    ''' <param name="i"></param>
                    ''' <returns></returns>
                    Public ReadOnly Property {|Definition:$$Item|}(i As Integer) As Integer
                        Get
                            Return i
                        End Get
                    End Property
                    Public ReadOnly Property Item(i As Single) As Single
                        Get
                            Return i
                        End Get
                    End Property
                End Class]]>
        </Document>
    </Project>
</Workspace>
            Test(input)
        End Sub

        <Fact, Trait(Traits.Feature, Traits.Features.FindReferences)>
        Public Sub TestIndexInCref2()
            Dim input =
<Workspace>
    <Project Language="C#" CommonReferences="true">
        <Document><![CDATA[
                using System;
                class Test
                {
                    /// <summary>
                    /// <see cref="[|$$|]this"/>
                    /// </summary>
                    /// <param name="i"></param>
                    /// <returns></returns>
                    public int {|Definition:this|}[int i]
                    {
                        get { return i; }
                    }
                    public float this[float i]
                    {
                        get { return i; }
                    }
                }]]>
        </Document>
    </Project>
</Workspace>
            Test(input)
        End Sub

        <Fact, Trait(Traits.Feature, Traits.Features.FindReferences)>
        Public Sub TestIndexInCref2_VisualBasic()
            Dim input =
<Workspace>
    <Project Language="Visual Basic" CommonReferences="true">
        <Document><![CDATA[
                Imports System
                Class Test
                    ''' <summary>
                    ''' <see cref="[|$$Item|]"/>
                    ''' </summary>
                    ''' <param name="i"></param>
                    ''' <returns></returns>
                    Public ReadOnly Property {|Definition:Item|}(i As Integer) As Integer
                        Get
                            Return i
                        End Get
                    End Property
                    Public ReadOnly Property Item(i As Single) As Single
                        Get
                            Return i
                        End Get
                    End Property
                End Class]]>
        </Document>
    </Project>
</Workspace>
            Test(input)
        End Sub

        <Fact, Trait(Traits.Feature, Traits.Features.FindReferences)>
        Public Sub TestIndexInCref3()
            Dim input =
<Workspace>
    <Project Language="C#" CommonReferences="true">
        <ProjectReference>VBAssembly1</ProjectReference>
        <Document><![CDATA[
            using System;
            class Program
            {
                /// <see cref="GetDNSaliases.[||]this[int]"/>
                static void Main(string[] args) { }
                {
                }
            }
            ]]>
        </Document>
    </Project>
    <Project Language="Visual Basic" CommonReferences="true" AssemblyName="VBAssembly1">
        <Document><![CDATA[
            Imports System
            Public Class GetDNSaliases
                Default Public ReadOnly Property {|Definition:$$Item|}(ByVal nIndex As Integer) As String
                    Get
                        Return ""
                    End Get
                End Property
            End Class
            ]]>
        </Document>
    </Project>
</Workspace>
            Test(input)
        End Sub

        <Fact(Skip:="783135"), Trait(Traits.Feature, Traits.Features.FindReferences)>
        Public Sub TestIndexInCref3_VisualBasic()
            Dim input =
<Workspace>
    <Project Language="Visual Basic" CommonReferences="true">
        <ProjectReference>CSAssembly1</ProjectReference>
        <Document><![CDATA[
            Imports System
            Class Program
                ''' <see cref="GetDNSaliases.[|Item|](Integer)"/>
                Shared Sub Main(args As String())
                End Sub
            End Class
            ]]>
        </Document>
    </Project>
    <Project Language="C#" CommonReferences="true" AssemblyName="CSAssembly1">
        <Document><![CDATA[
            using System;
            public class GetDNSaliases
            {
                public string {|Definition:$$this|}[int nIndex]
                {
                    get { return ""; }
                }
            }
            ]]>
        </Document>
    </Project>
</Workspace>
            Test(input)
        End Sub
    End Class
End Namespace

redpajama_set_name: RedPajamaGithub


text:
Hankook dispute: Hungarian workers defy strikebreaking tactics to win big pay rise
Members of IndustriAll Europe's Hungarian affiliate, VDSZ, working for multinational tire manufacturer, Hankook, have won a substantial pay rise after a determined strike.
After a campaign of strike action that began on March 6, the union has today announced that it has successfully negotiated a wage rise that exceeds their initial demand of 18%.
Wages for workers at the South Korean company's plant in Dunaujváros are set to be 18.5% higher on average.Details of the settlement include:
A 6% bonus for workers on the 6pm to 6am shifts, which was previously reserved only for those who relinquished their right to take 14 of their holiday days consecutively.
A substantial loyalty bonus which was previously received after 10 years work at the company will be paid out to all workers who stay for five years. A precondition that workers must have taken fewer than 8 days sickness leave has also been dropped.
Workers on the lowest wage scale will receive a 5% pay rise.
This victory was achieved in spite of strike breaking tactics employed by management, which included paying those who continued to work 50% more and an additional overtime allowance.
Management also threatened to fire workers who went on strike and replace them with workers from another Hankook plant in Mongolia.
The result was a big rise in union membership at the plant and a substantial drop in production.
Unfortunately union recognition has still not yet been fully achieved, but the union will be represented on a 'working group' to discuss conditions and production.
At a press conference, Tamas Szekely of VDSZ thanked IndustriAll Europe and IndustriALL Global for their support and solidarity during the dispute and said the strike showed the importance of organising at plant level in the chemical and tire industry.
IndustriAll Europe general secretary Luc Triangle said: "We congratulate our sisters and brothers in VDSZ for securing this important victory in difficult circumstances for hard working people who deserve a fair share of the profits they are generating for this multinational company.
"This case once again shows it pays to be part of a trade union. It also demonstrates the benefits for workers – and employers – of agreeing wages and working conditions by bringing unions and management round the table through collective bargaining rather than industrial disputes.
"Hankook should learn the lessons from this costly dispute by fully recognising the union."
Our strategic advisor, Ildiko Kren, also this week travelled to Hungary to deliver training on building trade union power in order to raise wages and conditions to members of VDSZ.
BUILDING TRADE UNION POWER COLLECTIVE BARGAINING CONFERENCE HUNGARY


text:
The retinoids are a class of chemical compounds that are vitamers of vitamin A or are chemically related to it. Retinoids have found use in medicine where they regulate epithelial cell growth.

Retinoids have many important functions throughout the body including roles in vision, regulation of cell proliferation and differentiation, growth of bone tissue, immune function, and activation of tumor suppressor genes.

Research is also being done into their ability to treat skin cancers. Currently, alitretinoin (9-cis-retinoic acid) may be used topically to help treat skin lesions from Kaposi's sarcoma, and tretinoin (all-trans- retinoic acid) is used to treat acute promyelocytic leukemia.

Types
There are four generations of retinoids:
 First generation include retinol, retinal, tretinoin (retinoic acid), isotretinoin, and alitretinoin
 Second generation include etretinate and its metabolite acitretin
 Third generation include adapalene, bexarotene, and tazarotene
 Fourth generation includes Trifarotene

Structure
The basic structure of the hydrophobic retinoid molecule consists of a cyclic end group, a polyene side chain and a polar end group. The conjugated system formed by alternating C=C double bonds in the polyene side chain are responsible for the color of retinoids (typically yellow, orange, or red). Hence, many retinoids are chromophores. Alternation of side chains and end groups creates the various classes of retinoids.

First and second generation retinoids are able to bind with several retinoid receptors due to the flexibility imparted by their alternating single and double bonds.

Third generation retinoids are less flexible than first- and second-generation retinoids and therefore, interact with fewer retinoid receptors.

Fourth generation retinoid, Trifarotene, binds selectively to the RAR-y receptor.  It was approved for use in the US in 2019.

Absorption
The major source of retinoids from the diet are plant pigments such as carotenes and retinyl esters derived from animal sources. Retinyl esters are hydrolyzed in the intestinal lumen to yield free retinol and the corresponding fatty acid (i.e. palmitate or stearate). After hydrolysis, retinol is taken up by the enterocytes.  Retinyl ester hydrolysis requires the presence of bile salts that serve to solubilize the retinyl esters in mixed micelles and to activate the hydrolyzing enzymes

Several enzymes that are present in the intestinal lumen may be involved in the hydrolysis of dietary retinyl esters. Cholesterol esterase is secreted into the intestinal lumen from the pancreas and has been shown, in vitro, to display retinyl ester hydrolase activity. In addition, a retinyl ester hydrolase that is intrinsic to the brush-border membrane of the small intestine has been characterized in the rat as well as in the human.  The different hydrolyzing enzymes are activated by different types of bile salts and have distinct substrate specificities.  For example, whereas the pancreatic esterase is selective for short-chain retinyl esters, the brush-border membrane enzyme preferentially hydrolyzes retinyl esters containing a long-chain fatty acid such as palmitate or stearate.  Retinol enters the absorptive cells of the small intestine, preferentially in the all-trans-retinol form.

Uses
Common skin conditions treated by retinoids include acne and psoriasis. Retinoids are used in the treatment of many diverse diseases and are effective in the treatment of a number of dermatological conditions such as inflammatory skin disorders, skin cancers, such as bexaroten for mycosis fungoides, disorders of increased cell turnover (e.g. psoriasis), photoaging, and skin wrinkles.

Isotretinoin was originally a chemotherapy treatment for certain cancers, such as leukemia.

Toxicity
Toxic effects occur with prolonged high intake. The specific toxicity is related to exposure time and the exposure concentration. A medical sign of chronic poisoning is the presence of painful tender swellings on the long bones. Anorexia, skin lesions, hair loss, hepatosplenomegaly, papilloedema, bleeding, general malaise, pseudotumor cerebri, and death may also occur.

Chronic overdose also causes an increased lability of biological membranes and of the outer layer of the skin to peel.

Recent research has suggested a role for retinoids in cutaneous adverse effects for a variety of drugs including the antimalarial drug proguanil. It is proposed that drugs such as proguanil act to disrupt retinoid homeostasis.

Systemic retinoids (isotretinoin, etretinate) are contraindicated during pregnancy as they may cause CNS, cranio-facial, cardiovascular and other defects.

See also
 Hypervitaminosis A

References

 The Pharmacological Basis of Therapeutics, 10th Edition, Goodman & Gilman.
 Clinical Pharmacology, P.N. Bennett & M.J. Brown.

External links


text:
<?xml version="1.0" encoding="UTF-8"?><!--
  ~ Copyright (c) 2017, WSO2 Inc. (http://www.wso2.org) All Rights Reserved.
  ~
  ~ WSO2 Inc. licenses this file to you under the Apache License,
  ~ Version 2.0 (the "License"); you may not use this file except
  ~ in compliance with the License.
  ~ You may obtain a copy of the License at
  ~
  ~ http://www.apache.org/licenses/LICENSE-2.0
  ~
  ~ Unless required by applicable law or agreed to in writing,
  ~ software distributed under the License is distributed on an
  ~ "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
  ~ KIND, either express or implied.  See the License for the
  ~ specific language governing permissions and limitations
  ~ under the License.
  -->
<!DOCTYPE web-app PUBLIC "-//Sun Microsystems, Inc.//DTD Web Application 2.3//EN"
        "http://java.sun.com/dtd/web-app_2_3.dtd" >
<web-app>
    <filter>
        <filter-name>AuthenticationEndpointFilter</filter-name>
        <filter-class>
            org.wso2.carbon.identity.application.authentication.endpoint.util.filter.AuthenticationEndpointFilter
        </filter-class>
    </filter>
    <filter-mapping>
        <filter-name>AuthenticationEndpointFilter</filter-name>
        <url-pattern>/*</url-pattern>
    </filter-mapping>
    <filter>
        <filter-name>CRLFPreventionFilter</filter-name>
        <filter-class>org.wso2.carbon.ui.filters.CRLFPreventionFilter</filter-class>
    </filter>
    <filter-mapping>
        <filter-name>CRLFPreventionFilter</filter-name>
        <url-pattern>/*</url-pattern>
    </filter-mapping>

    <filter>
        <filter-name>HttpHeaderSecurityFilter</filter-name>
        <filter-class>org.apache.catalina.filters.HttpHeaderSecurityFilter</filter-class>
        <init-param>
            <param-name>hstsEnabled</param-name>
            <param-value>false</param-value>
        </init-param>
    </filter>

    <filter-mapping>
        <filter-name>HttpHeaderSecurityFilter</filter-name>
        <url-pattern>*</url-pattern>
    </filter-mapping>

    <filter>
        <filter-name>ContentTypeBasedCachePreventionFilter</filter-name>
        <filter-class>
            org.wso2.carbon.ui.filters.cache.ContentTypeBasedCachePreventionFilter
        </filter-class>
        <init-param>
            <param-name>patterns</param-name>
            <param-value>"text/html" ,"application/json" ,"plain/text"</param-value>
        </init-param>
        <init-param>
            <param-name>filterAction</param-name>
            <param-value>enforce</param-value>
        </init-param>
        <init-param>
            <param-name>httpHeaders</param-name>
            <param-value>
                Cache-Control: no-store, no-cache, must-revalidate, private
            </param-value>
        </init-param>
    </filter>

    <filter-mapping>
        <filter-name>ContentTypeBasedCachePreventionFilter</filter-name>
        <url-pattern>*</url-pattern>
    </filter-mapping>

    <listener>
        <listener-class>
            org.wso2.carbon.identity.application.authentication.endpoint.util.listener.AuthenticationEndpointContextListener
        </listener-class>
    </listener>
    <error-page>
        <exception-type>java.lang.Throwable</exception-type>
        <location>/generic-exception-response.jsp</location>
    </error-page>
    <session-config>
        <cookie-config>
            <secure>true</secure>
        </cookie-config>
    </session-config>
</web-app>


Babu has spent the last six months researching a new trek, one which required no transportation except for "feet power!" During this trek you will meet people who have had little or no contact with outsiders, especially foreigners. You will walk through pine forests, over a suspension bridge across a lake, have tea at traditional Nepali Kitchens, all the while admiring the magnificent scenery. On day 2 and 3 (weather permitting) you can see from Dhaulagiri to Mount Everest which makes it far cheaper than travelling hundreds of kilometres to Annapurna or Everest!
Day 1 Today we start early from Babu's House. After an easy walk to Thankot there will be a steady climb (taking three hours) to Chandragiri Bhanyang through the jungle. On the top (2265 m) we will stop to have lunch and take tea at a traditional tea house.
After lunch break we will continue down into the valley to the picturesque village of Chitlang where Nepal's first Goat Cheese factory was started. This walk down will take approximately two hours. In Chitlang we will stop and overnight in a family Homestay and have a traditional dinner.
Day 2 - After a traditional breakfast we start an easy walk towards Palung past several Newari brick house villages and agricultural terraces. The walk takes us through beautiful hidden Nepali villages and through some jungle trails. After five to six hours we will reach Palung where we will stay in a family guesthouse.
Day 3 - After breakfast we begin a steep climb through the village and jungle for a fairly gruelling three hour walk towards the viewpoint of Daman where (weather permitting) you can see the mountain range from Dhaulagiri to Mount Everest.
After Daman we continue going up to the highest point of the trek in Simbhanjyang (2488 m) where we will sleep in a family hotel. If weather permits you can see the mountain range from here as well.
Day 4 - From Simbhanjyang we will make our five hours descending way along sandy paths and beautiful pine forests towards Markhu. At the end of this walk we will have spectacular views over the lake that powers most of Kathmandu's electricity.
We will be staying right next to the lake in a family lodge in Markhu and if you are a fish lover we will have fresh fish from the lake, otherwise we will eat traditional Dal Bhat.
Day 5 - After a traditional breakfast with the family we will walk into Markhu village via a fantastic suspension bridge to take the local bus back to Kirtipur. The bus ride will take two to three hours and you will see how Nepali people travel. After lunch in Kirtipur we will walk 45 minutes back to the Homestay.