text:
Glasshouse Meets: Lucy Vincent Marr
Over the last few years, it's felt like there's been no end to the successes of the natural and organic beauty industry. Brands are launching and developing at lightening speed rate and these days 'green beauty' means a whole lot more than a DIY formula made in someone's kitchen. However, for us, there have always been a handful of well-respected individuals who have truly pioneered in the market from the very early days. Lucy Marr just happens to be one of those people.
Lucy is the founder of go-to Glasshouse brand Sans [Ceuticals] - a highly effective range of potent, multi-use products for skin and hair, made using the finest quality botanical ingredients. She started her career as a hair stylist, launching her first salon with her partner in Auckland when she was just 24. Stephen Marr is still one of New Zealand's most well-respected salons, with three sites and two skincare clinics under the brand's belt. These days, Lucy is firmly at the helm of [Sans] Ceuticals - developing formulas that bridge the gap between science and nature.
"Sans [Ceuticals] was born from a frustration of not being able to find pure, natural, results-driven products, that were also thoughtfully designed and sustainable" explains Lucy, "When I was studying to become a hairdresser, I fell in love with trichology - a medical and cosmetic study of the hair and scalp. I also spent a lot of time with a dear friend who is a biotech scientist carrying out exciting research in the field of cancer. The more I learned how ingredients and cells work, the more I desired to create a product that was good for both our bodies and the environment, whilst actually delivering results."
Results are confidently at the center of every Sans product. Each ingredient has been picked for purpose - whether it's sustainable ground bamboo to gently slough away dead skin cells or powerful vitamin E for treating scarring and stretch marks. The word 'Sans' (translating to 'without' in French) also hints at the ingredients not used in Lucy's formulations.
"The skin is our largest organ and absorbs about 70% of what is applied to its surface," she says, "To me, that's more than enough reason to be conscious of what and how much we're applying to our bodies. All our ingredients are pure and sustainable, with no unnecessary harmful additives for our bodies or the environment."
What we love about Lucy's attitude is that her ethics extend to so much more than just the products she wants you to fill your bathroom shelves with. A New Zealand native, she's used to feeling connected to the land and nature in a way that perhaps us Brits aren't so well accustomed to. For instance, her approach to food and drink mirrors her approach to hair and skincare, with "less" certainly meaning "more".
"I avoid anything processed, only because I love cooking, I love gardening and I really prefer food in its natural state" Lucy tells us, "I generally start my day with a green juice of cucumber, green apple, spinach, ginger and lemon and I do love my spice. I also enjoy a good glass of Pinot Noir in the evenings!"
As if running a global beauty business wasn't hectic enough, Lucy's busy home life bringing up her two boys (Billy, 13 and Jonny, 11) has taught her the importance of switching off, zoning out and remembering that work can always wait. "I no longer work in the evenings like I used to which I find really helps to maintain a healthy work/life balance" she says, "For me, finding your own centre of gravity comes from what makes you really happy and grounded - family, cooking and gardening are key."
Part of Sans [Ceuticals] success hasn't just been down to what lies on the inside of the (100% recyclable) packaging, but the brand aesthetic as a whole. Beautiful, ecological and a minimalist's dream; purchasing a piece of Sans is as much a design-led statement as it is a cosmetic one. Their signature neutral palette reminds us of the land and earth Lucy feels so connected to, and the use of biodegradable ingredients and vegetable inks for printing all make for a brand that intertwines style, substance and ethics - which is no mean feat.
It's rare to find someone with such a holistic approach to life that also has a natural skill for the nitty gritty of running a business as well. Keeping the two well balanced is an "ever-changing beast" explains Lucy, particularly when it comes to juggling kids and running a company. "Just when you think you have your systems down, the whole game changes" she says, "Constantly having to remember things, not drop the ball and keep the well-oiled machine that is life moving - while dynamic and interesting, can be really taxing at times."
It's a balancing act many of us are familiar with and Lucy's openness on getting it right (and it easily going pear-shaped) is refreshingly honest. With some exciting developments and expansion for the Sans brand expected in the near future, we've got our eyes peeled for more products at the cutting edge of the natural beauty industry. In the meantime, we're taking a leaf out of Lucy's book and surrendering to life's twists and turns with her healthy can-do mentality and maybe a glass of Pinot Noir…
Words: Lucy Vincent
Images: Holly Sarah Burgess for An Organised Life
A Sans bestseller, this multi-purpose product can be used from head to toe. Try applying to damp skin after showering or rubbing into mid-lengths and ends for softness and shine.
Gentle Exfoliant
Made with fine bamboo granules to gently slough away dead skin cells, this exfoliator is a natural beauty cupboard must-have.
Clay Cleanser
Brand new to the Sans line-up, this probiotic soap cleanser can be used on the face and body for a dose of clay-based nourishment.


