The unadjusted trial balance of Epicenter Laundry at June 30, 2019, the end of the fiscal year, follows:

Epicenter Laundry

UNADJUSTED TRIAL BALANCE

June 30, 2019

The data needed to determine year-end adjustments are as follows:

Required:

Read the article below and write a brief (1-2 paragraph) summary. This assignment should be approximately 250 words . Complete this assignment as a Word document.

Time to Scrap Performance Appraisals

Times have changed. More and more companies have decided to radically change (read “scrap” or “re-engineer”) their performance appraisal process.

Last week at our research conference we spoke with Adobe, Juniper, Kelly Services, and a variety of other companies who have decided to do away with traditional performance ratings and dramatically change the annual appraisal process.

Our research shows that this is a strong and positive trend.

Why the process must change.

Why do companies have annual reviews in the first place? They are an artifact from traditional top-down organizations where we had to “weed out” the bottom performers every year. By forcing managers to rate people once per year we can have annual talent reviews and decide who gets more money, who to promote, and who to let go.

Coupled with the performance rating is the “potential” rating, which tries to capture an individual’s potential to move up two levels in the organization (the traditional definition).

This approach is based on a philosophy that “ we cant totally trust managers” so we’re going to force them to fit people into these rating scales. And in many companies (around 20%) there are forced distributions, which mandate that some percent of employees are rated at the bottom and only a limited percent can be rated at the top.

The well publicized problems with this process abound. These include:

Employees need and want regular feedback (daily, weekly), so a once-a-year review is not only too late but it’s often a surprise. Regular coaching is the key to alignment and performance.

Managers cannot typically “judge” an entire year of work from an individual at one time (imagine if your spouse gave you an annual review!), so the annual review is awkward and uncomfortable for both manager and employee.

Manager-employee relationships are not 1:1 like they used to be. We work with many leaders and peers during the year, so one person cannot adequately rate you without lots of peer input.

While some employees are a poor fit and likely are poor performers, these issues should be addressed immediately, not at the end of the year.

Some companies really do have a lot of high performers, so forced ranking eliminates great people and damages the culture.

People are inspired and motivated by positive, constructive feedback – and the “appraisal” process almost always works against this.

The most valuable part of an appraisal is the “development planning” conversation – what can one do to improve performance and engagement – and this is often left to a small box on the review form.

Companies are nervous about eliminating this process because:

We need a fair and validated way to distribute compensation increases (don’t we?)

We need a record of low performance when we let someone go

We need to capture performance data in an employee’s profile for future promotion and other talent reviews, development plans, and career migration

We need a way to make sure managers are doing their jobs well.

Well, I’ve probably discussed these issues with 100+ companies over the last five years and our research shows more and more that companies are ready to let this process go.

Organization structures have changed and companies need to be more agile. We have a shortage of key talent and the keys to success now focus on regular alignment, coaching, creating passion and engagement, and continuous employee development.

The new keys to success:

Develop a “feedback-rich” culture and set of tools (often online, sometimes formal, often informal) that encourages all employees to give each other feedback. Tools from companies like Achievers, Globoforce, and most HR software vendors now enable and make this easy.

Separate the discussions about performance from discussions about potential and future career plans. Yes we need to evaluate people when raise time comes, but that can be a totally different conversation from.

Talk about performance regularly and let employees create their own goals on a regular basis. Force managers to provide ongoing feedback and teach them how to have honest conversations.

Assume that employees already know something about their own performance, and force them to self-assess. People tend to have a good idea of their own strengths and weaknesses – give them an open and positive opportunity to share it. That starts the dialogue about expectations and the match between their self-assessment and that of the organization.

Enable managers to assess performance regularly. Software teams now use Agile tools which evaluate code on a weekly basis. Managers should be giving people feedback regularly. If they learn to do this on a regular basis it will get easier and employees will learn to appreciate it.

Focus managers on hiring the best, so they build a team which strives for 100% high performers. This is never possible of course, but rather than assuming that 20% of your employees will perform poorly, spend more time on assessment, culture, and fit to make sure very few low performers make it into the organization in the first place.

Remember that everyone wants to succeed. If they aren’t performing well it’s not necessarily their fault – the organization should take responsibility for helping them find a better fit if possible.

Set and reset goals frequently. Companies that set performance goals quarterly generate 31% greater returns from their performance process than those who do it annually, and those who do it monthly get even better results. This means employees get feedback on a continuous basis (most sales organizations work this way). Read our research for more details.

Beware of pay for performance plans. While many companies (particularly investment banking, sales) have large pay for performance plans, research showsthat these can create perverse behavior. People focus on their own goals at the expense of the organization. In sales related roles this process works well – when you move to customer service, engineering, and other “builder” roles they can create problems.

Give your leaders a cultural framework and set of values to work from. Companies like Juniper and Deckers (Uggs shoes) focus very heavily on corporate values, forcing managers to hire and manage to these values. This makes selection easier and enables us to evaluate and coach people against higher level frameworks.

Invest in leadership development. Being a manager is a tough job. Managers at all levels struggle with selection, hiring, training, coaching, and evaluation. Give them time and tools to learn, a framework for feedback, and a continuous development process so they learn how to become better.

Reward talent “production” not talent “hoarding.” If you pay your managers to “produce output,” they will focus heavily on talent performance and evaluation. This may be a good thing, but ultimately companies thrive by building skills – so in addition to encouraging managers to produce good work, incent them to produce good talent as well.

I’ve had the opportunity to study HR and performance management for almost 15 years now, and this topic has been controversial for a long time. In today’s globalized,talent constrained workplace it’s clear to me that the traditional appraisal has to change.

Businesses thrive on agility, speed, passion, and alignment. The process of driving and measuring performance has to do the same.

Complete the following questions. In addition to answering the items below, you must submit an analysis of the assignment. Analyze the specific outcomes and write an analysis directed toward the management team at Smart Company describing what the numbers mean and how they relate to the business. Submit journal entries in an Excel file and written segments in an MS Word document. For written answers, please make sure your responses are well-written, formatted per CSU-Global Guide to Writing and APA and have proper citations, where applicable.

Smart Company is preparing its financial statements for the year ended June 30, 2017. The financial statements are complete except for the statement of cash flows. You have been asked to prepare a statement of cash flows for the year ended June 30, 2017.

Download the excel spreadsheet found in the link below.

Required:

Prepare a spreadsheet to support a statement of cash flows for the year ended June 30, 2017.

In the tab named ‘Journal Entries’, show in journal entry form, the entries that would be made in preparation of the statement of cash flows.

Prepare Smart Company’s statement of cash flows for the year ended June 30, 2017. Prepare the statement of cash flows using the indirect method. Note: For full credit, you must prepare the statement of cash flow in good form with all necessary disclosures, including disclosures about noncash financing and investing activities.

