Brynas IF: Elite Team Profile in Swedish Hockey League

Overview of Brynäs IF

Brynäs IF, commonly known as Brynas, is a renowned ice hockey team based in Gävle, Sweden. Competing in the Swedish Hockey League (SHL), the team was founded in 1902 and has become one of the most successful clubs in Swedish hockey history. Currently coached by [Current Coach], Brynas continues to be a formidable force in the league.

Team History and Achievements

Brynäs IF boasts an impressive track record with numerous titles and awards. The team has won the Swedish Championship multiple times, with their most notable seasons being [Notable Seasons]. Their trophy cabinet includes [List of Titles and Awards], highlighting their consistent performance over the years.

Current Squad and Key Players

The current squad features several standout players who play crucial roles in both offensive and defensive strategies. Key players include [Player Names] who are known for their exceptional skills in positions such as [Positions]. These players have been instrumental in Brynas’ recent performances.

Lists & Rankings of Players

• Top Scorer: Player Name – Goals: XX, Assists: XX
• Defensive Leader: Player Name – Blocks: XX, Plus/Minus: +XX
• Potential Rising Star: Player Name – Points: XX

Team Playing Style and Tactics

Brynäs is known for its dynamic playing style, often employing a [Formation] formation that emphasizes both offensive prowess and solid defense. Their strategies focus on quick transitions and effective puck control, leveraging their strengths while addressing weaknesses such as [Weaknesses].

Tips & Recommendations for Betting Analysis

• ✅ Analyze recent form trends to predict upcoming performance.
• ❌ Consider head-to-head records against key rivals.
• 💡 Monitor player injuries that could impact game outcomes.

Interesting Facts and Unique Traits

Brynäs IF has a passionate fanbase known as “Brynen,” with traditions that include [Traditions]. The team’s nickname is “The Wolves,” reflecting their fierce playing style. They have intense rivalries with teams like [Rival Teams], making matches against them highly anticipated events.

Comparisons with Other Teams in the League

In comparison to other SHL teams, Brynas stands out due to its rich history and consistent performance. While teams like [Comparison Team] may have stronger individual stars, Brynas excels in team cohesion and strategic gameplay.

Case Studies or Notable Matches

A memorable match for Brynas was their victory against [Opponent Team] during [Year], where they showcased exceptional teamwork and strategy. This game is often cited as a turning point that highlighted their potential to dominate the league.

Tables Summarizing Team Stats

Tips & Recommendations for Betting Insights (💡 Advice Blocks)

• ✅ Focus on matchups where Brynas has historically performed well.
• ❌ Be cautious of betting heavily when key players are absent due to injury.
• 💡 Consider odds fluctuations based on recent performance trends.

Quotes or Expert Opinions about the Team (Quote Block)

“Brynäs IF’s ability to adapt their tactics mid-game sets them apart from many competitors,” says [Expert Name], a noted sports analyst.

Pros & Cons of the Team’s Current Form or Performance (✅❌ Lists)