Christmas may be over, but eBay's holiday shopping season continues! That red sweater just isn't Aunt Susie's style, and Cousin Tyler already has an iPod. Now it's time to figure out what to do with those well-intended but unsuitable gifts that were exchanged around the Christmas tree.
Help is on the way! Selling an item on eBay provides a great opportunity to give unwanted gifts a new home, and sellers can put that money toward something that didn't get crossed off their Christmas list. eBay expects $815 million in resold gifts this post-holiday season, and whether it's ugly sweaters or duplicate electronics, new owners are waiting to scoop up some post-Christmas loot.
For affiliate partners, the post-holiday season offers a great opportunity to link shoppers to eBay's global online marketplace, while you benefit from the traffic you send this way. There are many ways affiliate partners can use this trend to appeal to your audience. For example, eBay Instant Sale provides the most convenient way for Cousin Tyler to get immediate cash for his unwanted iPod or other electronics, while he can reinvest that money in another hot gadget.
By reminding your audience that they're not stuck with a sleigh full of unwanted gifts and showing them the options they have for reselling unwanted gifts and buying new items that they'll love, you have a timely and relevant opportunity to increase your earnings potential.


text:
Liverpool City Region COVID-19 Updates
... & Important Emergency Notices ...
YOU can get daily major and interesting news updates for the Liverpool City Region on our free email news service, via signing up on:- Formby Reporter. If you have any updates to send in or any views on the posts on here, please email us to:- News24@SouthportReporter.Com.
This page last updated on 2 August 2020
Plan to control COVID-19 outbreak in Princes Park
PUBLIC Health officials in Liverpool have unveiled a plan to deal with an increase in confirmed cases of Coronavirus in the Princes Park area of the City. The 'enhanced outbreak control action plan' is designed to rapidly control the spread of the virus, protect vulnerable communities and the elderly in the area, and prevent the need for the City to have to go into any kind of additional local lockdown measures. Almost half of the increase in confirmed cases across Liverpool over the last week have been in the ward.
Matt Ashton, Director of Public Health for Liverpool, said:- "We have seen a rise in confirmed cases in the Princes Park area and are concerned that it could spiral unless we act to bring the virus back under control. These measures are designed to prevent the need for a more draconian lockdown in the area which would be more difficult for people to endure. It is really important that people follow the advice that we are giving around good hygiene, social distancing, wearing face coverings on public transport, in supermarkets and confined spaces and avoiding visiting other households. This is about us all working together to protect each other, making sure we are not complacent and getting a grip of the virus and keeping it under control. We don't have a vaccine and there is no guarantee that there will be a jab or an effective treatment anytime soon so in the meantime it is up to us all to be responsible and make sure we don't take risks that could unwittingly infect not just ourselves, but vulnerable people including close family and friends."
A pop up Walk In Test Centre is being installed at Princes Park Health Centre, on Bentley Road, since Saturday, 1 August 2020, which people can drop in to from 9am to 4pm if they have symptoms, without the need to book an appointment.
The other measures are:-
► All people who have been shielding are being contacted by text message and a follow up letter and asked to continue to shield until 14 August 2020.
► Cafes, bars and restaurants given additional advice around appropriate public health measures.
► Care home visiting suspended except for those who are at the end of life, and closed for non-essential staff visits (the affected homes have been contacted)
► Community buildings to remain closed.
► Upcoming gatherings and events suspended.
Community volunteers are being deployed to call door to door to raise awareness of testing availability and to promote key public health messages, while work is under way with religious leaders to make sure places of worship are following COVID-19 safe procedures. The impact will be reviewed in 14 days and extended if necessary.
People are being advised to:-
► Follow the advice and guidance around social distancing.
► Wear face coverings in confined spaces, supermarkets and on public transport.
► Maintain social distancing with members of the same family who are from a different household.
► Have no overnight visitors from a different household; even members of the same family.
People with symptoms can also book a test appointment at drive through facilities through the NHS website, or by calling:- 119.
More information about symptoms; which include a:- continuous cough, high temperature and loss of taste and smells is available at:- NHS.UK/Coronavirus.
Mayor of Liverpool, Joe Anderson, said:- "Communities across the area have been absolutely brilliant in working with us to try and make sure we keep the number of cases low. It is really important we don't let the sacrifices and progress of the last few months go to waste and it is right that we are being proactive and acting fast to prevent the further spread of cases. I would like to pay tribute to the community in Princes Park who are working in partnership with us to get the message across of the importance of following social distancing and hygiene advice and getting tested if you have symptoms. The work we are doing now will hopefully pay dividends in terms of preventing the need for further restrictions, which would inevitably cause much more hardship. Liverpool has already suffered 600 deaths from COVID-19 and behind every case is a family who have been left devastated by this cruel illness. We are determined to do what it takes to minimise the risk to our citizens."
Total UK cases COVID-19 cases - update for Liverpool City Region and surroundings
THE North West has had a large number of warnings and added restrictions implemented. Now, due to a "concerning" rise in Coronavirus cases among young people in South Liverpool, that area has had a very localised warning issued to residents. Merseyside Police urged people to stay safe this weekend and remember to follow the guidance. If the case numbers continue to rise, like in other parts of the North West, a retightening of restrictions might have to be implemented. The total number of UK Coronavirus (COVID-19) infections that have been laboratory confirmed, within the UK, has risen by 744 cases and the total number now stand at 304,695, that includes tests carried out by commercial partners which are not included in the 4 National totals. Daily number of COVID-19 associated UK fatalities added to the total, was sadly reported to be 8 according to the Department of Health. The total number of deaths of people who have had a positive test result confirmed by a Public Health or NHS laboratory is 46,201. In England, there are a total of 262,746 confirmed cases. North West - total of 46,503 confirmed cases. The number of laboratory confirmed cases within the following Local Authorities, in and around the Liverpool City Region are as follows:-
► Liverpool, 2,570 confirmed cases.
Warning issued to Princes Park residents.
► Sefton, 1,571 confirmed cases.
► Wirral, 2,070 confirmed cases.
► St. Helens, 1,206 confirmed cases
► Halton, 705 confirmed cases.
► Blackpool, 1,049 confirmed cases.
Urgent warning issued to residents.
► Blackburn with Darwen, 1,418 confirmed cases.
. Under local lockdown warning
► Bolton, 2,002 confirmed cases.
Under local lockdown warning.
► Bury, 1,356 confirmed cases.
► Cheshire West and Chester, 2,047 confirmed cases.
► Cheshire East, 2,254 confirmed cases.
► Lancashire, 7,167 confirmed cases.
► Manchester, 3,325 confirmed cases.
► Oldham, 2,159 confirmed cases.
Under new local lockdown measures!
► Rochdale, 1,882 confirmed cases.
Under local lockdown warning
► Stockport, 1,763 confirmed cases.
► Tameside, 1,638 confirmed cases.
► Trafford, 1,445 confirmed cases.
► Wigan, 2,184 confirmed cases.
Previous 24hr Data
PLEASE ALSO SEE OUR WEEKLY EDITION...
Published weekly, as normal...
Click here to see it!
External links are selected and reviewed when the page is published. However we are not responsible for the content of external websites and links might change. If you find a problem, please report it to us.
Tweets by SouthportReport
Tweets by FormbyReport
This is the current phase of the moon. For more lunar related information, please click on here.
This is just 1 of the events on our event calendar, click on here to see lots more!
This online newspaper and information service is regulated by IMPRESS the independent monitor for the UK's press.
This is our process:-
Complaints Policy - Complaints Procedure - Whistle Blowing Policy
(+44) 0844 324 4 195
Calls will cost 7p per minute, plus your telephone company's access charge. Calls to this number may be recorded for security, broadcast, training and record keeping.
Liverpool Reporter Mersey Reporter Formby Reporter
Our News Room Office Address
Southport and Mersey Reporter, 4a Post Office Ave,
Southport, Merseyside, PR9 0US, UK
Tracking & Cookie Usage Policy - Terms & Conditions
- Southport Reporter® is the Registered Trade Mark of Patrick Trollope.