In your perspective, what would be the best ethical theory to analyze the case study "my family's honor? Please elaborate on why you think this way

My family’s Honor

My name is Charles, but my friends and family call me Chuck. I am the fifth child in a family of 7, three older sisters and an older brother before me, and a sister one a year younger and a brother 5 years younger than her. Due to the age difference between my sister and my little brother, jokes were told in family gatherings referring to my little brother as an “accident” or as “Ramses” making reference to a popular name brand of condoms implying that my mother had gotten pregnant because the Ramses Condoms were somehow damaged. At that time in my life, roughly 15 years old, I did not find these jokes or comments funny at all. Nevertheless, we had grown to know my little brother as Ramses for lack of a better nickname and he hated it even though I do not think he understood what it meant.

One warm summer afternoon, my little brother came home very angry. For days to follow, he did not want to talk about what was making him upset and seemed absent and sad. As the week came to an end, he was still obviously upset to the point that he refused to go to a football game that we had been planning to go for weeks. I did not understand what the problem was, but what I was about to find out, would make me reevaluate the meaning of the word “honor.”

A few weeks before this incident, a young Down Syndrome boy had been accepted into my brother school, fact that I was not aware of. Moved by a government “full integration” policy, schools were admitting what in those days were known as “non-traditional students”, a group that was composed by Down Syndrome, Autistic and other learning disabled children that up until that time had been going to special education centers out of the public eye. Thinking in retrospect, I personally had never been close or even seen a Down Syndrome child. The closest thing I remember was a boy who lived across the street who used to spy on us as we played in the street but never came out. Later on in life I found out that his name was Bobby and he had been the victim of a nasty disease known as Polio and thus confined to a wheel chair. Bobby was “home schooled” not because he had a learning disability, but probably because his parents tried to protect him from bullies and deep down inside they were possibly a bit ashamed of him.

After a while, my little brother (whose real name was David), decided to open up to me and told me the reasons why he had been upset in the past days. With tears in his eyes, David proceeded to narrate what he had been subjected to by kids in the school. He looked and me and said: Last Monday I went to school and some of the older kids were pointing at me and laughing. Before I knew it from the crowd I heard a voice yelling “Ramses, Ramses you mother can’t keep on her pantses.” In a macabre and cruel way of making fun of David by making up words to make a silly rhyme, they were implying that my mother was a whore who could not keep her pants on and thus, got pregnant with David. Never mind that my mother was married to my father and consequently she could not be labeled as a whore, I was enraged that this kids would have my mother in their stupid mouths. I was so upset about this that I told David that next time he saw the kid or kids who did this to him to point them out to me that I would make them pay. Keep in mind that David was around 8 years old at that time, so to him it was a huge deal to be reassured by his big brother that he was going to be protected.

Weeks went by without any incidents and then one afternoon as David and I were walking through the playground by our house, he saw the culprit of his ridicule. He seemed excited and nervous when he pointed out his “offender” in the distance. From that perspective the kid seemed big, even bigger than me at 15. Without thinking about it I ran towards him convinced that if I surprised him and hit first, I would have the advantage. Since the kid was walking away from him, I grabbed him by the collar of his shirt and swung him around. A right hook to his belly made him lose his air, a punch in the mouth and then another….. by this time all of the kids in the playground were surrounding me chanting “fight, fight, fight…” All I could think of was my mother’s honor….. never again would anyone dare calling my mother a whore…. I was blinded by rage as I continued to punch and kick. It was not long before someone grabbed me and pinned me down…. In my rage I heard a woman crying in desperation…… as I reclaimed by composure, I began to see what I had done.

On the ground, bleeding with what seemed a broken nose, and crying covering his face was this big kid…. The woman who had been crying, his mother, was trying to console him and as she helped him out my rage turned to horror as I realized the kid I had badly hurt was the Down Syndrome boy that had come to my brother’s school a few weeks ago. I learned his name was Christian and in an act of cruelty bigger than anything I had ever seen, had been bullied by the bigger kids into making fun of my brother. I had inflicted a lot of damage on this boy who had no understanding of what he was saying and I did not know what to say. In an attack of remorse, I too started to cry asking him to forgive him… I could not look at him or his mother, I had never in my short life felt so much remorse.

In an effort to regain my mother’s honor, I had attacked the wrong person, I had acted without thinking, I had committed an act of violence against someone who could not properly defend himself. What a shameful and coward act.

Time passed and we all got older. Christian was taken out of the school and we never heard anything from him. I got married and had children… 3 girls and a boy. Life sometimes likes to play cruel jokes on us and my boy was born with Down Syndrome. In a reconciliatory move, I named him Christian…. Not because I felt guilty anymore, but because I wanted to protect this little Christian and make sure that no bully ever took advantage of him. Today Christian is 10 years old. He is a mild case of Down Syndrome and the doctors seem to think that he will live a long and productive life. I cannot help however, to see the stares or the little boys pointing at him when we go to the playground. Today my honor is in making sure that my son will never be abused by anyone. Funny I should say this, but sometimes when I hold my Christian in my arms I still shed a tear of remorse for what I did to that poor boy many years ago.

My name is Charles, but my friends and family call me Chuck. I am the fifth child in a family of 7, three older sisters and an older brother before me, and a sister one a year younger and a brother 5 years younger than her. Due to the age difference between my sister and my little brother, jokes were told in family gatherings referring to my little brother as an “accident” or as “Ramses” making reference to a popular name brand of condoms implying that my mother had gotten pregnant because the Ramses Condoms were somehow damaged. At that time in my life, roughly 15 years old, I did not find these jokes or comments funny at all. Nevertheless, we had grown to know my little brother as Ramses for lack of a better nickname and he hated it even though I do not think he understood what it meant.

One warm summer afternoon, my little brother came home very angry. For days to follow, he did not want to talk about what was making him upset and seemed absent and sad. As the week came to an end, he was still obviously upset to the point that he refused to go to a football game that we had been planning to go for weeks. I did not understand what the problem was, but what I was about to find out, would make me reevaluate the meaning of the word “honor.”

A few weeks before this incident, a young Down Syndrome boy had been accepted into my brother school, fact that I was not aware of. Moved by a government “full integration” policy, schools were admitting what in those days were known as “non-traditional students”, a group that was composed by Down Syndrome, Autistic and other learning disabled children that up until that time had been going to special education centers out of the public eye. Thinking in retrospect, I personally had never been close or even seen a Down Syndrome child. The closest thing I remember was a boy who lived across the street who used to spy on us as we played in the street but never came out. Later on in life I found out that his name was Bobby and he had been the victim of a nasty disease known as Polio and thus confined to a wheel chair. Bobby was “home schooled” not because he had a learning disability, but probably because his parents tried to protect him from bullies and deep down inside they were possibly a bit ashamed of him.