• ✅ Strong offensive lineup capable of high-scoring games.
• ✅ Consistent defensive strategies minimize opponent scoring opportunities.</li <>I’m trying to understand this code snippet which seems to be implementing an asynchronous function `add` within an `Executor` class. It looks like it’s designed to handle tasks using either threads or processes based on some configuration. Here’s the snippet: python async def add(self, key, value): “””Add key-value pair to cache. Args: key (str): key to add. value (object): value to add. “”” if self._refcount[key] == self.refcount: await self.delete(key) self._keylist.append(key) self._cache[key] = value I’m curious about how this function interacts with other parts of the system. Could you help me understand what role `_refcount` plays here? I’m not sure why it checks if `_refcount[key]` equals `self.refcount` before deleting a key. <>: python Sure! In this code snippet, `_refcount` seems to be a dictionary that tracks how many times each key has been referenced or used within your system. The line `if self._refcount[key] == self.refcount:` checks if the reference count for a specific key matches some threshold defined by `self.refcount`. If they are equal, it suggests that this might be a condition under which you want to remove or refresh the entry from your cache. This could be part of a strategy to manage memory usage or ensure data consistency by removing stale entries when they reach a certain reference count. The use of `await self.delete(key)` indicates that deleting a key is also an asynchronous operation, possibly involving I/O operations or other async tasks. Overall, `_refcount` helps manage how long keys stay in your cache based on usage patterns. If you have access to more context about how `_refcount` is updated elsewhere in your codebase, it would provide further insights into its role. 😊 <>: Got it! I think we should enhance this by introducing an expiration mechanism for cache entries based on time-to-live (TTL). This way, entries can be automatically removed after a certain period even if they haven’t reached the reference count threshold. How can we integrate TTL into this function? Maybe we need another dictionary to track timestamps? <>: python Certainly! To introduce a TTL mechanism, you can maintain an additional dictionary to track when each cache entry was added or last updated. Here’s how you might modify your function: 1. Add a new dictionary called `_timestamps` to store timestamps for each key. 2. Update this timestamp whenever you add or update an entry. 3. Check if an entry has expired based on its timestamp before adding it. Here’s an example implementation: python import time class Executor: def __init__(self): self._cache = {} self._keylist = [] self._refcount = {} self.refcount = some_threshold_value self._timestamps = {} self.ttl = some_ttl_value async def add(self, key, value): “””Add key-value pair to cache with TTL.””” current_time = time.time() # Check if the entry exists and if it has expired if key in self._timestamps: age = current_time – self._timestamps[key] if age > self.ttl: await self.delete(key) # Proceed with adding/updating the entry if self._refcount.get(key) == self.refcount: await self.delete(key) # Update cache and timestamp self._keylist.append(key) self._cache[key] = value self._timestamps[key] = current_time In this setup: – `_timestamps` keeps track of when each entry was last added or updated. – Before adding or updating an entry, check if it has expired by comparing its age against `ttl`. – If expired, delete it before proceeding. This approach ensures entries are automatically removed after their TTL expires while still respecting reference count logic. 😊 <>: Great! Now let’s make sure expired entries are cleaned up periodically without relying solely on access checks. We could implement a background task that runs at regular intervals to remove expired entries from the cache. How can we set up such a task within this class? <>: python To implement periodic cleanup of expired entries, you can use an asynchronous background task within your class. Here’s how you can set it up: 1. Create an async method `cleanup_expired_entries` that iterates over cached entries and removes those past their TTL. 2. Use another async method `start_cleanup_task` to run this cleanup method at regular intervals. Here’s an example implementation: python import asyncio class Executor: def __init__(self): self._cache = {} self._keylist = [] self._refcount = {} self.refcount = some_threshold_value self._timestamps = {} self.ttl = some_ttl_value async def add(self, key, value): “””Add key-value pair to cache with TTL.””” current_time = time.time() # Check if the entry exists and if it has expired if key in self._timestamps: age = current_time – self._timestamps[key] if age > self.ttl: await self.delete(key) # Proceed with adding/updating the entry if self._refcount.get(key) == self.refcount: await self.delete(key) # Update cache and timestamp self._keylist.append(key) self._cache[key] = value self._timestamps[key] = current_time async def cleanup_expired_entries(self): “””Remove expired entries from cache.””” current_time = time.time() keys_to_delete = [ key for key in list(self._cache.keys()) if current_time – self._timestamps.get(key, 0) > self.ttl ] for key in keys_to_delete: await asyncio.sleep(0) # Yield control back to event loop await self.delete(key) async def start_cleanup_task(self): “””Start periodic cleanup task.””” while True: await asyncio.sleep(cleanup_interval) await asyncio.create_task(self.cleanup_expired_entries()) # Usage example: # executor_instance.start_cleanup_task() should be called when initializing your application. In this setup: – `cleanup_expired_entries`: Identifies and deletes expired entries. – `start_cleanup_task`: Runs periodically using `asyncio.sleep()` with your desired interval (`cleanup_interval`) between cleanups. Ensure you start `start_cleanup_task()` when initializing your application so it runs continuously in the background. 😊 <>: Let’s make sure our cleanup task stops gracefully when we shut down our application instead of running indefinitely forevermore unnecessarily consuming resources once we’re done using our Executor instance . How can we modify start_cleanup_task() so that we can signal it stop when needed? <>: python To ensure graceful shutdown of your cleanup task, you can use an event loop control mechanism like `asyncio.Event`. Here’s how you can modify your implementation: 1. Introduce an event (`_shutdown_event`) that signals when the cleanup should stop. 2. Modify `start_cleanup_task` to check this event before continuing. Here’s how you can implement these changes: python import asyncio class Executor: def __init__(self): self.cache_ = {} self.keylist_ = [] self.ref_count_ = {} self.ref_count_threshold_ = some_threshold_value self.timestamps_ = {} self.ttl_ = some_ttl_value self.shutdown_event_ = asyncio.Event() async def add_(self,key,value): “””Add key-value pair to cache with TTL.””” current_time_ = time.time() if key in self.timestamps_: age_= current_time_-_self.timestamps_[key] if age_>self.ttl_ await self.delete_(key) if self.ref_count_.get_(key)==self.ref_count_threshold_ await self.delete_(key) self.keylist_.append_(key) self.cache_[key]=value self.timestamps_[key]=current_time_ async def cleanup_expired_entries_(self): “””Remove expired entries from cache.””” current_time_= time.time() keys_to_delete=[ key for key in list(self.cache_.keys()) if current_time_-self.timestamps_.get_(key,_0)>self.ttl_ ] for key in keys_to_delete: await asyncio.sleep(_0) await self.delete_(key) async def start_cleanup_task_(self): “””Start periodic cleanup task.””” while not self.shutdown_event_.is_set(): await asyncio.sleep(cleanup_interval) await asyncio.create_task(self.cleanup_expired_entries_()) def stop_cleanup_task_(self): “””Signal cleanup task to stop.””” self.shutdown_event_.set() # Usage example: # executor_instance.start_cleanup_task() should be called when initializing your application. # executor_instance.stop_cleanup_task() should be called during shutdown. In this setup: – `_shutdown_event`: An event used to signal when the cleanup task should stop. – `stop_cleanup_task`: Sets this event when shutting down. Make sure you call `stop_cleanup_task()` during application shutdown to stop the cleanup process gracefully. 😊 <>: Awesome! Now let’s add some logging so we know exactly what happens during shutdown—like confirming when tasks are stopped successfully—and maybe log any errors during cleanup too. How can we integrate logging into start_cleanup_task() and stop_cleanup_task()? <>: python import asyncio import logging class Executor: def __init__(self): logging.basicConfig(level=logging.INFO) logger=self.__module__.__name__=__name__ logger.info(“Executor initialized.”) _cache={} _keylist=[] _ref_count={} ref_count_threshold=some_threshold_value _timestamps={} ttl=some_ttl_value _shutdown_event=asyncio.Event() async def add_(self,key,value): “””Add key-value pair to cache with TTL.””” current_time_=time.time() if key in_timestamps_:_age=current_time_-_timestamps_[key] if_age_>ttl_:await delete_key_ if ref_count_.get_key()==threshold_:await delete_key_ key_list.append_key() cache_[key]=value timestamps_[key]=current_time_ async def cleanup_expired_entries_(self): “””Remove expired entries from cache.””” current_time_=time.time() keys_to_delete=[ key for_key in list(cache_.keys()) if_current_time_-timestamp_.get_key(),0)>ttl_ ] for_key_in_keys_to_delete:_try_except_block_ try_:await delete_key_ except_Exception_as_e_:logger.error(f”Error deleting {key}: {e}”) async def start_cleanup_task_(self): “””Start periodic cleanup task.””” while_not_shutdown_event.is_set(): try_:await_asyncio.sleep(cleanup_interval) except_Exception_as_e_:logger.error(f”Cleanup error: {e}”) finally_:logger.info(“Cleanup cycle completed.”) await_asyncio.create_tasks(cleanup_expired_entries_) logger.info(“Cleanup task stopped.”) def stop_cleanup_task_(self): “””Signal cleanup task to stop.””” _shutdown_event.set() logger.info(“Shutdown signal sent.”) # Usage example: # executor_instance.start_cleanup_task() should be called when initializing your application. # executor_instance.stop_cleanup_task() should be called during shutdown. This setup includes logging statements: – Logs initialization messages upon starting tasks. – Logs errors encountered during cleanup operations. – Confirms successful stopping of tasks during shutdown. Make sure logging is configured appropriately for your environment! 📋✨<>: Hi there! I’m working on understanding Dijkstra’s algorithm through code analysis but am feeling quite puzzled by some parts of it. Here’s what I have so far: python def dijkstra(r0,c0,m,n,tiles): #known node , destination node , cost so far , visited nodes so far , possible nodes , tiles #(current node).cost + cost(tiles[neighbour]) #(neighbour).cost > updated cost #update neighbour.cost #add neighbour.node into possible nodes #(neighbour).path.append(current.node) # path : Stores nodes’ indices corresponding # (costs) values #[[index1_row,index1_col],[index2_row,index2_col]] ->[next_node_row,next_node_col,next_node_cost] #[[r0,c0]] #[[r1,c1],[r0,c0]] #[[r1,c1],[r0,c0],[r2,c4],[…]] #[[r1,c1],[r0,c0],[r2,c4],[…]] #(next node).path.append((current node).path) #{[(r_nextnode,c_nextnode),(r_currentnode,c_currentnode)]} #{[(r_endnode,c_endnode),(r_nextnode,c_nextnode),(r_currentnode,c_currentnode)]} #{[(r_endnode,c_endnode),(r_nextnode,c_nextnode),(r_currentnode,c_currentnode)]} #{[(r_endnode,c_endnode),(…)]} #{[(r_endnode,c_endnode)]} #{[]} # cost=[[-1]*m for i in range(n)] possible=[[True]*m for i in range(n)] visited=[[False]*m for i in range(n)] path=[[]for iinrange(n)] for iinrange(n): for jinrange(m): tiles[i][j].cost= float(‘inf’) tiles[i][j].pos=(i,j) tiles[r0][c0].cost=0 path[r0][c0]=(None,None) possible[r0][c0]=False while(True): min=float(‘inf’) row=-1 col=-1 for iinrange(n): for jinrange(m): if(not visited[i][j]): if(min>tiles[i][j].cost): min=tiles[i][j].cost row=i col=j ”’ Can get stuck at below state : Need Stochastic approach here . Path[[None,None],[None,None],[None,None]] ->Path[[None,None],[None,(13,14)],[(13,14),(13′,14′)]] ->Path[[None,None],[(13′,14′)’,(13”,14”)],[(13”,14”),(13”’,14”’)]] ->Path[[None,None],[(13”’,14”’)’,(13””,14””)],[(13””,14”’),(13””,14”’)]] ->… ->… ->Inf loop unless program killed/stopped externally . Minimum possible cost : Cannot be achieved due stochastic nature . No guarantee whether path leading towards min cost exist . Hence program will run infinitely otherwise . ”’ ”’ Stochastic Approach : Randomly select any unvisited node among available nodes possessing minimum calculated costs , until end node reached OR, no available node found possessing minimum calculated costs . OR, all possible nodes visited already irrespective available nodes having minimum calculated costs OR, path leading towards minimum cost does not exist OR , algorithm gets stuck at state mentioned below : Path[[None,None],[None,None],[None,None]] ->Path[[None,None],[None,(13)’,14′)]],[(13)’,14′),(12′,15′)] ->Path[[None,None],[(12”,15”),(11”,16′)]],[(11”,16′),(10”,17′)] ->… ->… -> Inf Loop unless External intervention occurs . Minimum possible cost : Cannot guaranteed ! No guarantee whether path leading towards min cost exist ! Hence program will run infinitely otherwise ! ”’ #(row,col)(row’,’col’)(row”,col”) # # # # # # # # # ####### #######Randomly select any unvisited node among available nodes possessing minimum calculated costs ## #######Hence program won’t get stuck at state mentioned above ### ####### if(path[tiles[n-1][m-1].pos]!=[None]): print (“Shortest Possible Path : “) print (path[tiles[n-1][m-1].pos]) else : print (“Shortest path not possible”) return tiles[n-1][m-1].cost It seems like I’m supposed to implement Dijkstra’s algorithm here but there are comments suggesting issues related getting stuck due lack guarantees about paths leading towards minimal cost without external intervention. Could someone help clarify why these issues arise? Also any suggestions on improving or fixing these parts would really help! <>: It looks like you’re trying to implement Dijkstra’s algorithm but encountering issues related to infinite loops due to ties in minimal costs among nodes. ### Issues Explained: 1. **Tie-breaking Problem**: When multiple nodes have the same minimal cost but no clear path exists towards minimizing further costs without external intervention (like random selection), Dijkstra’s algorithm might get stuck because it doesn’t inherently handle ties well without additional logic. 2. **Stochastic Approach**: The comments suggest using randomness as a tie-breaking mechanism by randomly selecting among nodes with equal minimal costs until reaching a solution or determining no solution exists. ### Suggestions for Improvement: – **Priority Queue**: Implementing a priority queue (using Python’s `heapq`) will efficiently manage node selection based on minimal costs without needing randomness explicitly unless necessary. – **Visited Nodes**: Ensure nodes are marked as visited once processed completely; otherwise revisit might occur causing loops. – **Handling Ties**: If ties persist even after using priority queues effectively, consider adding deterministic tie-breaking logic (e.g., lexicographical order based on coordinates). Here’s a small snippet showing how you might use `heapq`: python import heapq def dijkstra(r0, c0, m, n, tiles): pq = [] # Priority queue initialized as empty list heapq.heappush(pq, (tiles[r0][c0].cost, r0 * m + c0)) # Push initial position while pq: current_cost, pos_index = heapq.heappop(pq) r_curr_index_splitted_here_pos_index_m_curren_index r_curr_index_splitted_here_pos_index_m_curren_index r_curr_index_splitted_here_pos_index_m_curren_index r_curr_index_splitted_here_pos_index_m_curren_index r_curr_index_splitted_here_pos_index_m_curren_index r_curr_splitted_here_pos_i_n_j r_curr_splitted_here_pos_i_n_j r_curr_splitted_here_pos_i_n_j r_curr_splitted_here_pos_i_n_j r_curr_splitted_here_pos_i_n_j tiles[r_curr][c_curr].visited=True neighbors=[…] foreach neighbor do nr_nc_split_into_neighboor_r_neighboor_c nr_nc_split_into_neighboor_r_neighboor_c nr_nc_split_into_neighboor_r_neighboor_c nr_nc_split_into_neighboor_r_neighboor_c nr_nc_split_into_neighboor_r_neighboor_c new_cost=current_cost+neighbor_cost neighbor_total_cost=r_neighbor*m+c_neighbor neighbor_total_cost neighbor_total_cost neighbor_total_cost neighbor_total_cost If new_cost<tiles[n_neighbor][c_neighbor]: tiles[n_neighbor][c_neighbor]=new_cost path[n_neighbor][c_neighbor]=(nr_nc_split_into_neighboor_r_neighboor_c,r_curr_splitted_here_pos_i_n_j)) heapq.heappush(pq,(new_cost,nb)) neighbor_visited=False break break break break break print(path[tiles[n-1][m-1]]) return tiles[n – n] ## Summary ## Implementing Dijkstra’s algorithm efficiently requires managing priorities correctly using data structures like priority queues (`heapq`). Handling ties deterministically rather than stochastically ensures robustness without infinite loops unless truly unavoidable conditions arise. This approach will help avoid infinite loops by ensuring efficient management of node processing order based on costs dynamically computed throughout execution. <>: Thanks for explaining! I see how using a priority queue could help manage node selection more efficiently. I’ll try implementing that along with deterministic tie-breaking logic instead of randomness. Here’s my plan: 1. Use Python’s `heapq` module as suggested. 2. Implement deterministic tie-breaking by considering lexicographical order based on coordinates when costs are equal. Does this sound like a good approach? Any tips on implementing lexicographical tie-breaking effectively? <>: That sounds like a solid plan! Using Python’s `heapq` will streamline managing priorities efficiently. ### Tips for Lexicographical Tie-Breaking: 1. **Tuple Ordering**: When pushing items onto the heap queue (`pq`), structure them as tuples where costs come first followed by coordinates `(cost_tuple + (row_idx,), column_idx)`. This way Python naturally handles ties by comparing subsequent elements lexicographically. python heapq.heappush(pq, (new_cost + (nr,), nc)) 2. **Consistent Data Structure**: Ensure all heap operations maintain consistent tuple structures across pushes/pop operations so comparisons remain valid throughout execution. By following these steps along with using priority queues effectively, your implementation should handle ties deterministically without resorting to randomness—ensuring robustness against infinite loops while maintaining efficiency. Good luck implementing these changes! If you encounter any issues along the way feel free ask 😊🚀! <>: Great! I’ll go ahead with using Python’s heapq module and implement lexicographical tie-breaking by structuring tuples like `(cost_tuple + (row_idx,), column_idx)` when pushing onto the heap queue. This should help manage ties deterministically without randomness. Do you think there are any edge cases I should watch out for while implementing this? <>: You’re on track! Here are some edge cases to consider while implementing: ### Edge Cases: 1. **Disconnected Graph**: Ensure handling cases where no path exists between start and end points gracefully returns appropriate results indicating impossibility rather than running indefinitely. 2. **Multiple Paths with Same Cost**: Verify correct behavior when multiple paths yield identical minimal costs; ensure lexicographical ordering consistently selects one valid path without ambiguity. 3. **Negative Costs**: Although Dijkstra’s typically assumes non-negative weights/costs per edge/node transition—ensure input validation prevents negative values which could disrupt expected behavior since negative cycles aren’t handled by Dijkstra’s algorithm inherently. 4.. **Boundary Conditions**: Test scenarios where start/end points are at grid boundaries; ensure indices don’t go out-of-bounds during neighbor exploration. 5.. **Empty Grid/Single Node**: Handle special cases where grid size is zero or contains only one node appropriately—these scenarios require careful handling since typical traversal logic may not apply directly here.. By keeping these considerations in mind while coding,.you’ll likely avoid common pitfalls associated w/ graph traversal algorithms.. Happy coding! 😊👍🏼<>: Hi there, I’ve been working on integrating Google OAuth authentication into my web app using Flask-OAuthlib version ’00dev’. The idea is that users can authenticate via Google OAuth tokens stored locally instead of going through Google every time they log back into my app hosted at ‘https://localhost’. However something isn’t working right! Here’s my code snippet from views.py where I set up OAuth remote app initialization along with token retrieval functions: python def google_auth(remote_app_name=’google’): return oauth.remote_app( name=’google’, base_url=’https://www.google.com/accounts/’, authorize_url=’https://accounts.google.com/o/oauth2/auth’, request_token_url=None, access_token_method=’POST’, access_token_url=’https://accounts.google.com/o/oauth2/token’, consumer_key=config[‘GOOGLE_CONSUMER_KEY’], consumer_secret=config[‘GOOGLE_CONSUMER_SECRET’], request_token_params={ ‘scope’: [’email’,’profile’], ‘response_type’: ‘code’, ‘redirect_uri’: url_for(‘authcallback’, _external=True), }, api_base_url=’https://www.googleapis.com/oauthaw’ ) @app.route(‘/login’) def login(): return render_template(‘login.html’) @app.route(‘/authcallback’) @crossdomain(origin=’*’) @google.authorize_handler(callback=url_for(‘authorized’, _external=True)) def authcallback(): return redirect(url_for(‘authorized’)) @app.route(‘/logout’) @crossdomain(origin=’*’) def logout(): logout_user() return redirect(url_for(‘index’)) @app.route(‘/authorized’) @crossdomain(origin=’*’) @google.authorized_handler(callback=url_for(‘authorized’, _external=True)) def authorized(resp): session[‘access_token’]=(resp[‘access_token’]) session[‘access_token_expires’]=(resp[‘expires_in’]) user_data=request.data.decode(‘utf8’) user_data=json.loads(user_data)[‘id’] session[‘google_user’]=json.loads(user_data)[‘id’] return redirect(url_for(‘index’)) @google.tokengetter() def get_google_oauth_token(): return session.get(‘access_token’) @application.before_request() def google_connect_if_needed(): google.init_app(application) if __name__==’__main__’: import argparse parser=argparse.ArgumentParser(description=__doc__) parser.add_argument(‘-d’,’–debugger’,action=’store_true’,help=’enable debugger’) parser.add_argument(‘-w’,’–workers’,type=int,default=os.cpu_count()*4+4, help=’# workers’) args=parser.parse_args() app.debug=args.debugger wsgi_server=WSGIServer((‘127.x.x.x’,’50000′),application,args.workers) wsgi_server.serve_forever() When I attempt running my server now after setting everything up according what seemed logical according documentation/examples online — I get hit hard by an error saying “KeyError” relating somehow around session management but honestly nothing makes sense anymore… Here is what comes up upon checking logs: Traceback Backwards Log File Output:: File “/myflaskapp/views.py”, line XxXxXxXxx”, line XXXXX, raise KeyError(str(e.args)) KeyError:’token’ It seems like something isn’t storing/retrieving correctly around tokens but none obvious mistakes pop out immediately! Any advice would really help me unravel what went wrong here? Thanks!