redpajama_set_name: RedPajamaCommonCrawl


Eric Fouarge is the CTO at Root Level Tech. He was responsible for building and driving the Cloud Enablement cloud practice to scale into a $30mm+ organization focusing on bringing progressive technology and practices into emerging enterprises and startups alike. Eric is responsible for pushing the pace for 200% quarter over quarter growth.


text:
Arabic Phenomena
Cultural Phenomena
Feminist Phenomena
International Phenomena
Palestinian Phenomena
Political Phenomena
Progressive Phenomena
Social Phenomena
The Winds of Freedom and the Ethnic, Religious and Sectarian Diversity
"One Day you finally knew
What you had to do, and began,
Though the voices around you
Kept shouting their bad advice—"
Mary Oliver\ USA
At the time of fragmentation and division, at the time in which the compass and the priorities are almost lost; about seven hundred activists and freedom lovers from forty countries started their journey to break the siege on Gaza Strip despite the ill advice called for not to do that.
At a time of ethnic, religious and sectarian intolerance, The Freedom Flotilla witnessed a distinguished ethnic, religious, sectarian and national diversity that urges us to reconsider the camp of friends from that of enemies.
The participation of one hundred women in The Freedom Flotilla came to prove that women are equal to men in their struggle against oppression, occupation and colonialism, and act as an equal partner in the battle against injustice, tyranny and slavery. This came at a time in which we hear increasing loud voices calling for the necessity for women to go back home, to the shells they freed themselves out of, after long dark ages, using their own will.
The Freedom Flotilla was embracing the monotheistic religions, the different nations and diversity of nationalities on its board, among them: the Turkish martyr Jngs Akure, the American martyr from Turkish descendent Furkan Dogan, Bishop Hilarion Kpucci, Sheikh Raed Salah, the Jewish survivor of the Holocaust Hedy Epstein, Henning Mankell from Sweden, the American coordinator of The Free Gaza Movement Greta Berlin, Shatha Barakat from Syria, Sondos Al-abd Aljader from Kuwait, Dr. Hazem Farouq Mansour from Egypt, engineer Mahmoud Abu Ghaneemeh from Jordan, Hassan Murad from Bahrain, Munasriyya Saliha from Algeria, Fatima Mohammadi from America, the Irish Laureate Mairead Maguire who won Nobel Prize in 1976, the American Kenneth O'Keefe.
In parallel, the Turkish solidarity activists were chanting in broken Arabic accent: 'Palestine … Palestine, the Intifada will continue until the liberation of Palestine'. This came at a time when some fanatical voices in the Arab countries are still repeating outdated slogans, such as: " Khaibar Khaibar … Jews…".
Solidarity activists from thirty-seven nationalities were raising the Palestinian flag and wearing the Palestinian black and white koufiyyeh behind the main slogan: 'Break the siege on Gaza and end the vile Israeli occupation of Palestine'. This came at a time when the Palestinian flag is almost disappearing behind the banners of various factions with the black and white Palestinian scarf (koufiyyeh), which is considered a symbol of the struggle of the Palestinian people, is also nearly fading away behind the scarves of different colors.
In a protest reaction to the massacre of The Freedom Flotilla and the Zionist crime against peaceful international aid activists, and as a condemnation of the Zionist entity and an expression of solidarity and advocacy of the Palestinian cause, 35 members from the group of Friends of Palestine in the Norwegian Parliament participated in the Parliament session wearing the Palestinian koufiyyehs and shawls.
The martyr Rachel Corrie came back to life through the vessel which carried her name to remind the world that she will continue her resistance and will pursue the killers by land, sea and air. The British Alexandra risked her life through her participation in The Freedom Flotilla seeking to break the siege on Gaza. In parallel, Haneen Zoubi challenged her fellow members of the Israeli Knesset who sought to prosecute her following her participation in The Freedom Flotilla. She declared that Israel is the one who should be submitted to trial.
Haneen Zoubi was revealing the racist and chauvinist face of Israel. All this came at a time when we hear some fanatic voices calling for "real men" to act, reproaching Arab rulers for allowing women to take the initiative in their place: "A nation led by Alfarouq, Salah Al-Din, Muhammad the Conqueror and Abdel-Hamid deserves sincere leaders to teach America a lesson about real men who make the decision of war against all occupiers of Muslim lands, and implement it by dignified believers responding to "the call for jihad". This nation deserves men leaders to teach America that the nation is led by men, not women".
When are we going to act, and not to react?
When are we going to take the initiative for breaking of the siege on Gaza, in collaboration with our friends across the globe who took the initiative of the Flotilla?
When are we going to realize our priorities for political unity and the unification of a dissociated homeland?
When are we going to review our slogans so as to focus on what unites us, not what divides us?
How can we accumulate and invest the global and Arab momentum that was launched to support the just cause of Palestine?
How can we intensify our efforts to bring murderers and war criminals to justice?
كلمة السيدة فيحاء عبد الهادي خلال امسية تكريم جمعية عيبال الخيرية للمناضلة عصام عبد الهادي
'I can't breathe': There is no alternative for Justice
The Political Role of Palestinian Women in the 1930s
The Call of Women from Ukraine to Palestine
Sally Majdi Zahran: Will remain in the collective memory of the Arab people
The Mirror of Memory: Pictures and belongings of Palestinians displaced in 1948
What is to be Done? Youth's Visions or Visions?
Razzan al-Najjar and the Dawn of Freedom: She walks with a self-assured step
On the International Day of Happiness: We are not fine