After a while, my little brother (whose real name was David), decided to open up to me and told me the reasons why he had been upset in the past days. With tears in his eyes, David proceeded to narrate what he had been subjected to by kids in the school. He looked and me and said: Last Monday I went to school and some of the older kids were pointing at me and laughing. Before I knew it from the crowd I heard a voice yelling “Ramses, Ramses you mother can’t keep on her pantses.” In a macabre and cruel way of making fun of David by making up words to make a silly rhyme, they were implying that my mother was a whore who could not keep her pants on and thus, got pregnant with David. Never mind that my mother was married to my father and consequently she could not be labeled as a whore, I was enraged that this kids would have my mother in their stupid mouths. I was so upset about this that I told David that next time he saw the kid or kids who did this to him to point them out to me that I would make them pay. Keep in mind that David was around 8 years old at that time, so to him it was a huge deal to be reassured by his big brother that he was going to be protected.

Weeks went by without any incidents and then one afternoon as David and I were walking through the playground by our house, he saw the culprit of his ridicule. He seemed excited and nervous when he pointed out his “offender” in the distance. From that perspective the kid seemed big, even bigger than me at 15. Without thinking about it I ran towards him convinced that if I surprised him and hit first, I would have the advantage. Since the kid was walking away from him, I grabbed him by the collar of his shirt and swung him around. A right hook to his belly made him lose his air, a punch in the mouth and then another….. by this time all of the kids in the playground were surrounding me chanting “fight, fight, fight…” All I could think of was my mother’s honor….. never again would anyone dare calling my mother a whore…. I was blinded by rage as I continued to punch and kick. It was not long before someone grabbed me and pinned me down…. In my rage I heard a woman crying in desperation…… as I reclaimed by composure, I began to see what I had done.

On the ground, bleeding with what seemed a broken nose, and crying covering his face was this big kid…. The woman who had been crying, his mother, was trying to console him and as she helped him out my rage turned to horror as I realized the kid I had badly hurt was the Down Syndrome boy that had come to my brother’s school a few weeks ago. I learned his name was Christian and in an act of cruelty bigger than anything I had ever seen, had been bullied by the bigger kids into making fun of my brother. I had inflicted a lot of damage on this boy who had no understanding of what he was saying and I did not know what to say. In an attack of remorse, I too started to cry asking him to forgive him… I could not look at him or his mother, I had never in my short life felt so much remorse.

In an effort to regain my mother’s honor, I had attacked the wrong person, I had acted without thinking, I had committed an act of violence against someone who could not properly defend himself. What a shameful and coward act.

Time passed and we all got older. Christian was taken out of the school and we never heard anything from him. I got married and had children… 3 girls and a boy. Life sometimes likes to play cruel jokes on us and my boy was born with Down Syndrome. In a reconciliatory move, I named him Christian…. Not because I felt guilty anymore, but because I wanted to protect this little Christian and make sure that no bully ever took advantage of him. Today Christian is 10 years old. He is a mild case of Down Syndrome and the doctors seem to think that he will live a long and productive life. I cannot help however, to see the stares or the little boys pointing at him when we go to the playground. Today my honor is in making sure that my son will never be abused by anyone. Funny I should say this, but sometimes when I hold my Christian in my arms I still shed a tear of remorse for what I did to that poor boy many years ago.

Based on this story,

int terms of honor,,, in your perspective, what is the most important lesson to be learned from this short story?

Master Budget Case: Wooden Pull Toys Inc. Wooden Pull Toys Ltd. is a company that manufactures and sells a single product, which they call a Baby Turtle. For planning and control purposes they utilize a quarterly master budget, which is usually developed at least six months in advance of the budget period. Their fiscal year end is December 31. During the summer of 2019, Jimmy C., the Wooden Pull Toys controller, spent considerable time with Fanny L., the Manager of Marketing, putting together a sales forecast for the first quarter of next year (January to March, 2020). Unfortunately, their collaboration worked so well they eloped to Niagara, ON, were married and settled down. Prior to their departure they e-mailed letters of resignation and a cryptic sales forecast to the President of Wooden Pull Toys. Their sales forecast consisted of these few lines: • For the year ended December 31, 2019: 475,000 units at $11.00 each* • For the year ended December 31, 2020: 500,000 units at $11.00 each • For the year ended December 31, 2021: 500,000 units at $11.00 each *Expected sales for the year ended December 31, 2019 are based on actual sales to date and budgeted sales for the duration of the year. Wooden Pull Toys’ President felt certain that the marriage wouldn’t last, and expected Chris would be back any day. But the end of the year is quickly approaching, and there is still no word from the desert. The President, desperately needing the budget completed, has approached you, a management accounting student, for help in preparing the budget for the first quarter. Your conversations with the President and your investigations of the company’s records have revealed the following information: 1. Sales of Baby Turtles are seasonal. History shows that January, March, May and June are the slowest months with only 5% of sales for each month. Sales pick up over the summer with July, August and September each contributing 6% to the total. Valentines Day in February boosts sales to 10%, and spring break in April accounts for 7%. As Christmas shopping picks up momentum, winter sales start at 10% in October, move to 15% in November and then peak at 20% in December. This pattern of sales is not expected to change in the next two years. 2. From previous experience, management has determined that an ending inventory equal to 25% of the next month’s sales is required to fit the buyer’s demands. 3. There is only one type of raw material used in the production of Baby Turtles. R700 is a very compact material that is purchased in powder form. Each Baby Turtle requires 5 kilograms of R700, at a cost of $0.45 per kilogram. The supplier of R700 tends to be somewhat erratic so Wooden Pull Toys finds it necessary to maintain an inventory balance equal to 40% of the following month’s production needs as a precaution against stock-outs. Wooden Pull Toys pays for 20% of a month’s purchases in the month of purchase, 45% in the following month and the remaining 35% two months after the month of purchase. There is no early payment discount. 4. Beginning accounts payable will consist of $167,084 arising from the following estimated direct material purchases for November and December of 2019: R700 purchases in November 2019: $173,953 R700 purchases in December 2019 $132,750 5. Wooden Pull Toys’ manufacturing process is highly automated, so their direct labour cost is low. Employees are paid on a per unit basis. Their total pay each month is, therefore, dependent on production volumes and averages $9.00 per hour. This rate already includes the employer’s portion of employee benefits. All payroll costs are paid in the period in which they are incurred. Each unit spends a total of 18 minutes in production. 6. Due to the similarity of the equipment in each of the production stages and the company’s concentration on a single product, manufacturing overhead is allocated based on volume (i.e. the units produced). The unit variable overhead manufacturing rate is $1.30, consisting of: Utilities--$0.60; Indirect Materials--$0.20; Plant maintenance--$0.30; environmental fee--$0.14; and Other--$0.06. 7. The fixed manufacturing overhead costs for the entire year are as follows: Training and development $ 43,200 Repairs and maintenance 39,000 Supervisors’ salaries 149,400 Depreciation on equipment 178,800 Plant Insurance 96,000 Other 117,600 $ 624,000 • The annual insurance premium of $96,000 will be paid at the beginning of January. There is no change in the premium from last year. • All other “cash-related” fixed manufacturing overhead costs are incurred evenly over the year and paid as incurred. • Wooden Pull Toys uses the straight line method of depreciation. 8. Selling and administrative expenses are known to be a mixed cost; however, there is a lot of uncertainty about the portion that is fixed. Previous years’ experience has provided the following information: Lowest level of sales: 375,000 units Total Operating Expenses: $778,710 Highest level of sales: 750,000 units Total Operating Expenses: $1,022,460 These costs are paid in the month in which they occur. Not included in the above expenses is bad debt expense. 9. Sales are on a cash and credit basis, with 55% collected during the month of the sale, 35% the following month, and 9.5% the month thereafter. ½ of 1% of sales are considered uncollectible (bad debt expense). 10. Sales in November and December 2019 are expected to be $783,750 and $1,045,000 respectively. Based on the above collection pattern this will result in Accounts Receivable of $539,481 at December 31, 2019 which will be collected in January and February, 2020. 11. During the fiscal year ended December 31, 2020, Wooden Pull Toys will be required to make monthly income tax installment payments of $1,500. Outstanding income taxes from the year ended December 31, 2019 must be paid in March 2020. Income tax expense is estimated to be 25% of net income. Income taxes for the year ended December 31, 2020, in excess of installment payments, will be paid in March, 2021. 12. Wooden Pull Toys is planning to acquire additional manufacturing equipment for $304,200 cash. 40% of this amount is to be paid in January 2020, the rest, in February 2020. The manufacturing overhead costs shown above already include the depreciation on this equipment. 13. An arrangement has been made with the local bank that if Wooden Pull Toys maintains a minimum balance of $20,000 in their bank account, they will be given a line of credit at a preferred rate of 6% per annum. All borrowing is considered to happen on the first day of the month, repayments are on the last day of the month. All borrowings and repayments from the bank should be in multiples of $1,000 and interest must be paid at the end of each month. Interest is calculated on the balance at the beginning of the month, which includes any amounts borrowed that month. 14. Wooden Pull Toys Ltd. has a policy of paying dividends at the end of each quarter. The President tells you that the board of directors is planning on continuing their policy of declaring dividends of $50,000 per quarter.   15. A listing of the estimated balances in the company’s ledger accounts as of December 31, 2019 is given below: Cash $ 64,165 Accounts receivable 539,481 Inventory-raw materials 28,125 Inventory-finished goods 45,625 Capital assets (net) 724,000 $ 1,401,396 Accounts payable $ 167,084 Income tax payable 21,500 Capital stock 1,000,000 Retained earnings 212,813 $ 1,401396 ________________________________________ Required: Prepare a master budget for Wooden Pull Toys for the first quarter (January, February and March) of the year ending December 31, 2020, including the following schedules: Sales Budget Schedule of Cash Receipts Production Budget Direct Materials Budget Schedule of Cash Disbursements Direct Labour Budget Manufacturing Overhead Budget Ending Finished Goods Inventory Budget Selling and Administrative Expense Budget Cash Budget Prepare a budgeted income statement for the quarter ended March 31, 2020. Prepare a budgeted balance sheet at March 31, 2020.