Smart Peak Flow's mission is to help patients stay on top of their asthma by giving an accurate measure of their lung function.
Smart Peak Flow's mission is to help patients stay on top of their asthma by giving an accurate measure of their lung function - a bit like a blood pressure meter does for people with hypertension. For doctors and asthma nurses Smart Peak Flow provides reliable clinical data they can base therapeutic decisions on.


text:
/*
    This library is free software; you can redistribute it and/or
    modify it under the terms of the GNU General Public
    License as published by the Free Software Foundation; either
    version 2 of the license, or (at your option) any later version.
*/

package org.gjt.jclasslib.bytecode;

import org.gjt.jclasslib.structures.InvalidByteCodeException;
import org.gjt.jclasslib.structures.attributes.*;

import java.util.*;

/**
    Contains all information necessary to insert code into a
    method. Allows for pre and post insertions. The core method
    to perform code insertions is the static <tt>apply</tt> method.

    @author Ingo Kegel
    @version $Revision: 1.2 $ $Date: 2006/09/04 15:43:18 $
*/
public class CodeInsertion {

    /**
        Merge two code insertions into one.
        @param position the position of the resulting <tt>CodeInsertion</tt>
        @param shiftTarget should offsets of branch instructions pointing to
                           the position of the resulting code insertion
                           be shifted or point to the beginning of the
                           inserted code.
        @param inner the inner <tt>CodeInsertion</tt>
        @param outer the outer <tt>CodeInsertion</tt>
        @return the resulting <tt>CodeInsertion</tt>
    */
    public static CodeInsertion merge(int position,
                                      boolean shiftTarget,
                                      CodeInsertion inner,
                                      CodeInsertion outer)
    {

        if (outer == null) {
            return inner;
        }
        if (inner == null) {
            return outer;
        }

        AbstractInstruction[] preInstructions = mergeInstructions(outer.preInstructions, inner.preInstructions);
        AbstractInstruction[] postInstructions = mergeInstructions(inner.postInstructions, outer.postInstructions);

        CodeInsertion codeInsertion =
            new CodeInsertion(position,
                              preInstructions,
                              postInstructions,
                              shiftTarget);

        return codeInsertion;
    }