Write a member function that deletes all repetitions from the bag. In your implementation, assume that items can be compared for equality using ==. Use the following header for the function:

void remove_repetitions() Here is a brief outline of an algorithm:

- A node pointer p steps through the bag

- For each Item, define a new pointer q equal to p

- While the q is not the last Item in the bag ◼ If the next Item has data equal to the data in p, remove the next Item ◼ Otherwise move q to the next Item in the bag

This is what I have so far, the issue being it doesn't delete properly and does not print out the list. Thanks in advance!

template <class Item>
void bag<Item>::remove_repetitions(){
    std::cout<<"Working progress"<<std::endl;
    node<Item> *p;
    //node<Item> *temp;
    p=head_ptr;
    while(p!=NULL && p->link()!=NULL){
        node<Item> *q;
        node<Item> *target;
        for(q=p->link(); q!=NULL; q=q->link()){
            if(p->data()==q->data()){
                target = q;
                q->set_link(q->link());
                delete(target);
            }
        }
        p=p->link();
    }
}

//The main file

#include <cstdlib>
#include <iostream>
#include <set>
#include <algorithm>
#include "node2.h"
#include "bag5.h"

using namespace std;

// PROTOTYPE for a function used by this demonstration program
template <class Item, class SizeType, class MessageType>
void get_items(bag<Item>& collection, SizeType n, MessageType description)
// Postcondition: The string description has been written as a prompt to the
// screen. Then n items have been read from cin and added to the collection.
// Library facilities used: iostream, bag4.h
{
    Item user_input; // An item typed by the program's user
    SizeType i;

    cout << "Please type " << n << " " << description;
    cout << ", separated by spaces.\n";
    cout << "Press the <return> key after the final entry:\n";
    for (i = 1; i <= n; ++i)
    {
        cin >> user_input;
        collection.insert(user_input);
    }
    cout << endl;
}

int main()
{
    //demonstrate bag template class
    bag<int> bag_of_int;
    bag<string> bag_of_string;

    bag_of_int.insert(3);
    bag_of_string.insert("hello");
    bag_of_string.insert("goodbye");
    bag_of_string.insert("auf wiedersehen");
    bag_of_string.insert("goodbye");
    bag_of_string.insert("hello");
    bag_of_string.insert("goodbye");

    cout << "count of goodbye: " << bag_of_string.count("goodbye") << endl;
    cout << "count of guten morgen: " << bag_of_string.count("guten morgen") << endl;
    cout << "count of 3: " << bag_of_int.count(3) << endl;
  

    for(bag<string>::iterator cursor = bag_of_string.begin(); cursor != bag_of_string.end(); ++cursor)
        cout<<*cursor<< " ";
    cout<<endl;
  
   bag<int> bag_int;
   bag_int.insert (7);
   bag_int.insert (6);
   bag_int.insert (5);
   bag_int.insert (4);
   bag_int.insert (5);
   bag_int.insert (3);
   bag_int.insert (2);
   bag_int.insert (1);
   bag_int.insert (1);
   bag_int.insert (5);
   bag_int.print_value_range (5,20);
   bag_int.remove_repetitions();
   bag_int.print_value_range (5,20);
   return EXIT_SUCCESS;
  
}

#ifndef NODE2_H
#define NODE2_H

//the node header file with template implementations
#include <cstdlib>   // Provides NULL and size_t
#include <iterator> // Provides iterator and forward_iterator_tag