    /**
        Merge two arrays of instructions into one.
        @param firstInstructions the head array of type <tt>AbstractInstruction</tt>
        @param lastInstructions the tail array of type <tt>AbstractInstruction</tt>
        @return the merged array of type <tt>AbstractInstruction[]</tt>
    */
    public static AbstractInstruction[] mergeInstructions(AbstractInstruction[] firstInstructions,
                                                          AbstractInstruction[] lastInstructions)
    {
        if (firstInstructions== null) {
            return lastInstructions;
        }
        if (lastInstructions == null) {
            return firstInstructions;
        }

        AbstractInstruction[] mergedInstructions = new AbstractInstruction[firstInstructions.length + lastInstructions.length];
        System.arraycopy(firstInstructions, 0, mergedInstructions, 0, firstInstructions.length);
        System.arraycopy(lastInstructions, 0, mergedInstructions, firstInstructions.length, lastInstructions.length);

        return mergedInstructions;
    }

    /**
        Apply a list of <tt>CodeInsertion</tt>s to a list of instructions
        such as the one supplied by a <tt>ByteCodeReader</tt>. Offsets
        of branch instructions will be adapted to point to the original
        instructions. Exception and line number tables in the associated
        <tt>CodeAttribute</tt>will also be updated.

        @param instructions the list of instructions which is to be treated
                            with the <tt>CodeInsertion</tt>s. This list
                            and the resulting instructions will not be usable
                            after the method is finished. If you need to
                            reuse the original instructions, you have to pass
                            a deep-cloned list into this method.
        @param codeInsertions the list of codeInsertions which is to be applied to
                              the list of instructions.
        @param codeAttribute the <tt>CodeAttribute</tt> pertaining to the supplied
                             list of instructions.
        @return the resulting list of instructions
        @throws InvalidByteCodeException
     */
    public static List apply(List instructions,
                             List codeInsertions,
                             CodeAttribute codeAttribute)

        throws InvalidByteCodeException
    {
        int instructionCount = instructions.size();
        int[] transformedIndices = new int[instructionCount];
        for (int i = 0; i < instructionCount; i++) {
            transformedIndices[i] = i;
        }

        List newInstructions = insertCode(instructions,
                                          codeInsertions,
                                          transformedIndices);

        int[] oldOffsets = new int[instructionCount];
        for (int i = 0; i < instructionCount; i++) {
            oldOffsets[i] = ((AbstractInstruction)instructions.get(i)).getOffset();
        }
        int[] newOffsets = new int[newInstructions.size()];
        calculateOffsets(newInstructions, newOffsets);

        adjustOffsets(instructions,
                      newInstructions,
                      oldOffsets,
                      newOffsets,
                      transformedIndices);

        if (codeAttribute != null) {
            adjustExceptionTable(oldOffsets,
                                 newOffsets,
                                 transformedIndices,
                                 codeAttribute);

            adjustLineNumberTable(oldOffsets,
                                  newOffsets,
                                  transformedIndices,
                                  codeAttribute);
        }

        applyOffsets(newInstructions, newOffsets);
        return newInstructions;
    }

    private static List insertCode(List instructions,
                                   List codeInsertions,
                                   int[] transformedIndices)
    {
        int instructionCount = instructions.size();
        int insertionCount = codeInsertions.size();

        int newSize = calculateNewSize(instructions, codeInsertions);
        List<Object> newInstructions = new ArrayList<Object>(newSize);

        int currentInsertionIndex = 0;
        CodeInsertion currentInsertion = (CodeInsertion)codeInsertions.get(0);
        for (int i = 0; i < instructionCount; i++) {
            if (currentInsertion.getPosition() < i && currentInsertionIndex < insertionCount - 1) {
                ++currentInsertionIndex;
                currentInsertion = (CodeInsertion)codeInsertions.get(currentInsertionIndex);
            }
            int addedBefore = 0;
            int addedAfter = 0;
            if (currentInsertion.getPosition() == i) {
                addedBefore = addInstructions(newInstructions, currentInsertion.getPreInstructions());
            }
            newInstructions.add(instructions.get(i));
            if (currentInsertion.getPosition() == i) {
                addedAfter = addInstructions(newInstructions, currentInsertion.getPostInstructions());
            }
            if (addedBefore > 0 || addedAfter > 0) {
                shiftIndices(i, addedBefore, addedAfter, transformedIndices, currentInsertion.isShiftTarget());
            }
        }

        return newInstructions;
    }

    private static int calculateNewSize(List instructions, List codeInsertions) {

        int insertionCount = codeInsertions.size();
        int newSize = instructions.size();
        for (int i = 0; i < insertionCount; i++) {
            CodeInsertion insertion = (CodeInsertion)codeInsertions.get(i);

            AbstractInstruction[] preInstructions = insertion.getPreInstructions();
            if (preInstructions != null) {
                newSize += preInstructions.length;
            }
            AbstractInstruction[] postInstructions = insertion.getPostInstructions();
            if (postInstructions != null) {
                newSize += postInstructions.length;
            }
        }
        return newSize;
    }

    private static void shiftIndices(int currentIndex,
                                     int addedBefore,
                                     int addedAfter,
                                     int[] transformedIndices,
                                     boolean shiftTarget)
    {
        if (!shiftTarget) {
            transformedIndices[currentIndex] += addedBefore;
        }
        for (int i = currentIndex + 1; i < transformedIndices.length; i++) {
            transformedIndices[i] += addedBefore + addedAfter;
        }
    }

    private static int addInstructions(List<Object> newInstructions,
                                       AbstractInstruction[] insertedInstructions)
    {
        if (insertedInstructions != null) {
            for (int i = 0; i < insertedInstructions.length; i++) {
                newInstructions.add(insertedInstructions[i]);
            }
            return insertedInstructions.length;
        } else {
            return 0;
        }
    }

    private static void calculateOffsets(List instructions,
                                         int[] offsets)
    {
        int instructionCount = instructions.size();
        int currentOffset = 0;
        for (int i = 0; i < instructionCount; i++) {
            offsets[i] = currentOffset;

            AbstractInstruction instr = (AbstractInstruction)instructions.get(i);

            int currentSize;
            if (instr instanceof PaddedInstruction) {
                currentSize = ((PaddedInstruction)instr).getPaddedSize(currentOffset);
            } else {
                currentSize = instr.getSize();
            }
            currentOffset += currentSize;
        }
    }

    private static void applyOffsets(List instructions, int[] offsets) {
        int instructionCount = instructions.size();
        for (int i = 0; i < instructionCount; i++) {
            AbstractInstruction instr = (AbstractInstruction)instructions.get(i);
            instr.setOffset(offsets[i]);
        }
    }