template <class Item>
class node
{
public:
        // TYPEDEF
        typedef Item value_type;
        // CONSTRUCTOR
        node(const Item& init_data=Item( ), node* init_link=NULL)
            { data_field = init_data; link_field = init_link; }
        // MODIFICATION MEMBER FUNCTIONS
        Item& data( ) { return data_field; }
        node* link( ) { return link_field; }
        void set_data(const Item& new_data) { data_field = new_data; }
        void set_link(node* new_link) { link_field = new_link; }
        // CONST MEMBER FUNCTIONS
        const Item& data( ) const { return data_field; }
        const node* link( ) const { return link_field; }
private:
        Item data_field;
        node *link_field;
};

// FUNCTIONS to manipulate a linked list:
template <class Item>
void list_clear(node<Item>*& head_ptr);

template <class Item>
void list_copy
     (const node<Item>* source_ptr, node<Item>*& head_ptr, node<Item>*& tail_ptr);

template <class Item>
void list_head_insert(node<Item>*& head_ptr, const Item& entry);

template <class Item>
void list_head_remove(node<Item>*& head_ptr);

template <class Item>
void list_insert(node<Item>* previous_ptr, const Item& entry);

template <class Item>
std::size_t list_length(const node<Item>* head_ptr);

template <class NodePtr, class SizeType>
NodePtr list_locate(NodePtr head_ptr, SizeType position);

template <class Item>
void list_remove(node<Item>* previous_ptr);

template <class NodePtr, class Item>
NodePtr list_search(NodePtr head_ptr, const Item& target);

// FORWARD ITERATORS to step through the nodes of a linked list
// A node_iterator of can change the underlying linked list through the
// * operator, so it may not be used with a const node. The
// node_const_iterator cannot change the underlying linked list
// through the * operator, so it may be used with a const node.
// WARNING:
// This classes use std::iterator as its base class;
// Older compilers that do not support the std::iterator class can
// delete everything after the word iterator in the second line:

template <class Item>
class node_iterator : public std::iterator<std::forward_iterator_tag, Item>
{
public:
       node_iterator(node<Item>* initial = NULL){ current = initial; }
      
        Item& operator *( ) const { return current->data( ); }
      
        node_iterator& operator ++( ) // Prefix ++
        {
       current = current->link( );
       return *this;
        }
      
        node_iterator operator ++(int) // Postfix ++
        {
       node_iterator original(current);
       current = current->link( );
       return original;        
        }
      
        bool operator ==(const node_iterator other) const { return current == other.current; }
      
        bool operator !=(const node_iterator other) const { return current != other.current; }
private:
        node<Item>* current;
};

template <class Item>
class const_node_iterator : public std::iterator<std::forward_iterator_tag, const Item>
{
public:
       const_node_iterator(const node<Item>* initial = NULL) { current = initial; }
      
        const Item& operator *( ) const { return current->data( ); }
      
        const_node_iterator& operator ++( ) // Prefix ++
        {
       current = current->link( );
       return *this;
        }
      
        const_node_iterator operator ++(int) // Postfix ++
        {
       const_node_iterator original(current);
       current = current->link( );
       return original;
        }
      
        bool operator ==(const const_node_iterator other) const { return current == other.current; }
      
        bool operator !=(const const_node_iterator other) const { return current != other.current; }
private:
   const node<Item>* current;
};

#include "node2.template"

#endif // NODE2_H

#ifndef BAG5_H
#define BAG5_H

//bag header file with template
#include <cstdlib>   // Provides NULL and size_t and NULL
#include "node2.h"   // Provides node class

template <class Item>
class bag
{
public:
    // TYPEDEFS
   typedef std::size_t size_type;
        typedef Item value_type;
   typedef node_iterator<Item> iterator;
   typedef const_node_iterator<Item> const_iterator;
  
        // CONSTRUCTORS and DESTRUCTOR
        bag( );
        bag(const bag& source);
        ~bag( );
  
        // MODIFICATION MEMBER FUNCTIONS
        size_type erase(const Item& target);
        bool erase_one(const Item& target);
        void insert(const Item& entry);
        void operator +=(const bag& addend);
        void operator =(const bag& source);
        void print_value_range(const Item& x, const Item& y);
        void remove_repetitions(); //<-- Implement this!!!!!

        // CONST MEMBER FUNCTIONS
        size_type count(const Item& target) const;
        Item grab( ) const;
        size_type size( ) const { return many_nodes; }
  
   // FUNCTIONS TO PROVIDE ITERATORS
   iterator begin( )
        { return iterator(head_ptr); }
   const_iterator begin( ) const
        { return const_iterator(head_ptr); }
   iterator end( )
        { return iterator( ); } // Uses default constructor
   const_iterator end( ) const
        { return const_iterator( ); } // Uses default constructor

private:
        node<Item> *head_ptr;        // Head pointer for the list of items
        size_type many_nodes;        // Number of nodes on the list
};

// NONMEMBER functions for the bag
template <class Item>
bag<Item> operator +(const bag<Item>& b1, const bag<Item>& b2);

// The implementation of a template class must be included in its header file:
#include "bag5.template"

#endif // BAG5_H

In C++ please modify the following program and add characters (char) and names (strings) to be added to the linked list along with integers. The current demo program accepts only integer data, so you would ask the user to select the data type to be added to the linked list. The user should be given the following three choices:

(a) whole numbers

(b) single characters

(c) strings

Once the user makes a selection from the list above then your program should be able to process the data appropriately. This includes:

(a) insert

(b) print

(c) delete

(d) search

(e) copy

You will use the following existing code and modify it to process char and string data type.

Please upload .cpp file(s) along with screenshots of all solutions/screens. You can take a screenshot of your solutions by hitting PrintScreen button on your keyboard and then by pasting that image into a Word document.

Code:
//This program tests various operation of a linked list
//45 67 23 89 -999

#include  
#include  

using namespace std;

template 
struct nodeType
{
        Type info;
        nodeType *link;
};

template 
class circularLinkedList
{
public:
        //Overloads the assignment operator.
        const circularLinkedList& operator=(const circularLinkedList& otherList)
        {
                if (this != &otherList) //avoid self-copy
                {
                        copyList(otherList);
                }//end else

                return *this;
        }

        //Initializes the list to an empty state.
        //Postcondition: first = NULL, last = NULL,
        //                count = 0
        void initializeList()
        {
                destroyList();
        }

        //Function to determine whether the list is empty. 
        //Postcondition: Returns true if the list is empty; otherwise, returns false.
        bool isEmptyList()
        {
                return (first == NULL);
        }


        void print() const
        {
                nodeType *current; //pointer to traverse the list

                current = first->link;

                while (current != first) //while more data to print
                {
                        cout << current->info << " ";
                        current = current->link;
                }

                cout << first->info << " ";
        }

        //Function to return the number of nodes in the list.
        //Postcondition: The value of count is returned.
        int length()
        {
                return count;
        }