    private static void adjustOffsets(List instructions,
                                      List newInstructions,
                                      int[] oldOffsets,
                                      int[] newOffsets,
                                      int[] transformedIndices)
        throws InvalidByteCodeException
    {
        int instructionCount = instructions.size();
        for (int sourceIndex = 0; sourceIndex < instructionCount; sourceIndex++) {
            AbstractInstruction currentInstruction = (AbstractInstruction)instructions.get(sourceIndex);
            int branchOffset = getBranchOffset(currentInstruction);
            if (branchOffset == 0) {
                continue;
            }
            if (currentInstruction instanceof TableSwitchInstruction) {
                int[] jumpOffsets = ((TableSwitchInstruction)currentInstruction).getJumpOffsets();
                for (int i = 0; i < jumpOffsets.length; i++) {
                    int targetIndex = getBranchTargetIndex(instructions, sourceIndex, jumpOffsets[i]);
                    jumpOffsets[i] =
                        calculateNewBranchOffset(newInstructions, sourceIndex, targetIndex, transformedIndices, newOffsets);
                }
            } else if (currentInstruction instanceof LookupSwitchInstruction) {
                List matchOffsetPairs = ((LookupSwitchInstruction)currentInstruction).getMatchOffsetPairs();
                for (int i = 0; i < matchOffsetPairs.size(); i++) {
                    MatchOffsetPair matchOffsetPair =
                        (MatchOffsetPair)matchOffsetPairs.get(i);
                    int targetIndex = getBranchTargetIndex(instructions, sourceIndex, matchOffsetPair.getOffset());
                    matchOffsetPair.setOffset(
                        calculateNewBranchOffset(newInstructions, sourceIndex, targetIndex, transformedIndices, newOffsets)
                    );
                }
            }
            int targetIndex = getBranchTargetIndex(instructions, sourceIndex, branchOffset);

            setBranchOffset(
                currentInstruction,
                calculateNewBranchOffset(newInstructions, sourceIndex, targetIndex, transformedIndices, newOffsets)
            );

        }
    }

    private static int calculateNewBranchOffset(List newInstructions,
                                                int sourceIndex,
                                                int targetIndex,
                                                int[] transformedIndices,
                                                int[] newOffsets)
{
            int transformedSourceIndex = transformedIndices[sourceIndex];
            int transformedTargetIndex = transformedIndices[targetIndex];

            int newBranchOffset = newOffsets[transformedTargetIndex] - newOffsets[transformedSourceIndex];

            return newBranchOffset;
    }

    private static int getBranchOffset(AbstractInstruction instruction) {

        int branchOffset = 0;
        if (instruction.getOpcode() == Opcodes.OPCODE_GOTO_W) {
            branchOffset = ((ImmediateIntInstruction)instruction).getImmediateInt();
        } else if (instruction instanceof TableSwitchInstruction) {
            branchOffset = ((TableSwitchInstruction)instruction).getDefaultOffset();
        } else if (instruction instanceof LookupSwitchInstruction) {
            branchOffset = ((LookupSwitchInstruction)instruction).getDefaultOffset();
        } else if (instruction instanceof BranchInstruction) {
            branchOffset = ((BranchInstruction)instruction).getBranchOffset();
        }
        return branchOffset;
    }

    private static void setBranchOffset(AbstractInstruction instruction,
                                        int branchOffset)
    {
        if (instruction.getOpcode() == Opcodes.OPCODE_GOTO_W) {
            ((ImmediateIntInstruction)instruction).setImmediateInt(branchOffset);
        } else if (instruction instanceof TableSwitchInstruction) {
            ((TableSwitchInstruction)instruction).setDefaultOffset(branchOffset);
        } else if (instruction instanceof LookupSwitchInstruction) {
            ((LookupSwitchInstruction)instruction).setDefaultOffset(branchOffset);
        } else if (instruction instanceof BranchInstruction) {
            ((BranchInstruction)instruction).setBranchOffset(branchOffset);
        }
    }

    private static int getBranchTargetIndex(List instructions,
                                            int sourceIndex,
                                            int branchOffset)
        throws InvalidByteCodeException
    {
        int instructionsCount = instructions.size();
        int startOffset = ((AbstractInstruction)instructions.get(sourceIndex)).getOffset();
        int step = branchOffset > 0 ? 1 : -1;
        for (int i = sourceIndex + step; i >= 0 && i < instructionsCount; i += step) {
            int targetOffset = ((AbstractInstruction)instructions.get(i)).getOffset();
            if (targetOffset - startOffset == branchOffset) {
                return i;
            }
        }
        throw new InvalidByteCodeException("Invalid branch target");
    }

    private static void adjustExceptionTable(int[] oldOffsets,
                                             int[] newOffsets,
                                             int[] transformedIndices,
                                             CodeAttribute codeAttribute)
        throws InvalidByteCodeException
    {

        ExceptionTableEntry[] exceptionTable = codeAttribute.getExceptionTable();
        if (exceptionTable == null) {
            return;
        }

        for (int i = 0; i < exceptionTable.length; i++) {
            ExceptionTableEntry currentEntry = exceptionTable[i];
            int startPcIndex = Arrays.binarySearch(oldOffsets, currentEntry.getStartPc());
            int endPcIndex = Arrays.binarySearch(oldOffsets, currentEntry.getEndPc());
            int handlerPcIndex = Arrays.binarySearch(oldOffsets, currentEntry.getHandlerPc());
            if (startPcIndex < 0 || endPcIndex < 0 || handlerPcIndex < 0 ||
                startPcIndex == oldOffsets.length ||
                endPcIndex == oldOffsets.length ||
                handlerPcIndex == oldOffsets.length)
            {
                throw new InvalidByteCodeException("Invalid exception table");
            }
            currentEntry.setStartPc(newOffsets[transformedIndices[startPcIndex]]);
            currentEntry.setEndPc(newOffsets[transformedIndices[endPcIndex]]);
            currentEntry.setHandlerPc(newOffsets[transformedIndices[handlerPcIndex]]);
        }

   }