        //Function to delete all the nodes from the list.
        //Postcondition: first = NULL, last = NULL, 
        //               count = 0
        void destroyList()
        {
                nodeType *temp;
                nodeType *current = NULL;

                if (first != NULL)
                {
                        current = first->link;
                        first->link = NULL;
                }

                while (current != NULL)
                {
                        temp = current;
                        current = current->link;
                        delete temp;
                }

                first = NULL;   //initialize last to NULL; first has already
                                                //been set to NULL by the while loop
                count = 0;
        }


        //Function to return the first element of the list.
        //Precondition: The list must exist and must not be empty.
        //Postcondition: If the list is empty, then the program terminates; otherwise, the first element of the list is returned.
        Type front()
        {
                assert(first != NULL);
                return first->link->info; //return the info of the first node     
        }


        //Function to return the last element of the list.
        //Precondition: The list must exist and must not be empty.
        //Postcondition: If the list is empty, then the program terminates; otherwise, the last element of the list is returned.
        Type back()
        {
                assert(first != NULL);
                return first->info; //return the info of the first node      
        }


        //Function to determine whether searchItem is in the list.              
        //Postcondition: Returns true if searchItem is found in the list; otherwise, it returns false.
        bool search(const Type& searchItem)
        {
                nodeType *current; //pointer to traverse the list
                bool found = false;

                if (first != NULL)
                {
                        current = first->link;

                        while (current != first && !found)
                        {
                                if (current->info >= searchItem)
                                        found = true;
                                else
                                        current = current->link;

                                found = (current->info == searchItem);
                        }
                }

                return found;
        }


        void insertNode(const Type& newitem)
        {
                nodeType *current; //pointer to traverse the list
                nodeType *trailCurrent; //pointer just before current
                nodeType *newNode;  //pointer to create a node

                bool  found;

                newNode = new nodeType; //create the node

                newNode->info = newitem;   //store newitem in the node
                newNode->link = NULL;      //set the link field of the node
                                                                   //to NULL

                if (first == NULL)  //Case 1    e.g., 3
                {
                        first = newNode;
                        first->link = newNode;
                        count++;
                }
                else
                {
                        if (newitem >= first->info)//e.g., 25 > 3
                        {
                                newNode->link = first->link;
                                first->link = newNode;
                                first = newNode;
                        }
                        else
                        {
                                trailCurrent = first; //e.g., 1 < 3 
                                current = first->link;
                                found = false;

                                while (current != first && !found)
                                        if (current->info >= newitem)
                                                found = true;
                                        else
                                        {
                                                trailCurrent = current;
                                                current = current->link;
                                        }

                                trailCurrent->link = newNode;
                                newNode->link = current;
                        }

                        count++;
                }//end else
        }

        //Function to delete deleteItem from the list.
        //Postcondition: If found, the node containing deleteItem is deleted from the list, first points to the first           
        //                node, and last points to the last node of the updated list. 
        void deleteNode(const Type& deleteItem)
        {
                nodeType *current; //pointer to traverse the list
                nodeType *trailCurrent; //pointer just before current
                bool found;

                if (first == NULL)    //Case 1; list is empty. 
                        cout << "Can not delete from an empty list." << endl;
                else
                {
                        found = false;
                        trailCurrent = first;
                        current = first->link;

                        while (current != first && !found)
                                if (current->info >= deleteItem)
                                        found = true;
                                else
                                {
                                        trailCurrent = current;
                                        current = current->link;
                                }

                        if (current == first)
                        {
                                if (first->info == deleteItem)
                                {
                                        if (first == first->link)
                                                first = NULL;
                                        else
                                        {
                                                trailCurrent->link = current->link;
                                                first = trailCurrent;
                                        }
                                        delete current;

                                        count--;
                                }
                                else
                                        cout << "The item to be deleted is not in the list." << endl;
                        }
                        else
                                if (current->info == deleteItem)
                                {
                                        trailCurrent->link = current->link;
                                        count--;
                                        delete current;
                                }
                                else
                                        cout << "Item to be deleted is not in the list." << endl;
                } //end else
        }


        //Default constructor
        //Initializes the list to an empty state.               
        //Postcondition: first = NULL, last = NULL, 
        //               count = 0 
        circularLinkedList()
        {
                first = NULL;
                count = 0;
        }


        //Copy constructor
        circularLinkedList(const circularLinkedList& otherList)
        {
                first = NULL;
                copyList(otherList);
        }


        //Destructor
        //Deletes all the nodes from the list.
        //Postcondition: The list object is destroyed. 
        ~circularLinkedList()
        {
                destroyList();
        }


protected:
        int count;              //variable to store the number of elements in the list
        nodeType *first; //pointer to the first node of the list
        nodeType *last;  //pointer to the last node of the list 
private:
        //Function to make a copy of otherList.
        //Postcondition: A copy of otherList is created and assigned to this list.
        void copyList(const circularLinkedList& otherList)
        {
                nodeType *newNode;
                nodeType *current;
                nodeType *tempFirst;

                if (first != NULL)
                        destroyList();

                if (otherList.first == NULL)
                {
                        first = NULL;
                        count = 0;
                }
                else
                {
                        current = otherList.first->link;  //current points to the 
                                                                                          //list to be copied
                        count = otherList.count;

                        //copy the first node
                        tempFirst = new nodeType;  //create the node

                        tempFirst->info = current->info; //copy the info
                        last = tempFirst;                    //make last point to the 
                                                                                         //first node
                        current = current->link;     //make current point to the 
                                                                                 //next node

                                                                                 //copy the remaining list
                        while (current != otherList.first)
                        {
                                newNode = new nodeType;  //create a node
                                newNode->info = current->info;
                                last->link = newNode;
                                last = newNode;

                                current = current->link;

                        }//end while

                        if (tempFirst == last)
                        {
                                first = tempFirst;
                                first->link = first;
                        }
                        else
                        {
                                newNode = new nodeType;  //create a node
                                newNode->info = current->info;
                                last->link = newNode;
                                first = newNode;
                                first->link = tempFirst;
                        }

                }//end else
        }
};

int main()
{
        circularLinkedList list1, list2;
        int num;

        cout << "Enter number ending with -999" << endl;
        cin >> num;

        while (num != -999)
        {
                list1.insertNode(num);
                cin >> num;
        }

        cout << endl;

        cout << "List 1: ";
        list1.print();
        cout << endl;

        cout << "Length List 1: " << list1.length() << endl;

        cout << "Enter the number to be searched:  ";
        cin >> num;
        cout << endl;

        if (list1.search(num))
                cout << num << " found in the list" << endl;
        else
                cout << num << " not in the list" << endl;

        cout << "Enter the number to be deleted: ";
        cin >> num;
        cout << endl;

        list1.deleteNode(num);

        cout << "After deleting the node, "
                << "List 1: ";
        list1.print();
        cout << endl;

        cout << "Length List 1: " << list1.length() << endl;

        list2 = list1;

        cout << "List 2: ";
        list2.print();
        cout << endl;

        cout << "Length List 2: " << list2.length() << endl;

        cout << "List 1: ";
        list1.print();
        cout << endl;

        return 0;
}

In September 2002, the Financial Accounting Standards Board (FASB) of the United States published a discussion paper seeking views on whether U.S. standard setting should move from a principle based approach toward a principle based approach as sometimes associated with the International Accounting Standards Board (IASB). That paper was partly in response to the SarbanesOxley Act, which was itself a response to such accounting scandals as Enron and WorldCom. Schipper (2003) points out that the U.S. rules are often based on principles. That is, the standard setters use principles in order to produce the rules for the preparers of financial statements. Nelson (2003, 91) agrees, and suggests that a particular standard should rather be seen as more or less rules-based. He suggests that rules can increase the accuracy with which standard setters communicate their requirements and can reduce the sort of imprecision that leads to aggressive reporting choices by management. However, he notes that rules can also lead to excessive complexity and to the structuring of transactions. One of the reasons why standards on several topics need to contain rules is that the standards are inconsistent with the conceptual frameworks of the standard setters. For several topics, the use of the appropriate principle could lead to clearer communication and to more precision without the need for the current rules. That is, before asking how rules-based a particular standard should be, we should ask whether the standard is based on the most appropriate principle. I identify six topics on which the accounting standards have detailed technical rules. In each case, I suggest that part of the need for rules is caused by a lack of principle or by the use of an inappropriate principle (i.e., one that does not fit with higher-level principles). The lack of clear and appropriate principles can also lead to optional accounting methods in standards because no one policy is obviously the correct one; this leads to lack of comparability. I do not suggest that the use of appropriate principles would lead inexorably to standards with no optional methods but that, on some topics, optional methods could be eliminated. The six topics are examined one by one. In each case, I attempt to locate the principles being used, to assess the appropriateness of the principles, and then to identify any arbitrary rules or optional methods that result from the absence of appropriate principles. I start with the IASB’s standards (hereafter, IFRSs), with frequent comparison with U.S. GAAP. One reason for examining

IFRSs in particular is that they are required for the financial reporting of listed companies throughout much of the world in 2005 onward,1 and the FASB has announced plans for convergence of its standards with IFRSs.2 The final section of the paper draws conclusions about how accounting might be improved by substituting principles (or better principles) for the existing requirements. PRIOR LITERATURE AND PURPOSE OF THIS PAPER Alexander (1999) investigates the nature of principles and rules in an accounting context. Below, I use the word ìprinciplesî to include Alexanderís type A overall criteria (e.g., fair presentation, the definitions of elements of accounting and, in particular, the primacy of the asset and liability definitions) and his type B conventions (e.g., prudence). Such principles are contained in the standard settersí conceptual frameworks. I contrast this to ìrulesî which are Alexanderís type C rules (e.g., the requirement to measure inventories at the lower of cost and market). My definition of ìrulesî includes Nelsonís (2003, 91) ìspecific criteria, ëbright lineí thresholds, examples, scope restrictions, exceptions, subsequent precedents, implementation guidance, etc.î The use of the terms ìprinciplesî and ìrulesî seems broadly consistent among Alexander (1999), Nelson (2003), Schipper (2003), and me. My purpose is not to investigate why the U.S. system tends toward the writing of rules (whether based on principles or not). Identifying the roles played by the existence since the 1930s of the Securities and Exchange Commission (SEC) as an enforcement agency and the perceived need of auditors to protect themselves from litigation by encouraging the setting of clear and detailed rules is left to Benston (1976), Zeff (1995), and future research. As discussed below, the IASB also frequently writes rules. Thus, my purpose is to evaluate how the failure to use the appropriate principles can lead any standard setter to rely too much on rules. As noted earlier, the imposition of rules has some potential advantages. Those identified by Schipper (2003) and Nelson (2003) include: ï increased comparability; ï increased verifiability for auditors and regulators (and a related reduction in litigation); ï reduced opportunities for earnings management through judgments (but increased opportunities through transaction structuring); and ï improved communication of standard settersí intentions. Nelson (2003) and the American Accounting Associationís Financial Accounting Standards Committee (FASC) (2003) review the literature related to these issues. FASC concludes: Concepts-based standards, if applied properly, better support the FASBís stated mission of ìimproving the usefulness of financial reporting by focusing on the primary characteristics of relevance and reliability.î (AAA FASC 2003, 74) (emphasis added) In addition to balancing the advantages and disadvantages of more detailed rules, the standard setters sometimes face competing principles. An obvious example is the difficulty of trading off relevance and reliability: for instance, estimates of current values or future cash flows might be potentially relevant data, but some such estimates have low reliability. Departure from one principle might be justified by the need to follow another one. Standard setters are also subject to political pressure, especially from the management of large companies (e.g., Hope and Gray 1982; Solomons 1978; Watts and Zimmerman 1978; Nobes 1992; Zeff 1997). Giving way to political pressure might be an explanation for departing from principles. However, a bad standard cannot be re-classified as a good one because issuing it enabled the standard setter to survive.

As noted earlier, my purpose is to identify several accounting topics for which the accounting standard could be improved by being based more closely on a principle from the conceptual frameworks. In some cases, merely removing a rogue ìprincipleî that is not contained in the conceptual frameworks is sufficient. The improvements come in the form of increased clarity, decreased complexity, and decreased motivation for the structuring of transactions. That is, in some cases, increased clarity can be associated with a reduction in rules. This is not to say that principles-based standards are always clearer than rules-based standards. For example, development costs can represent an asset that meets reasonable recognition criteria; IAS No. 38 (para. 57) is based on this argument. In this context, the U.S. requirement (in SFAS No. 2) to expense development costs could be seen as an un-principled rule. However, in this case, the U.S. ìruleî leads to a clearer instruction and to several resulting advantages (see above), although not necessarily to a better balance sheet. Because some accounting topics are not susceptible to solution by use of appropriate principles without rules, standard setters are then forced to choose, for example, between an unclear principle and a clear rule. However, I and most other authors quoted above do not welcome rules for their own sake. They should be kept to the minimum necessary to achieve the various advantages claimed for them, such as clarity. This warrants an examination of each accounting topic to see if a more appropriate principle could achieve the advantages of rules and yet reduce the amount of rules at the same time. As mentioned earlier, the use of appropriate principles can reduce optional accounting treatments, with a consequent increase in comparability. I am not talking here of judgments by preparers, but of overt optional methods in accounting standards. Optional methods are not prevalent in U.S. accounting standards, although some exist.3 However, several options continue to exist in IFRS even after the removal of many in December 2003. The options were needed to achieve a three-quarters majority on the IASC Board, but arguing for the options was easier in the absence of clear principles. Using appropriate principles does not guarantee a reduction in options, but the discussion below finds several instances where a focus on principles can reduce options.