    private static void adjustLineNumberTable(int[] oldOffsets,
                                              int[] newOffsets,
                                              int[] transformedIndices,
                                              CodeAttribute codeAttribute)
        throws InvalidByteCodeException
    {

        LineNumberTableAttribute lineNumberTableAttribute =
            (LineNumberTableAttribute)codeAttribute.findAttribute(LineNumberTableAttribute.class);
        if (lineNumberTableAttribute == null) {
            return;
        }
        LineNumberTableEntry[] lineNumberTable = lineNumberTableAttribute.getLineNumberTable();

        for (int i = 0; i < lineNumberTable.length; i++) {
            LineNumberTableEntry currentEntry = lineNumberTable[i];
            int startPcIndex = Arrays.binarySearch(oldOffsets, currentEntry.getStartPc());
            if (startPcIndex < 0 || startPcIndex == oldOffsets.length) {
                throw new InvalidByteCodeException("Invalid line number table " + currentEntry.getStartPc());
            }
            currentEntry.setStartPc(newOffsets[transformedIndices[startPcIndex]]);
        }

   }

    private int position;
    private AbstractInstruction[] preInstructions;
    private AbstractInstruction[] postInstructions;
    private boolean shiftTarget;

    /**
        Create a code insertion.
        @param position the instruction number to which this <tt>CodeInsertion</tt>
                        is to be applied. Corresponds to the index in the list
                        of instructions such as the one returned by a
                        <tt>ByteCodeReader</tt>.
        @param preInstructions the instructions to be inserted before
                               the insertion point.
        @param postInstructions the instructions to be inserted after
                                the insertion point.
        @param shiftTarget should offsets of branch instructions pointing to
                           the position of this code insertion
                           be shifted or point to the beginning of the
                           code inserted via the <tt>preInstructions</tt>
                           parameters.
     */
    public CodeInsertion(int position,
                         AbstractInstruction[] preInstructions,
                         AbstractInstruction[] postInstructions,
                         boolean shiftTarget)
    {
        this.position = position;
        this.preInstructions = preInstructions;
        this.postInstructions  = postInstructions;
        this.shiftTarget = shiftTarget;
    }

    /**
        Get the insertion position, i.e the instruction number to which
        this <tt>CodeInsertion</tt> is to be applied. Corresponds to the
        index in the list of instructions such as the one returned by a
        <tt>ByteCodeReader</tt>.
        @return the insertion position
     */
    public int getPosition() {
        return position;
    }

    /**
        Set the insertion position, i.e the instruction number to which
        this <tt>CodeInsertion</tt> is to be applied. Corresponds to the
        index in the list of instructions such as the one returned by a
        <tt>ByteCodeReader</tt>.
        @param position the insertion position
     */
    public void setPosition(int position) {
        this.position = position;
    }

    /**
        Get the instructions to be inserted before the insertion point.
        @return array of instructions
     */
    public AbstractInstruction[] getPreInstructions() {
        return preInstructions;
    }

    /**
        Set the instructions to be inserted before the insertion point.
        @param preInstructions array of instructions
     */
    public void setPreInstructions(AbstractInstruction[] preInstructions) {
        this.preInstructions = preInstructions;
    }

    /**
        Get the instructions to be inserted after the insertion point.
        @return array of instructions
     */
    public AbstractInstruction[] getPostInstructions() {
        return postInstructions;
    }

    /**
        Set the instructions to be inserted after the insertion point.
        @param postInstructions array of instructions
     */
    public void setPostInstructions(AbstractInstruction[] postInstructions) {
        this.postInstructions = postInstructions;
    }

    /**
        Get whether offsets of branch instructions pointing to the position of
        the resulting code insertion should be shifted to the first pre-instruction
        or continue to point at the original instruction.
        @return the boolean value
     */
    public boolean isShiftTarget() {
        return shiftTarget;
    }

    /**
        Set whether offsets of branch instructions pointing to the position of
        the resulting code insertion should be shifted to the first pre-instruction
        or continue to point at the original instruction.
        @param shiftTarget the boolean value.
     */
    public void setShiftTarget(boolean shiftTarget) {
        this.shiftTarget = shiftTarget;
    }
}

redpajama_set_name: RedPajamaGithub