WHAT IS THE MAIN POINT OF THIS ARTICLE? HOW TO SUMMARY THIS?

Based on Court Case United States v. Bestfoods 113F.3d 572 (1998)

United States v. Bestfoods

113 F.3d 572 (1998)

SOUTER, JUSTICE

The United States brought this action under §107(a)(2) of the Comprehensive Environmental Response, Compensation, and Liability Act of 1980 (CERCLA) against, among others, respondent CPC International, Inc., the parent corporation of the defunct Ott Chemical Co. (Ott II), for the costs of cleaning up industrial waste generated by Ott II’s chemical plant. Section 107(a)(2) authorizes suits against, among others, “any person who at the time of disposal of any hazardous substance owned or operated any facility.” The trial focused on whether CPC, as a parent corporation, had “owned or operated” Ott II’s plant within the meaning of §107(a)(2). The District Court said that operator liability may attach to a parent corporation both indirectly, when the corporate veil can be pierced under state law, and directly, when the parent has exerted power or influence over its subsidiary by actively participating in, and exercising control over, the subsidiary’s business during a period of hazardous waste disposal. Applying that test, the court held CPC liable because CPC had selected Ott II’s board of directors and populated its executive ranks with CPC officials, and another CPC official had played a significant role in shaping Ott II’s environmental compliance policy.

The Sixth Circuit reversed. Although recognizing that a parent company might be held directly liable under §107(a)(2) if it actually operated its subsidiary’s facility in the stead of the subsidiary, or alongside of it as a joint venturer, that court refused to go further. Rejecting the District Court’s analysis, the Sixth Circuit explained that a parent corporation’s liability for operating a facility ostensibly operated by its subsidiary depends on whether the degree to which the parent controls the subsidiary and the extent and manner of its involvement with the facility amount to the abuse of the corporate form that will warrant piercing the corporate veil and disregarding the separate corporate entities of the parent and subsidiary. Applying Michigan veil-piercing law, the court decided that CPC was not liable for controlling Ott II’s actions, since the two corporations maintained separate personalities and CPC did not utilize the subsidiary form to perpetrate fraud or subvert justice.

Held:

1. When (but only when) the corporate veil may be pierced, a parent corporation may be charged with derivative CERCLA liability for its subsidiary’s actions in operating a polluting facility. It is a general principle of corporate law that a parent corporation (so-called because of control through ownership of another corporation’s stock) is not liable for the acts of its subsidiaries. CERCLA does not purport to reject this bedrock principle, and the Government has indeed made no claim that a corporate parent is liable as an owner or an operator under §107(a)(2) simply because its subsidiary owns or operates a polluting facility. But there is an equally fundamental principle of corporate law, applicable to the parent-subsidiary relationship as well as generally, that the corporate veil may be pierced and the shareholder held liable for the corporation’s conduct when, inter alia, the corporate form would otherwise be misused to accomplish certain wrongful purposes, most notably fraud, on the shareholder’s behalf. CERCLA does not purport to rewrite this well-settled rule, either, and against this venerable common-law backdrop, the congressional silence is audible. Cf. Edmonds v. Compagnie Generale Transatlantique, 443 U.S. 256, 266-267. CERCLA’s failure to speak to a matter as fundamental as the liability implications of corporate ownership demands application of the rule that, to abrogate a common-law principle, a statute must speak directly to the question addressed by the common law. United States v. Texas, 507 U.S. 529, 534.

2. A corporate parent that actively participated in, and exercised control over, the operations of its subsidiary’s facility may be held directly liable in its own right under §107(a)(2) as an operator of the facility.

(a) Derivative liability aside, CERCLA does not bar a parent corporation from direct liability for its own actions. Under the plain language of §107(a)(2), any person who operates a polluting facility is directly liable for the costs of cleaning up the pollution, and this is so even if that person is the parent corporation of the facility’s owner. Because the statute does not define the term “operate,” however, it is difficult to define actions sufficient to constitute direct parental “operation.” In the organizational sense obviously intended by CERCLA, to “operate” a facility ordinarily means to direct the workings of, manage, or conduct the affairs of the facility. To sharpen the definition for purposes of CERCLA’s concern with environmental contamination, an operator must manage, direct, or conduct operations specifically related to the leakage or disposal of hazardous waste, or decisions about compliance with environmental regulations.

(b) The Sixth Circuit correctly rejected the direct liability analysis of the District Court, which mistakenly focused on the relationship between parent and subsidiary, and premised liability on little more than CPC’s ownership of Ott II and its majority control over Ott II’s board of directors. Because direct liability for the parent’s operation of the facility must be kept distinct from derivative liability for the subsidiary’s operation of the facility, the analysis should instead have focused on the relationship between CPC and the facility itself, i.e., on whether CPC “operated” the facility, as evidenced by its direct participation in the facility’s activities. That error was compounded by the District Court’s erroneous assumption that actions of the joint officers and directors were necessarily attributable to CPC, rather than Ott II, contrary to time-honored common-law principles. The District Court’s focus on the relationship between parent and subsidiary (rather than parent and facility), combined with its automatic attribution of the actions of dual officers and directors to CPC, erroneously, even if unintentionally, treated CERCLA as though it displaced or fundamentally altered common-law standards of limited liability. The District Court’s analysis created what is in essence a relaxed, CERCLA-specific rule of derivative liability that would banish traditional standards and expectations from the law of CERCLA liability. Such a rule does not arise from congressional silence, and CERCLA’s silence is dispositive.

(c) Nonetheless, the Sixth Circuit erred in limiting direct liability under CERCLA to a parent’s sole or joint venture operation, so as to eliminate any possible finding that CPC is liable as an operator on the facts of this case. The ordinary meaning of the word “operate” in the organizational sense is not limited to those two parental actions, but extends also to situations in which, e.g., joint officers or directors conduct the affairs of the facility on behalf of the parent, or agents of the parent with no position in the subsidiary manage or direct activities at the subsidiary’s facility. Norms of corporate behavior (undisturbed by any CERCLA provision) are crucial reference points, both for determining whether a dual officer or director has served the parent in conducting operations at the facility, and for distinguishing a parental officer’s oversight of a subsidiary from his control over the operation of the subsidiary’s facility. There is, in fact, some evidence that an agent of CPC alone engaged in activities at Ott II’s plant that were eccentric under accepted norms of parental oversight of a subsidiary’s facility: The District Court’s opinion speaks of such an agent who played a conspicuous part in dealing with the toxic risks emanating from the plant’s operation. The findings in this regard are enough to raise an issue of CPC’s operation of the facility, though this Court draws no ultimate conclusion, leaving the issue for the lower courts to reevaluate and resolve in the first instance.

113 F.3d 572, vacated and remanded.

What norms of corporate behavior does the court look to in determining whether an officer or a director is involved in the operation of a facility?